ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/Development/ray/src/common/bsdf.h

Comparing ray/src/common/bsdf.h (file contents):
Revision 2.8 by greg, Mon Feb 21 22:50:37 2011 UTC vs.
Revision 2.21 by greg, Sat Jan 26 04:00:25 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
40	<	/* Component flags for SDsampBSDF() and SDhemiScatter() */
40	>	/* Component flags for SDsampBSDF() and SDdirectHemi() */
41		#define SDsampR         0x1             /* include reflection */
42		#define SDsampT         0x2             /* include transmission */
43		#define SDsampS         0x3             /* include scattering (R+T) */
#	Line 44 | Line 48 | extern "C" {
48		#define SDsampSpS       0x7             /* include non-diffuse scattering */
49		#define SDsampAll       0xF             /* include everything */
50
51	<	/* Projected solid angle query flags fos SDsizeBSDF() */
51	>	/* Projected solid angle query flags for SDsizeBSDF() */
52		#define SDqueryVal      0x0             /* query single value */
53		#define SDqueryMin      0x1             /* query minimum proj. solid angle */
54		#define SDqueryMax      0x2             /* query maximum proj. solid angle */
#	Line 67 | 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
#	Line 81 | Line 87 | typedef struct SDComp_s        SDComponent;
87		typedef const struct {
88		/* return non-diffuse BSDF */
89		int             (*getBSDFs)(float coef[SDmaxCh], const FVECT outVec,
90	<	const FVECT inVec, const void *dist);
90	>	const FVECT inVec, SDComponent *sdc);
91		/* query non-diffuse PSA for vector */
92	<	SDError         (*queryProjSA)(double *psa, const FVECT vec,
93	<	int qflags, const void *dist);
92	>	SDError         (*queryProjSA)(double *psa, const FVECT v1,
93	>	const RREAL *v2, int qflags,
94	>	SDComponent *sdc);
95		/* get cumulative distribution */
96		const SDCDst    *(*getCDist)(const FVECT inVec, SDComponent *sdc);
97		/* sample cumulative distribution */
98	<	SDError         (*sampCDist)(FVECT outVec, double randX,
98	>	SDError         (*sampCDist)(FVECT ioVec, double randX,
99		const SDCDst *cdp);
100		/* free a spectral BSDF component */
101		void            (*freeSC)(void *dist);
#	Line 112 | Line 119 | typedef struct {
119
120		/* Loaded BSDF data */
121		typedef struct {
122	<	char            name[SDnameLn]; /* BSDF name (derived from file) */
122	>	char            name[SDnameLn]; /* BSDF name (usu. derived from file) */
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) */
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 */
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 129 | 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
149		/*****************************************************************
150		* The following routines are less commonly used by applications.
#	Line 151 | Line 161 | extern void            SDclipName(char res[SDnameLn], const char
161		/* Allocate new spectral distribution function */
162		extern SDSpectralDF     *SDnewSpectralDF(int nc);
163
164	+	/* Add component(s) to spectral distribution function */
165	+	extern SDSpectralDF     *SDaddComponent(SDSpectralDF *odf, int nadd);
166	+
167		/* Free a spectral distribution function */
168		extern void             SDfreeSpectralDF(SDSpectralDF *df);
169
170	<	/* Initialize an unused BSDF struct (clears to zeroes) */
171	<	extern void             SDclearBSDF(SDData *sd);
170	>	/* Initialize an unused BSDF struct and assign name (calls SDclipName) */
171	>	extern void             SDclearBSDF(SDData *sd, const char *fname);
172
173		/* Load a BSDF struct from the given file (keeps name unchanged) */
174		extern SDError          SDloadFile(SDData *sd, const char *fname);
#	Line 170 | Line 183 | extern SDData          *SDgetCache(const char *bname);
183		extern void             SDfreeCumulativeCache(SDSpectralDF *df);
184
185		/* Sample an individual BSDF component */
186	<	extern SDError          SDsampComponent(SDValue *sv, FVECT outVec,
187	<	const FVECT inVec, double randX,
175	<	SDComponent *sdc);
186	>	extern SDError          SDsampComponent(SDValue *sv, FVECT ioVec,
187	>	double randX, SDComponent *sdc);
188
189		/* Convert 1-dimensional random variable to N-dimensional */
190		extern void             SDmultiSamp(double t[], int n, double randX);
191
192		/* Map a [0,1]^2 square to a unit radius disk */
193	<	void                    SDsquare2disk(double ds[2], double seedx, double seedy);
193	>	extern void             SDsquare2disk(double ds[2], double seedx, double seedy);
194
195		/* Map point on unit disk to a unit square in [0,1]^2 range */
196	<	void                    SDdisk2square(double sq[2], double diskx, double disky);
196	>	extern void             SDdisk2square(double sq[2], double diskx, double disky);
197
198		/*****************************************************************
199		* The calls below are the ones most applications require.
#	Line 189 | Line 201 | void                   SDdisk2square(double sq[2], double diskx, doubl
201		*/
202
203		/* Get BSDF from cache (or load and cache it on first call) */
204	<	/* Report any problems to stderr and return NULL on failure */
204	>	/* Report any problems to stderr (in English), return NULL on failure */
205		extern const SDData     *SDcacheFile(const char *fname);
206
207	<	/* Free a BSDF from our cache (clear all if NULL) */
207	>	/* Free a BSDF from our cache (clear all if sd==NULL) */
208		extern void             SDfreeCache(const SDData *sd);
209
210	<	/* Query projected solid angle resolution for non-diffuse BSDF direction */
211	<	extern SDError          SDsizeBSDF(double *projSA, const FVECT vec,
212	<	int qflags, const SDData *sd);
210	>	/* Query projected solid angle resolution for non-diffuse BSDF direction(s) */
211	>	extern SDError          SDsizeBSDF(double *projSA, const FVECT v1,
212	>	const RREAL *v2, int qflags,
213	>	const SDData *sd);
214
215		/* Return BSDF for the given incident and scattered ray vectors */
216		extern SDError          SDevalBSDF(SDValue *sv, const FVECT outVec,
#	Line 208 | Line 221 | extern double          SDdirectHemi(const FVECT inVec,
221		int sflags, const SDData *sd);
222
223		/* Sample BSDF direction based on the given random variable */
224	<	extern SDError          SDsampBSDF(SDValue *sv, FVECT outVec,
212	<	const FVECT inVec, double randX,
224	>	extern SDError          SDsampBSDF(SDValue *sv, FVECT ioVec, double randX,
225		int sflags, const SDData *sd);
226
227		/*****************************************************************
#	Line 217 | Line 229 | extern SDError         SDsampBSDF(SDValue *sv, FVECT outVec,
229		* Directions may be passed unnormalized to these routines.
230		*/
231
232	<	/* Compute World->BSDF transform from surface normal and up (Y) vector */
232	>	/* Compute World->BSDF transform from surface normal and BSDF up vector */
233		extern SDError          SDcompXform(RREAL vMtx[3][3], const FVECT sNrm,
234		const FVECT uVec);
235
#	Line 228 | Line 240 | extern SDError         SDinvXform(RREAL iMtx[3][3], RREAL vMt
240		extern SDError          SDmapDir(FVECT resVec, RREAL vMtx[3][3],
241		const FVECT inpVec);
242
243	<	/* System-specific BSDF loading routine (not part of our library) */
243	>	/* Application-specific BSDF loading routine (not part of our library) */
244		extern SDData           *loadBSDF(char *name);
245
246	<	/* System-specific BSDF error translator (not part of our library) */
246	>	/* Application-specific BSDF error translator (not part of our library) */
247		extern char             *transSDError(SDError ec);
236	–
237	–	/*################################################################*/
238	–	/*######### DEPRECATED DEFINITIONS AWAITING PERMANENT REMOVAL #######*/
239	–	/*
240	–	* Header for BSDF i/o and access routines
241	–	*/
242	–
243	–	#include "mat4.h"
244	–	/* up directions */
245	–	typedef enum {
246	–	UDzneg=-3,
247	–	UDyneg=-2,
248	–	UDxneg=-1,
249	–	UDunknown=0,
250	–	UDxpos=1,
251	–	UDypos=2,
252	–	UDzpos=3
253	–	} UpDir;
254	–	/* BSDF coordinate calculation routines */
255	–	/* vectors always point away from surface */
256	–
257	–	typedef int     b_vecf2(FVECT v, int n, void *cd);
258	–	typedef int     b_ndxf2(FVECT v, void *cd);
259	–	typedef double  b_radf2(int n, void *cd);
260	–
261	–	/* Bidirectional Scattering Distribution Function */
262	–	struct BSDF_data {
263	–	int     ninc;                   /* number of incoming directions */
264	–	int     nout;                   /* number of outgoing directions */
265	–	float   dim[3];                 /* width, height, thickness (meters) */
266	–	char    *mgf;                   /* geometric description (if any) */
267	–	void    *ib_priv;               /* input basis private data */
268	–	b_vecf2 *ib_vec;                /* get input vector from index */
269	–	b_ndxf2 *ib_ndx;                /* get input index from vector */
270	–	b_radf2 *ib_ohm;                /* get input radius for index */
271	–	void    *ob_priv;               /* output basis private data */
272	–	b_vecf2 *ob_vec;                /* get output vector from index */
273	–	b_ndxf2 *ob_ndx;                /* get output index from vector */
274	–	b_radf2 *ob_ohm;                /* get output radius for index */
275	–	float   *bsdf;                  /* scattering distribution data */
276	–	};                              /* bidirectional scattering distrib. func. */
277	–
278	–	#define getBSDF_incvec(v,b,i)   (*(b)->ib_vec)(v,i,(b)->ib_priv)
279	–	#define getBSDF_incndx(b,v)     (*(b)->ib_ndx)(v,(b)->ib_priv)
280	–	#define getBSDF_incohm(b,i)     (*(b)->ib_ohm)(i,(b)->ib_priv)
281	–	#define getBSDF_outvec(v,b,o)   (*(b)->ob_vec)(v,o,(b)->ob_priv)
282	–	#define getBSDF_outndx(b,v)     (*(b)->ob_ndx)(v,(b)->ob_priv)
283	–	#define getBSDF_outohm(b,o)     (*(b)->ob_ohm)(o,(b)->ob_priv)
284	–	#define BSDF_value(b,i,o)       (b)->bsdf[(o)*(b)->ninc + (i)]
285	–
286	–	extern struct BSDF_data *load_BSDF(char *fname);
287	–	extern void free_BSDF(struct BSDF_data *b);
288	–	extern int r_BSDF_incvec(FVECT v, struct BSDF_data *b, int i,
289	–	double rv, MAT4 xm);
290	–	extern int r_BSDF_outvec(FVECT v, struct BSDF_data *b, int o,
291	–	double rv, MAT4 xm);
292	–	extern int getBSDF_xfm(MAT4 xm, FVECT nrm, UpDir ud, char *xfbuf);
293	–
294	–	/*######### END DEPRECATED DEFINITIONS #######*/
295	–	/*################################################################*/
248
249		#ifdef __cplusplus
250		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)