ViewVC Help

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

root/radiance/ray/src/common/bsdf.c

Comparing ray/src/common/bsdf.c (file contents):
Revision 2.7 by greg, Tue Sep 7 23:10:50 2010 UTC vs.
Revision 2.46 by greg, Thu Jul 4 15:14:45 2013 UTC

#	Line 2 | Line 2
2		static const char RCSid[] = "$Id$";
3		#endif
4		/*
5	<	* Routines for handling BSDF data
5	>	*  bsdf.c
6	>	*
7	>	*  Definitions for bidirectional scattering distribution functions.
8	>	*
9	>	*  Created by Greg Ward on 1/10/11.
10	>	*
11		*/
12
13	<	#include "standard.h"
14	<	#include "bsdf.h"
15	<	#include "paths.h"
16	<	#include "ezxml.h"
13	>	#define _USE_MATH_DEFINES
14	>	#include <stdio.h>
15	>	#include <stdlib.h>
16	>	#include <string.h>
17	>	#include <math.h>
18		#include <ctype.h>
19	+	#include "ezxml.h"
20	+	#include "hilbert.h"
21	+	#include "bsdf.h"
22	+	#include "bsdf_m.h"
23	+	#include "bsdf_t.h"
24
25	<	#define MAXLATS         46              /* maximum number of latitudes */
25	>	/* English ASCII strings corresponding to ennumerated errors */
26	>	const char              *SDerrorEnglish[] = {
27	>	"No error",
28	>	"Memory error",
29	>	"File input/output error",
30	>	"File format error",
31	>	"Illegal argument",
32	>	"Invalid data",
33	>	"Unsupported feature",
34	>	"Internal program error",
35	>	"Unknown error"
36	>	};
37
38	<	/* BSDF angle specification */
39	<	typedef struct {
18	<	char    name[64];               /* basis name */
19	<	int     nangles;                /* total number of directions */
20	<	struct {
21	<	float   tmin;                   /* starting theta */
22	<	short   nphis;                  /* number of phis (0 term) */
23	<	}       lat[MAXLATS+1];         /* latitudes */
24	<	} ANGLE_BASIS;
38	>	/* Pointer to error list in preferred language */
39	>	const char              **SDerrorList = SDerrorEnglish;
40
41	<	#define MAXABASES       7               /* limit on defined bases */
41	>	/* Additional information on last error (ASCII English) */
42	>	char                    SDerrorDetail[256];
43
44	<	static ANGLE_BASIS      abase_list[MAXABASES] = {
45	<	{
30	<	"LBNL/Klems Full", 145,
31	<	{ {-5., 1},
32	<	{5., 8},
33	<	{15., 16},
34	<	{25., 20},
35	<	{35., 24},
36	<	{45., 24},
37	<	{55., 24},
38	<	{65., 16},
39	<	{75., 12},
40	<	{90., 0} }
41	<	}, {
42	<	"LBNL/Klems Half", 73,
43	<	{ {-6.5, 1},
44	<	{6.5, 8},
45	<	{19.5, 12},
46	<	{32.5, 16},
47	<	{46.5, 20},
48	<	{61.5, 12},
49	<	{76.5, 4},
50	<	{90., 0} }
51	<	}, {
52	<	"LBNL/Klems Quarter", 41,
53	<	{ {-9., 1},
54	<	{9., 8},
55	<	{27., 12},
56	<	{46., 12},
57	<	{66., 8},
58	<	{90., 0} }
59	<	}
60	<	};
44	>	/* Empty distribution for getCDist() calls that fail for some reason */
45	>	const SDCDst            SDemptyCD;
46
47	<	static int      nabases = 3;    /* current number of defined bases */
47	>	/* Cache of loaded BSDFs */
48	>	struct SDCache_s        *SDcacheList = NULL;
49
50	<	#define  FEQ(a,b)       ((a)-(b) <= 1e-7 && (b)-(a) <= 1e-7)
50	>	/* Retain BSDFs in cache list */
51	>	int                     SDretainSet = SDretainNone;
52
53	<	// returns the name of the given tag
54	<	#ifdef ezxml_name
55	<	#undef ezxml_name
69	<	static char *
70	<	ezxml_name(ezxml_t xml)
53	>	/* Report any error to the indicated stream */
54	>	SDError
55	>	SDreportError(SDError ec, FILE *fp)
56		{
57	<	if (xml == NULL)
58	<	return(NULL);
59	<	return(xml->name);
57	>	if (!ec)
58	>	return SDEnone;
59	>	if ((ec < SDEnone) | (ec > SDEunknown)) {
60	>	SDerrorDetail[0] = '\0';
61	>	ec = SDEunknown;
62	>	}
63	>	if (fp == NULL)
64	>	return ec;
65	>	fputs(SDerrorList[ec], fp);
66	>	if (SDerrorDetail[0]) {
67	>	fputs(": ", fp);
68	>	fputs(SDerrorDetail, fp);
69	>	}
70	>	fputc('\n', fp);
71	>	if (fp != stderr)
72	>	fflush(fp);
73	>	return ec;
74		}
76	–	#endif
75
76	<	// returns the given tag's character content or empty string if none
77	<	#ifdef ezxml_txt
78	<	#undef ezxml_txt
79	<	static char *
82	<	ezxml_txt(ezxml_t xml)
76	>	static double
77	>	to_meters(              /* return factor to convert given unit to meters */
78	>	const char *unit
79	>	)
80		{
81	<	if (xml == NULL)
82	<	return("");
83	<	return(xml->txt);
81	>	if (unit == NULL) return(1.);           /* safe assumption? */
82	>	if (!strcasecmp(unit, "Meter")) return(1.);
83	>	if (!strcasecmp(unit, "Foot")) return(.3048);
84	>	if (!strcasecmp(unit, "Inch")) return(.0254);
85	>	if (!strcasecmp(unit, "Centimeter")) return(.01);
86	>	if (!strcasecmp(unit, "Millimeter")) return(.001);
87	>	sprintf(SDerrorDetail, "Unknown dimensional unit '%s'", unit);
88	>	return(-1.);
89		}
88	–	#endif
90
91	<
92	<	static int
93	<	ab_getvec(              /* get vector for this angle basis index */
93	<	FVECT v,
94	<	int ndx,
95	<	void *p
96	<	)
91	>	/* Load geometric dimensions and description (if any) */
92	>	static SDError
93	>	SDloadGeometry(SDData *sd, ezxml_t wtl)
94		{
95	<	ANGLE_BASIS  *ab = (ANGLE_BASIS *)p;
96	<	int     li;
97	<	double  pol, azi, d;
98	<
99	<	if ((ndx < 0) | (ndx >= ab->nangles))
100	<	return(0);
101	<	for (li = 0; ndx >= ab->lat[li].nphis; li++)
102	<	ndx -= ab->lat[li].nphis;
103	<	pol = PI/180.*0.5*(ab->lat[li].tmin + ab->lat[li+1].tmin);
104	<	azi = 2.*PI*ndx/ab->lat[li].nphis;
105	<	v[2] = d = cos(pol);
106	<	d = sqrt(1. - d*d);     /* sin(pol) */
107	<	v[0] = cos(azi)*d;
108	<	v[1] = sin(azi)*d;
109	<	return(1);
95	>	ezxml_t         node, matl, geom;
96	>	double          cfact;
97	>	const char      *fmt = NULL, *mgfstr;
98	>
99	>	SDerrorDetail[0] = '\0';
100	>	sd->matn[0] = '\0'; sd->makr[0] = '\0';
101	>	sd->dim[0] = sd->dim[1] = sd->dim[2] = 0;
102	>	matl = ezxml_child(wtl, "Material");
103	>	if (matl != NULL) {                     /* get material info. */
104	>	if ((node = ezxml_child(matl, "Name")) != NULL) {
105	>	strncpy(sd->matn, ezxml_txt(node), SDnameLn);
106	>	if (sd->matn[SDnameLn-1])
107	>	strcpy(sd->matn+(SDnameLn-4), "...");
108	>	}
109	>	if ((node = ezxml_child(matl, "Manufacturer")) != NULL) {
110	>	strncpy(sd->makr, ezxml_txt(node), SDnameLn);
111	>	if (sd->makr[SDnameLn-1])
112	>	strcpy(sd->makr+(SDnameLn-4), "...");
113	>	}
114	>	if ((node = ezxml_child(matl, "Width")) != NULL)
115	>	sd->dim[0] = atof(ezxml_txt(node)) *
116	>	to_meters(ezxml_attr(node, "unit"));
117	>	if ((node = ezxml_child(matl, "Height")) != NULL)
118	>	sd->dim[1] = atof(ezxml_txt(node)) *
119	>	to_meters(ezxml_attr(node, "unit"));
120	>	if ((node = ezxml_child(matl, "Thickness")) != NULL)
121	>	sd->dim[2] = atof(ezxml_txt(node)) *
122	>	to_meters(ezxml_attr(node, "unit"));
123	>	if ((sd->dim[0] < 0) | (sd->dim[1] < 0) | (sd->dim[2] < 0)) {
124	>	if (!SDerrorDetail[0])
125	>	sprintf(SDerrorDetail, "Negative dimension in \"%s\"",
126	>	sd->name);
127	>	return SDEdata;
128	>	}
129	>	}
130	>	sd->mgf = NULL;
131	>	geom = ezxml_child(wtl, "Geometry");
132	>	if (geom == NULL)                       /* no actual geometry? */
133	>	return SDEnone;
134	>	fmt = ezxml_attr(geom, "format");
135	>	if (fmt != NULL && strcasecmp(fmt, "MGF")) {
136	>	sprintf(SDerrorDetail,
137	>	"Unrecognized geometry format '%s' in \"%s\"",
138	>	fmt, sd->name);
139	>	return SDEsupport;
140	>	}
141	>	if ((node = ezxml_child(geom, "MGFblock")) == NULL ||
142	>	(mgfstr = ezxml_txt(node)) == NULL)
143	>	return SDEnone;
144	>	while (isspace(*mgfstr))
145	>	++mgfstr;
146	>	if (!*mgfstr)
147	>	return SDEnone;
148	>	cfact = to_meters(ezxml_attr(node, "unit"));
149	>	if (cfact <= 0)
150	>	return SDEformat;
151	>	sd->mgf = (char *)malloc(strlen(mgfstr)+32);
152	>	if (sd->mgf == NULL) {
153	>	strcpy(SDerrorDetail, "Out of memory in SDloadGeometry");
154	>	return SDEmemory;
155	>	}
156	>	if (cfact < 0.99 || cfact > 1.01)
157	>	sprintf(sd->mgf, "xf -s %.5f\n%s\nxf\n", cfact, mgfstr);
158	>	else
159	>	strcpy(sd->mgf, mgfstr);
160	>	return SDEnone;
161		}
162
163	<
164	<	static int
165	<	ab_getndx(              /* get index corresponding to the given vector */
118	<	FVECT v,
119	<	void *p
120	<	)
163	>	/* Load a BSDF struct from the given file (free first and keep name) */
164	>	SDError
165	>	SDloadFile(SDData *sd, const char *fname)
166		{
167	<	ANGLE_BASIS  *ab = (ANGLE_BASIS *)p;
168	<	int     li, ndx;
124	<	double  pol, azi, d;
167	>	SDError         lastErr;
168	>	ezxml_t         fl, wtl;
169
170	<	if ((v[2] < -1.0) | (v[2] > 1.0))
171	<	return(-1);
172	<	pol = 180.0/PI*acos(v[2]);
173	<	azi = 180.0/PI*atan2(v[1], v[0]);
174	<	if (azi < 0.0) azi += 360.0;
175	<	for (li = 1; ab->lat[li].tmin <= pol; li++)
176	<	if (!ab->lat[li].nphis)
177	<	return(-1);
178	<	--li;
179	<	ndx = (int)((1./360.)*azi*ab->lat[li].nphis + 0.5);
180	<	if (ndx >= ab->lat[li].nphis) ndx = 0;
181	<	while (li--)
182	<	ndx += ab->lat[li].nphis;
183	<	return(ndx);
170	>	if ((sd == NULL) | (fname == NULL || !*fname))
171	>	return SDEargument;
172	>	/* free old data, keeping name */
173	>	SDfreeBSDF(sd);
174	>	/* parse XML file */
175	>	fl = ezxml_parse_file(fname);
176	>	if (fl == NULL) {
177	>	sprintf(SDerrorDetail, "Cannot open BSDF \"%s\"", fname);
178	>	return SDEfile;
179	>	}
180	>	if (ezxml_error(fl)[0]) {
181	>	sprintf(SDerrorDetail, "BSDF \"%s\" %s", fname, ezxml_error(fl));
182	>	ezxml_free(fl);
183	>	return SDEformat;
184	>	}
185	>	if (strcmp(ezxml_name(fl), "WindowElement")) {
186	>	sprintf(SDerrorDetail,
187	>	"BSDF \"%s\": top level node not 'WindowElement'",
188	>	sd->name);
189	>	ezxml_free(fl);
190	>	return SDEformat;
191	>	}
192	>	wtl = ezxml_child(fl, "FileType");
193	>	if (wtl != NULL && strcmp(ezxml_txt(wtl), "BSDF")) {
194	>	sprintf(SDerrorDetail,
195	>	"XML \"%s\": wrong FileType (must be 'BSDF')",
196	>	sd->name);
197	>	ezxml_free(fl);
198	>	return SDEformat;
199	>	}
200	>	wtl = ezxml_child(ezxml_child(fl, "Optical"), "Layer");
201	>	if (wtl == NULL) {
202	>	sprintf(SDerrorDetail, "BSDF \"%s\": no optical layers'",
203	>	sd->name);
204	>	ezxml_free(fl);
205	>	return SDEformat;
206	>	}
207	>	/* load geometry if present */
208	>	lastErr = SDloadGeometry(sd, wtl);
209	>	if (lastErr) {
210	>	ezxml_free(fl);
211	>	return lastErr;
212	>	}
213	>	/* try loading variable resolution data */
214	>	lastErr = SDloadTre(sd, wtl);
215	>	/* check our result */
216	>	if (lastErr == SDEsupport)      /* try matrix BSDF if not tree data */
217	>	lastErr = SDloadMtx(sd, wtl);
218	>
219	>	/* done with XML file */
220	>	ezxml_free(fl);
221	>
222	>	if (lastErr) {          /* was there a load error? */
223	>	SDfreeBSDF(sd);
224	>	return lastErr;
225	>	}
226	>	/* remove any insignificant components */
227	>	if (sd->rf != NULL && sd->rf->maxHemi <= .001) {
228	>	SDfreeSpectralDF(sd->rf); sd->rf = NULL;
229	>	}
230	>	if (sd->rb != NULL && sd->rb->maxHemi <= .001) {
231	>	SDfreeSpectralDF(sd->rb); sd->rb = NULL;
232	>	}
233	>	if (sd->tf != NULL && sd->tf->maxHemi <= .001) {
234	>	SDfreeSpectralDF(sd->tf); sd->tf = NULL;
235	>	}
236	>	if (sd->tb != NULL && sd->tb->maxHemi <= .001) {
237	>	SDfreeSpectralDF(sd->tb); sd->tb = NULL;
238	>	}
239	>	/* return success */
240	>	return SDEnone;
241		}
242
243	<
244	<	static double
245	<	ab_getohm(              /* get solid angle for this angle basis index */
145	<	int ndx,
146	<	void *p
147	<	)
243	>	/* Allocate new spectral distribution function */
244	>	SDSpectralDF *
245	>	SDnewSpectralDF(int nc)
246		{
247	<	ANGLE_BASIS  *ab = (ANGLE_BASIS *)p;
150	<	int     li;
151	<	double  theta, theta1;
247	>	SDSpectralDF    *df;
248
249	<	if ((ndx < 0) | (ndx >= ab->nangles))
250	<	return(0);
251	<	for (li = 0; ndx >= ab->lat[li].nphis; li++)
156	<	ndx -= ab->lat[li].nphis;
157	<	theta1 = PI/180. * ab->lat[li+1].tmin;
158	<	if (ab->lat[li].nphis == 1) {           /* special case */
159	<	if (ab->lat[li].tmin > FTINY)
160	<	error(USER, "unsupported BSDF coordinate system");
161	<	return(2.*PI*(1. - cos(theta1)));
249	>	if (nc <= 0) {
250	>	strcpy(SDerrorDetail, "Zero component spectral DF request");
251	>	return NULL;
252		}
253	<	theta = PI/180. * ab->lat[li].tmin;
254	<	return(2.*PI*(cos(theta) - cos(theta1))/(double)ab->lat[li].nphis);
253	>	df = (SDSpectralDF *)malloc(sizeof(SDSpectralDF) +
254	>	(nc-1)*sizeof(SDComponent));
255	>	if (df == NULL) {
256	>	sprintf(SDerrorDetail,
257	>	"Cannot allocate %d component spectral DF", nc);
258	>	return NULL;
259	>	}
260	>	df->minProjSA = .0;
261	>	df->maxHemi = .0;
262	>	df->ncomp = nc;
263	>	memset(df->comp, 0, nc*sizeof(SDComponent));
264	>	return df;
265		}
266
267	<
268	<	static int
269	<	ab_getvecR(             /* get reverse vector for this angle basis index */
170	<	FVECT v,
171	<	int ndx,
172	<	void *p
173	<	)
267	>	/* Add component(s) to spectral distribution function */
268	>	SDSpectralDF *
269	>	SDaddComponent(SDSpectralDF *odf, int nadd)
270		{
271	<	if (!ab_getvec(v, ndx, p))
176	<	return(0);
271	>	SDSpectralDF    *df;
272
273	<	v[0] = -v[0];
274	<	v[1] = -v[1];
275	<	v[2] = -v[2];
276	<
277	<	return(1);
273	>	if (odf == NULL)
274	>	return SDnewSpectralDF(nadd);
275	>	if (nadd <= 0)
276	>	return odf;
277	>	df = (SDSpectralDF *)realloc(odf, sizeof(SDSpectralDF) +
278	>	(odf->ncomp+nadd-1)*sizeof(SDComponent));
279	>	if (df == NULL) {
280	>	sprintf(SDerrorDetail,
281	>	"Cannot add %d component(s) to spectral DF", nadd);
282	>	SDfreeSpectralDF(odf);
283	>	return NULL;
284	>	}
285	>	memset(df->comp+df->ncomp, 0, nadd*sizeof(SDComponent));
286	>	df->ncomp += nadd;
287	>	return df;
288		}
289
290	<
291	<	static int
292	<	ab_getndxR(             /* get index corresponding to the reverse vector */
188	<	FVECT v,
189	<	void *p
190	<	)
290	>	/* Free cached cumulative distributions for BSDF component */
291	>	void
292	>	SDfreeCumulativeCache(SDSpectralDF *df)
293		{
294	<	FVECT  v2;
295	<
194	<	v2[0] = -v[0];
195	<	v2[1] = -v[1];
196	<	v2[2] = -v[2];
294	>	int     n;
295	>	SDCDst  *cdp;
296
297	<	return ab_getndx(v2, p);
297	>	if (df == NULL)
298	>	return;
299	>	for (n = df->ncomp; n-- > 0; )
300	>	while ((cdp = df->comp[n].cdList) != NULL) {
301	>	df->comp[n].cdList = cdp->next;
302	>	free(cdp);
303	>	}
304		}
305
306	<
307	<	static void
308	<	load_angle_basis(       /* load custom BSDF angle basis */
204	<	ezxml_t wab
205	<	)
306	>	/* Free a spectral distribution function */
307	>	void
308	>	SDfreeSpectralDF(SDSpectralDF *df)
309		{
310	<	char    *abname = ezxml_txt(ezxml_child(wab, "AngleBasisName"));
311	<	ezxml_t wbb;
312	<	int     i;
210	<
211	<	if (!abname || !*abname)
310	>	int     n;
311	>
312	>	if (df == NULL)
313		return;
314	<	for (i = nabases; i--; )
315	<	if (!strcmp(abname, abase_list[i].name))
316	<	return;         /* assume it's the same */
317	<	if (nabases >= MAXABASES)
318	<	error(INTERNAL, "too many angle bases");
218	<	strcpy(abase_list[nabases].name, abname);
219	<	abase_list[nabases].nangles = 0;
220	<	for (i = 0, wbb = ezxml_child(wab, "AngleBasisBlock");
221	<	wbb != NULL; i++, wbb = wbb->next) {
222	<	if (i >= MAXLATS)
223	<	error(INTERNAL, "too many latitudes in custom basis");
224	<	abase_list[nabases].lat[i+1].tmin = atof(ezxml_txt(
225	<	ezxml_child(ezxml_child(wbb,
226	<	"ThetaBounds"), "UpperTheta")));
227	<	if (!i)
228	<	abase_list[nabases].lat[i].tmin =
229	<	-abase_list[nabases].lat[i+1].tmin;
230	<	else if (!FEQ(atof(ezxml_txt(ezxml_child(ezxml_child(wbb,
231	<	"ThetaBounds"), "LowerTheta"))),
232	<	abase_list[nabases].lat[i].tmin))
233	<	error(WARNING, "theta values disagree in custom basis");
234	<	abase_list[nabases].nangles +=
235	<	abase_list[nabases].lat[i].nphis =
236	<	atoi(ezxml_txt(ezxml_child(wbb, "nPhis")));
237	<	}
238	<	abase_list[nabases++].lat[i].nphis = 0;
314	>	SDfreeCumulativeCache(df);
315	>	for (n = df->ncomp; n-- > 0; )
316	>	if (df->comp[n].dist != NULL)
317	>	(*df->comp[n].func->freeSC)(df->comp[n].dist);
318	>	free(df);
319		}
320
321	<
322	<	static double
323	<	to_meters(              /* return factor to convert given unit to meters */
244	<	const char *unit
245	<	)
321	>	/* Shorten file path to useable BSDF name, removing suffix */
322	>	void
323	>	SDclipName(char *res, const char *fname)
324		{
325	<	if (unit == NULL) return(1.);           /* safe assumption? */
326	<	if (!strcasecmp(unit, "Meter")) return(1.);
327	<	if (!strcasecmp(unit, "Foot")) return(.3048);
328	<	if (!strcasecmp(unit, "Inch")) return(.0254);
329	<	if (!strcasecmp(unit, "Centimeter")) return(.01);
330	<	sprintf(errmsg, "unknown dimensional unit '%s'", unit);
331	<	error(USER, errmsg);
325	>	const char      *cp, *dot = NULL;
326	>
327	>	for (cp = fname; *cp; cp++)
328	>	if (*cp == '.')
329	>	dot = cp;
330	>	if ((dot == NULL) | (dot < fname+2))
331	>	dot = cp;
332	>	if (dot - fname >= SDnameLn)
333	>	fname = dot - SDnameLn + 1;
334	>	while (fname < dot)
335	>	*res++ = *fname++;
336	>	*res = '\0';
337		}
338
339	<
340	<	static void
341	<	load_geometry(          /* load geometric dimensions and description (if any) */
259	<	struct BSDF_data *dp,
260	<	ezxml_t wdb
261	<	)
339	>	/* Initialize an unused BSDF struct (simply clears to zeroes) */
340	>	void
341	>	SDclearBSDF(SDData *sd, const char *fname)
342		{
343	<	ezxml_t         geom;
264	<	double          cfact;
265	<	const char      *fmt, *mgfstr;
266	<
267	<	dp->dim[0] = dp->dim[1] = dp->dim[2] = 0;
268	<	dp->mgf = NULL;
269	<	if ((geom = ezxml_child(wdb, "Width")) != NULL)
270	<	dp->dim[0] = atof(ezxml_txt(geom)) *
271	<	to_meters(ezxml_attr(geom, "unit"));
272	<	if ((geom = ezxml_child(wdb, "Height")) != NULL)
273	<	dp->dim[1] = atof(ezxml_txt(geom)) *
274	<	to_meters(ezxml_attr(geom, "unit"));
275	<	if ((geom = ezxml_child(wdb, "Thickness")) != NULL)
276	<	dp->dim[2] = atof(ezxml_txt(geom)) *
277	<	to_meters(ezxml_attr(geom, "unit"));
278	<	if ((geom = ezxml_child(wdb, "Geometry")) == NULL ||
279	<	(mgfstr = ezxml_txt(geom)) == NULL)
343	>	if (sd == NULL)
344		return;
345	<	if ((fmt = ezxml_attr(geom, "format")) != NULL &&
346	<	strcasecmp(fmt, "MGF")) {
283	<	sprintf(errmsg, "unrecognized geometry format '%s'", fmt);
284	<	error(WARNING, errmsg);
345	>	memset(sd, 0, sizeof(SDData));
346	>	if (fname == NULL)
347		return;
348	<	}
287	<	cfact = to_meters(ezxml_attr(geom, "unit"));
288	<	dp->mgf = (char *)malloc(strlen(mgfstr)+32);
289	<	if (dp->mgf == NULL)
290	<	error(SYSTEM, "out of memory in load_geometry");
291	<	if (cfact < 0.99 || cfact > 1.01)
292	<	sprintf(dp->mgf, "xf -s %.5f\n%s\nxf\n", cfact, mgfstr);
293	<	else
294	<	strcpy(dp->mgf, mgfstr);
348	>	SDclipName(sd->name, fname);
349		}
350
351	<
352	<	static void
353	<	load_bsdf_data(         /* load BSDF distribution for this wavelength */
300	<	struct BSDF_data *dp,
301	<	ezxml_t wdb
302	<	)
351	>	/* Free data associated with BSDF struct */
352	>	void
353	>	SDfreeBSDF(SDData *sd)
354		{
355	<	char  *cbasis = ezxml_txt(ezxml_child(wdb,"ColumnAngleBasis"));
305	<	char  *rbasis = ezxml_txt(ezxml_child(wdb,"RowAngleBasis"));
306	<	char  *sdata;
307	<	int  i;
308	<
309	<	if ((!cbasis || !*cbasis) | (!rbasis || !*rbasis)) {
310	<	error(WARNING, "missing column/row basis for BSDF");
355	>	if (sd == NULL)
356		return;
357	+	if (sd->mgf != NULL) {
358	+	free(sd->mgf);
359	+	sd->mgf = NULL;
360		}
361	<	for (i = nabases; i--; )
362	<	if (!strcmp(cbasis, abase_list[i].name)) {
363	<	dp->ninc = abase_list[i].nangles;
316	<	dp->ib_priv = (void *)&abase_list[i];
317	<	dp->ib_vec = ab_getvecR;
318	<	dp->ib_ndx = ab_getndxR;
319	<	dp->ib_ohm = ab_getohm;
320	<	break;
321	<	}
322	<	if (i < 0) {
323	<	sprintf(errmsg, "undefined ColumnAngleBasis '%s'", cbasis);
324	<	error(WARNING, errmsg);
325	<	return;
361	>	if (sd->rf != NULL) {
362	>	SDfreeSpectralDF(sd->rf);
363	>	sd->rf = NULL;
364		}
365	<	for (i = nabases; i--; )
366	<	if (!strcmp(rbasis, abase_list[i].name)) {
367	<	dp->nout = abase_list[i].nangles;
330	<	dp->ob_priv = (void *)&abase_list[i];
331	<	dp->ob_vec = ab_getvec;
332	<	dp->ob_ndx = ab_getndx;
333	<	dp->ob_ohm = ab_getohm;
334	<	break;
335	<	}
336	<	if (i < 0) {
337	<	sprintf(errmsg, "undefined RowAngleBasis '%s'", cbasis);
338	<	error(WARNING, errmsg);
339	<	return;
365	>	if (sd->rb != NULL) {
366	>	SDfreeSpectralDF(sd->rb);
367	>	sd->rb = NULL;
368		}
369	<	/* read BSDF data */
370	<	sdata  = ezxml_txt(ezxml_child(wdb,"ScatteringData"));
371	<	if (!sdata || !*sdata) {
344	<	error(WARNING, "missing BSDF ScatteringData");
345	<	return;
369	>	if (sd->tf != NULL) {
370	>	SDfreeSpectralDF(sd->tf);
371	>	sd->tf = NULL;
372		}
373	<	dp->bsdf = (float *)malloc(sizeof(float)*dp->ninc*dp->nout);
374	<	if (dp->bsdf == NULL)
375	<	error(SYSTEM, "out of memory in load_bsdf_data");
350	<	for (i = 0; i < dp->ninc*dp->nout; i++) {
351	<	char  *sdnext = fskip(sdata);
352	<	if (sdnext == NULL) {
353	<	error(WARNING, "bad/missing BSDF ScatteringData");
354	<	free(dp->bsdf); dp->bsdf = NULL;
355	<	return;
356	<	}
357	<	while (*sdnext && isspace(*sdnext))
358	<	sdnext++;
359	<	if (*sdnext == ',') sdnext++;
360	<	dp->bsdf[i] = atof(sdata);
361	<	sdata = sdnext;
373	>	if (sd->tb != NULL) {
374	>	SDfreeSpectralDF(sd->tb);
375	>	sd->tb = NULL;
376		}
377	<	while (isspace(*sdata))
378	<	sdata++;
379	<	if (*sdata) {
380	<	sprintf(errmsg, "%d extra characters after BSDF ScatteringData",
381	<	(int)strlen(sdata));
382	<	error(WARNING, errmsg);
369	<	}
377	>	sd->rLambFront.cieY = .0;
378	>	sd->rLambFront.spec.flags = 0;
379	>	sd->rLambBack.cieY = .0;
380	>	sd->rLambBack.spec.flags = 0;
381	>	sd->tLamb.cieY = .0;
382	>	sd->tLamb.spec.flags = 0;
383		}
384
385	<
386	<	static int
387	<	check_bsdf_data(        /* check that BSDF data is sane */
375	<	struct BSDF_data *dp
376	<	)
385	>	/* Find writeable BSDF by name, or allocate new cache entry if absent */
386	>	SDData *
387	>	SDgetCache(const char *bname)
388		{
389	<	double          *omega_iarr, *omega_oarr;
390	<	double          dom, contrib, hemi_total, full_total;
380	<	int             nneg;
381	<	FVECT           v;
382	<	int             i, o;
389	>	struct SDCache_s        *sdl;
390	>	char                    sdnam[SDnameLn];
391
392	<	if (dp == NULL || dp->bsdf == NULL)
393	<	return(0);
394	<	omega_iarr = (double *)calloc(dp->ninc, sizeof(double));
395	<	omega_oarr = (double *)calloc(dp->nout, sizeof(double));
396	<	if ((omega_iarr == NULL) | (omega_oarr == NULL))
397	<	error(SYSTEM, "out of memory in check_bsdf_data");
398	<	/* incoming projected solid angles */
399	<	hemi_total = .0;
392	<	for (i = dp->ninc; i--; ) {
393	<	dom = getBSDF_incohm(dp,i);
394	<	if (dom <= .0) {
395	<	error(WARNING, "zero/negative incoming solid angle");
396	<	continue;
392	>	if (bname == NULL)
393	>	return NULL;
394	>
395	>	SDclipName(sdnam, bname);
396	>	for (sdl = SDcacheList; sdl != NULL; sdl = sdl->next)
397	>	if (!strcmp(sdl->bsdf.name, sdnam)) {
398	>	sdl->refcnt++;
399	>	return &sdl->bsdf;
400		}
401	<	if (!getBSDF_incvec(v,dp,i) || v[2] > FTINY) {
402	<	error(WARNING, "illegal incoming BSDF direction");
403	<	free(omega_iarr); free(omega_oarr);
404	<	return(0);
405	<	}
406	<	hemi_total += omega_iarr[i] = dom * -v[2];
401	>
402	>	sdl = (struct SDCache_s *)calloc(1, sizeof(struct SDCache_s));
403	>	if (sdl == NULL)
404	>	return NULL;
405	>
406	>	strcpy(sdl->bsdf.name, sdnam);
407	>	sdl->next = SDcacheList;
408	>	SDcacheList = sdl;
409	>
410	>	sdl->refcnt = 1;
411	>	return &sdl->bsdf;
412	>	}
413	>
414	>	/* Get loaded BSDF from cache (or load and cache it on first call) */
415	>	/* Report any problem to stderr and return NULL on failure */
416	>	const SDData *
417	>	SDcacheFile(const char *fname)
418	>	{
419	>	SDData          *sd;
420	>	SDError         ec;
421	>
422	>	if (fname == NULL || !*fname)
423	>	return NULL;
424	>	SDerrorDetail[0] = '\0';
425	>	if ((sd = SDgetCache(fname)) == NULL) {
426	>	SDreportError(SDEmemory, stderr);
427	>	return NULL;
428		}
429	<	if ((hemi_total > 1.02*PI) | (hemi_total < 0.98*PI)) {
430	<	sprintf(errmsg, "incoming BSDF hemisphere off by %.1f%%",
431	<	100.*(hemi_total/PI - 1.));
432	<	error(WARNING, errmsg);
429	>	if (!SDisLoaded(sd) && (ec = SDloadFile(sd, fname))) {
430	>	SDreportError(ec, stderr);
431	>	SDfreeCache(sd);
432	>	return NULL;
433		}
434	<	dom = PI / hemi_total;          /* fix normalization */
435	<	for (i = dp->ninc; i--; )
412	<	omega_iarr[i] *= dom;
413	<	/* outgoing projected solid angles */
414	<	hemi_total = .0;
415	<	for (o = dp->nout; o--; ) {
416	<	dom = getBSDF_outohm(dp,o);
417	<	if (dom <= .0) {
418	<	error(WARNING, "zero/negative outgoing solid angle");
419	<	continue;
420	<	}
421	<	if (!getBSDF_outvec(v,dp,o) || v[2] < -FTINY) {
422	<	error(WARNING, "illegal outgoing BSDF direction");
423	<	free(omega_iarr); free(omega_oarr);
424	<	return(0);
425	<	}
426	<	hemi_total += omega_oarr[o] = dom * v[2];
427	<	}
428	<	if ((hemi_total > 1.02*PI) | (hemi_total < 0.98*PI)) {
429	<	sprintf(errmsg, "outgoing BSDF hemisphere off by %.1f%%",
430	<	100.*(hemi_total/PI - 1.));
431	<	error(WARNING, errmsg);
432	<	}
433	<	dom = PI / hemi_total;          /* fix normalization */
434	<	for (o = dp->nout; o--; )
435	<	omega_oarr[o] *= dom;
436	<	nneg = 0;                       /* check outgoing totals */
437	<	for (i = 0; i < dp->ninc; i++) {
438	<	hemi_total = .0;
439	<	for (o = dp->nout; o--; ) {
440	<	double  f = BSDF_value(dp,i,o);
441	<	if (f >= .0)
442	<	hemi_total += f*omega_oarr[o];
443	<	else {
444	<	nneg += (f < -FTINY);
445	<	BSDF_value(dp,i,o) = .0f;
446	<	}
447	<	}
448	<	if (hemi_total > 1.02) {
449	<	sprintf(errmsg,
450	<	"incoming BSDF direction %d passes %.1f%% of light",
451	<	i, 100.*hemi_total);
452	<	error(WARNING, errmsg);
453	<	}
454	<	}
455	<	if (nneg) {
456	<	sprintf(errmsg, "%d negative BSDF values (ignored)", nneg);
457	<	error(WARNING, errmsg);
458	<	}
459	<	full_total = .0;                /* reverse roles and check again */
460	<	for (o = 0; o < dp->nout; o++) {
461	<	hemi_total = .0;
462	<	for (i = dp->ninc; i--; )
463	<	hemi_total += BSDF_value(dp,i,o) * omega_iarr[i];
434	>	return sd;
435	>	}
436
437	<	if (hemi_total > 1.02) {
438	<	sprintf(errmsg,
439	<	"outgoing BSDF direction %d collects %.1f%% of light",
440	<	o, 100.*hemi_total);
441	<	error(WARNING, errmsg);
437	>	/* Free a BSDF from our cache (clear all if NULL) */
438	>	void
439	>	SDfreeCache(const SDData *sd)
440	>	{
441	>	struct SDCache_s        *sdl, *sdLast = NULL;
442	>
443	>	if (sd == NULL) {               /* free entire list */
444	>	while ((sdl = SDcacheList) != NULL) {
445	>	SDcacheList = sdl->next;
446	>	SDfreeBSDF(&sdl->bsdf);
447	>	free(sdl);
448		}
449	<	full_total += hemi_total*omega_oarr[o];
449	>	return;
450		}
451	<	full_total /= PI;
452	<	if (full_total > 1.02) {
453	<	sprintf(errmsg, "BSDF transfers %.1f%% of light",
454	<	100.*full_total);
455	<	error(WARNING, errmsg);
451	>	for (sdl = SDcacheList; sdl != NULL; sdl = (sdLast=sdl)->next)
452	>	if (&sdl->bsdf == sd)
453	>	break;
454	>	if (sdl == NULL || (sdl->refcnt -= (sdl->refcnt > 0)))
455	>	return;                 /* missing or still in use */
456	>	/* keep unreferenced data? */
457	>	if (SDisLoaded(sd) && SDretainSet) {
458	>	if (SDretainSet == SDretainAll)
459	>	return;         /* keep everything */
460	>	/* else free cumulative data */
461	>	SDfreeCumulativeCache(sd->rf);
462	>	SDfreeCumulativeCache(sd->rb);
463	>	SDfreeCumulativeCache(sd->tf);
464	>	SDfreeCumulativeCache(sd->tb);
465	>	return;
466		}
467	<	free(omega_iarr); free(omega_oarr);
468	<	return(1);
467	>	/* remove from list and free */
468	>	if (sdLast == NULL)
469	>	SDcacheList = sdl->next;
470	>	else
471	>	sdLast->next = sdl->next;
472	>	SDfreeBSDF(&sdl->bsdf);
473	>	free(sdl);
474		}
475
476	<
477	<	struct BSDF_data *
478	<	load_BSDF(              /* load BSDF data from file */
486	<	char *fname
487	<	)
476	>	/* Sample an individual BSDF component */
477	>	SDError
478	>	SDsampComponent(SDValue *sv, FVECT ioVec, double randX, SDComponent *sdc)
479		{
480	<	char                    *path;
481	<	ezxml_t                 fl, wtl, wld, wdb;
482	<	struct BSDF_data        *dp;
483	<
484	<	path = getpath(fname, getrlibpath(), R_OK);
485	<	if (path == NULL) {
486	<	sprintf(errmsg, "cannot find BSDF file \"%s\"", fname);
487	<	error(WARNING, errmsg);
488	<	return(NULL);
480	>	float           coef[SDmaxCh];
481	>	SDError         ec;
482	>	FVECT           inVec;
483	>	const SDCDst    *cd;
484	>	double          d;
485	>	int             n;
486	>	/* check arguments */
487	>	if ((sv == NULL) | (ioVec == NULL) | (sdc == NULL))
488	>	return SDEargument;
489	>	/* get cumulative distribution */
490	>	VCOPY(inVec, ioVec);
491	>	sv->cieY = 0;
492	>	cd = (*sdc->func->getCDist)(inVec, sdc);
493	>	if (cd != NULL)
494	>	sv->cieY = cd->cTotal;
495	>	if (sv->cieY <= 1e-6) {         /* nothing to sample? */
496	>	sv->spec = c_dfcolor;
497	>	memset(ioVec, 0, 3*sizeof(double));
498	>	return SDEnone;
499		}
500	<	fl = ezxml_parse_file(path);
501	<	if (fl == NULL) {
502	<	sprintf(errmsg, "cannot open BSDF \"%s\"", path);
503	<	error(WARNING, errmsg);
504	<	return(NULL);
500	>	/* compute sample direction */
501	>	ec = (*sdc->func->sampCDist)(ioVec, randX, cd);
502	>	if (ec)
503	>	return ec;
504	>	/* get BSDF color */
505	>	n = (*sdc->func->getBSDFs)(coef, ioVec, inVec, sdc);
506	>	if (n <= 0) {
507	>	strcpy(SDerrorDetail, "BSDF sample value error");
508	>	return SDEinternal;
509		}
510	<	if (ezxml_error(fl)[0]) {
511	<	sprintf(errmsg, "BSDF \"%s\" %s", path, ezxml_error(fl));
512	<	error(WARNING, errmsg);
513	<	ezxml_free(fl);
514	<	return(NULL);
510	>	sv->spec = sdc->cspec[0];
511	>	d = coef[0];
512	>	while (--n) {
513	>	c_cmix(&sv->spec, d, &sv->spec, coef[n], &sdc->cspec[n]);
514	>	d += coef[n];
515		}
516	<	if (strcmp(ezxml_name(fl), "WindowElement")) {
517	<	sprintf(errmsg,
518	<	"BSDF \"%s\": top level node not 'WindowElement'",
514	<	path);
515	<	error(WARNING, errmsg);
516	<	ezxml_free(fl);
517	<	return(NULL);
518	<	}
519	<	wtl = ezxml_child(ezxml_child(fl, "Optical"), "Layer");
520	<	load_angle_basis(ezxml_child(ezxml_child(wtl,
521	<	"DataDefinition"), "AngleBasis"));
522	<	dp = (struct BSDF_data *)calloc(1, sizeof(struct BSDF_data));
523	<	load_geometry(dp, ezxml_child(wtl, "Material"));
524	<	for (wld = ezxml_child(wtl, "WavelengthData");
525	<	wld != NULL; wld = wld->next) {
526	<	if (strcmp(ezxml_txt(ezxml_child(wld,"Wavelength")), "Visible"))
527	<	continue;
528	<	wdb = ezxml_child(wld, "WavelengthDataBlock");
529	<	if (wdb == NULL) continue;
530	<	if (strcmp(ezxml_txt(ezxml_child(wdb,"WavelengthDataDirection")),
531	<	"Transmission Front"))
532	<	continue;
533	<	load_bsdf_data(dp, wdb);        /* load front BTDF */
534	<	break;                          /* ignore the rest */
535	<	}
536	<	ezxml_free(fl);                         /* done with XML file */
537	<	if (!check_bsdf_data(dp)) {
538	<	sprintf(errmsg, "bad/missing BTDF data in \"%s\"", path);
539	<	error(WARNING, errmsg);
540	<	free_BSDF(dp);
541	<	dp = NULL;
542	<	}
543	<	return(dp);
516	>	/* make sure everything is set */
517	>	c_ccvt(&sv->spec, C_CSXY+C_CSSPEC);
518	>	return SDEnone;
519		}
520
521	+	#define MS_MAXDIM       15
522
523	+	/* Convert 1-dimensional random variable to N-dimensional */
524		void
525	<	free_BSDF(              /* free BSDF data structure */
549	<	struct BSDF_data *b
550	<	)
525	>	SDmultiSamp(double t[], int n, double randX)
526		{
527	<	if (b == NULL)
527	>	unsigned        nBits;
528	>	double          scale;
529	>	bitmask_t       ndx, coord[MS_MAXDIM];
530	>
531	>	if (n <= 0)                     /* check corner cases */
532		return;
533	<	if (b->mgf != NULL)
534	<	free(b->mgf);
535	<	if (b->bsdf != NULL)
536	<	free(b->bsdf);
537	<	free(b);
533	>	if (randX < 0) randX = 0;
534	>	else if (randX >= 1.) randX = 0.999999999999999;
535	>	if (n == 1) {
536	>	t[0] = randX;
537	>	return;
538	>	}
539	>	while (n > MS_MAXDIM)           /* punt for higher dimensions */
540	>	t[--n] = rand()*(1./(RAND_MAX+.5));
541	>	nBits = (8*sizeof(bitmask_t) - 1) / n;
542	>	ndx = randX * (double)((bitmask_t)1 << (nBits*n));
543	>	/* get coordinate on Hilbert curve */
544	>	hilbert_i2c(n, nBits, ndx, coord);
545	>	/* convert back to [0,1) range */
546	>	scale = 1. / (double)((bitmask_t)1 << nBits);
547	>	while (n--)
548	>	t[n] = scale * ((double)coord[n] + rand()*(1./(RAND_MAX+.5)));
549		}
550
551	+	#undef MS_MAXDIM
552
553	<	int
554	<	r_BSDF_incvec(          /* compute random input vector at given location */
555	<	FVECT v,
565	<	struct BSDF_data *b,
566	<	int i,
567	<	double rv,
568	<	MAT4 xm
569	<	)
553	>	/* Generate diffuse hemispherical sample */
554	>	static void
555	>	SDdiffuseSamp(FVECT outVec, int outFront, double randX)
556		{
557	<	FVECT   pert;
558	<	double  rad;
559	<	int     j;
560	<
561	<	if (!getBSDF_incvec(v, b, i))
562	<	return(0);
563	<	rad = sqrt(getBSDF_incohm(b, i) / PI);
564	<	multisamp(pert, 3, rv);
579	<	for (j = 0; j < 3; j++)
580	<	v[j] += rad*(2.*pert[j] - 1.);
581	<	if (xm != NULL)
582	<	multv3(v, v, xm);
583	<	return(normalize(v) != 0.0);
557	>	/* convert to position on hemisphere */
558	>	SDmultiSamp(outVec, 2, randX);
559	>	SDsquare2disk(outVec, outVec[0], outVec[1]);
560	>	outVec[2] = 1. - outVec[0]*outVec[0] - outVec[1]*outVec[1];
561	>	if (outVec[2] > 0)              /* a bit of paranoia */
562	>	outVec[2] = sqrt(outVec[2]);
563	>	if (!outFront)                  /* going out back? */
564	>	outVec[2] = -outVec[2];
565		}
566
567	+	/* Query projected solid angle coverage for non-diffuse BSDF direction */
568	+	SDError
569	+	SDsizeBSDF(double *projSA, const FVECT v1, const RREAL *v2,
570	+	int qflags, const SDData *sd)
571	+	{
572	+	SDSpectralDF    *rdf, *tdf;
573	+	SDError         ec;
574	+	int             i;
575	+	/* check arguments */
576	+	if ((projSA == NULL) | (v1 == NULL) | (sd == NULL))
577	+	return SDEargument;
578	+	/* initialize extrema */
579	+	switch (qflags) {
580	+	case SDqueryMax:
581	+	projSA[0] = .0;
582	+	break;
583	+	case SDqueryMin+SDqueryMax:
584	+	projSA[1] = .0;
585	+	/* fall through */
586	+	case SDqueryMin:
587	+	projSA[0] = 10.;
588	+	break;
589	+	case 0:
590	+	return SDEargument;
591	+	}
592	+	if (v1[2] > 0) {                /* front surface query? */
593	+	rdf = sd->rf;
594	+	tdf = (sd->tf != NULL) ? sd->tf : sd->tb;
595	+	} else {
596	+	rdf = sd->rb;
597	+	tdf = (sd->tb != NULL) ? sd->tb : sd->tf;
598	+	}
599	+	if (v2 != NULL)                 /* bidirectional? */
600	+	if (v1[2] > 0 ^ v2[2] > 0)
601	+	rdf = NULL;
602	+	else
603	+	tdf = NULL;
604	+	ec = SDEdata;                   /* run through components */
605	+	for (i = (rdf==NULL) ? 0 : rdf->ncomp; i--; ) {
606	+	ec = (*rdf->comp[i].func->queryProjSA)(projSA, v1, v2,
607	+	qflags, &rdf->comp[i]);
608	+	if (ec)
609	+	return ec;
610	+	}
611	+	for (i = (tdf==NULL) ? 0 : tdf->ncomp; i--; ) {
612	+	ec = (*tdf->comp[i].func->queryProjSA)(projSA, v1, v2,
613	+	qflags, &tdf->comp[i]);
614	+	if (ec)
615	+	return ec;
616	+	}
617	+	if (ec) {                       /* all diffuse? */
618	+	projSA[0] = M_PI;
619	+	if (qflags == SDqueryMin+SDqueryMax)
620	+	projSA[1] = M_PI;
621	+	} else if (qflags == SDqueryMin+SDqueryMax && projSA[0] > projSA[1])
622	+	projSA[0] = projSA[1];
623	+	return SDEnone;
624	+	}
625
626	<	int
627	<	r_BSDF_outvec(          /* compute random output vector at given location */
628	<	FVECT v,
590	<	struct BSDF_data *b,
591	<	int o,
592	<	double rv,
593	<	MAT4 xm
594	<	)
626	>	/* Return BSDF for the given incident and scattered ray vectors */
627	>	SDError
628	>	SDevalBSDF(SDValue *sv, const FVECT outVec, const FVECT inVec, const SDData *sd)
629		{
630	<	FVECT   pert;
631	<	double  rad;
632	<	int     j;
633	<
634	<	if (!getBSDF_outvec(v, b, o))
635	<	return(0);
636	<	rad = sqrt(getBSDF_outohm(b, o) / PI);
637	<	multisamp(pert, 3, rv);
638	<	for (j = 0; j < 3; j++)
639	<	v[j] += rad*(2.*pert[j] - 1.);
640	<	if (xm != NULL)
641	<	multv3(v, v, xm);
642	<	return(normalize(v) != 0.0);
630	>	int             inFront, outFront;
631	>	SDSpectralDF    *sdf;
632	>	float           coef[SDmaxCh];
633	>	int             nch, i;
634	>	/* check arguments */
635	>	if ((sv == NULL) | (outVec == NULL) | (inVec == NULL) | (sd == NULL))
636	>	return SDEargument;
637	>	/* whose side are we on? */
638	>	inFront = (inVec[2] > 0);
639	>	outFront = (outVec[2] > 0);
640	>	/* start with diffuse portion */
641	>	if (inFront & outFront) {
642	>	*sv = sd->rLambFront;
643	>	sdf = sd->rf;
644	>	} else if (!(inFront | outFront)) {
645	>	*sv = sd->rLambBack;
646	>	sdf = sd->rb;
647	>	} else if (inFront) {
648	>	*sv = sd->tLamb;
649	>	sdf = (sd->tf != NULL) ? sd->tf : sd->tb;
650	>	} else /* inBack */ {
651	>	*sv = sd->tLamb;
652	>	sdf = (sd->tb != NULL) ? sd->tb : sd->tf;
653	>	}
654	>	sv->cieY *= 1./M_PI;
655	>	/* add non-diffuse components */
656	>	i = (sdf != NULL) ? sdf->ncomp : 0;
657	>	while (i-- > 0) {
658	>	nch = (*sdf->comp[i].func->getBSDFs)(coef, outVec, inVec,
659	>	&sdf->comp[i]);
660	>	while (nch-- > 0) {
661	>	c_cmix(&sv->spec, sv->cieY, &sv->spec,
662	>	coef[nch], &sdf->comp[i].cspec[nch]);
663	>	sv->cieY += coef[nch];
664	>	}
665	>	}
666	>	/* make sure everything is set */
667	>	c_ccvt(&sv->spec, C_CSXY+C_CSSPEC);
668	>	return SDEnone;
669		}
670
671	<
672	<	static int
673	<	addrot(                 /* compute rotation (x,y,z) => (xp,yp,zp) */
614	<	char *xfarg[],
615	<	FVECT xp,
616	<	FVECT yp,
617	<	FVECT zp
618	<	)
671	>	/* Compute directional hemispherical scattering at this incident angle */
672	>	double
673	>	SDdirectHemi(const FVECT inVec, int sflags, const SDData *sd)
674		{
675	<	static char     bufs[3][16];
676	<	int     bn = 0;
677	<	char    **xfp = xfarg;
678	<	double  theta;
675	>	double          hsum;
676	>	SDSpectralDF    *rdf, *tdf;
677	>	const SDCDst    *cd;
678	>	int             i;
679	>	/* check arguments */
680	>	if ((inVec == NULL) | (sd == NULL))
681	>	return .0;
682	>	/* gather diffuse components */
683	>	if (inVec[2] > 0) {
684	>	hsum = sd->rLambFront.cieY;
685	>	rdf = sd->rf;
686	>	tdf = (sd->tf != NULL) ? sd->tf : sd->tb;
687	>	} else /* !inFront */ {
688	>	hsum = sd->rLambBack.cieY;
689	>	rdf = sd->rb;
690	>	tdf = (sd->tb != NULL) ? sd->tb : sd->tf;
691	>	}
692	>	if ((sflags & SDsampDf+SDsampR) != SDsampDf+SDsampR)
693	>	hsum = .0;
694	>	if ((sflags & SDsampDf+SDsampT) == SDsampDf+SDsampT)
695	>	hsum += sd->tLamb.cieY;
696	>	/* gather non-diffuse components */
697	>	i = (((sflags & SDsampSp+SDsampR) == SDsampSp+SDsampR) &
698	>	(rdf != NULL)) ? rdf->ncomp : 0;
699	>	while (i-- > 0) {               /* non-diffuse reflection */
700	>	cd = (*rdf->comp[i].func->getCDist)(inVec, &rdf->comp[i]);
701	>	if (cd != NULL)
702	>	hsum += cd->cTotal;
703	>	}
704	>	i = (((sflags & SDsampSp+SDsampT) == SDsampSp+SDsampT) &
705	>	(tdf != NULL)) ? tdf->ncomp : 0;
706	>	while (i-- > 0) {               /* non-diffuse transmission */
707	>	cd = (*tdf->comp[i].func->getCDist)(inVec, &tdf->comp[i]);
708	>	if (cd != NULL)
709	>	hsum += cd->cTotal;
710	>	}
711	>	return hsum;
712	>	}
713
714	<	if (yp[2]*yp[2] + zp[2]*zp[2] < 2.*FTINY*FTINY) {
715	<	/* Special case for X' along Z-axis */
716	<	theta = -atan2(yp[0], yp[1]);
717	<	*xfp++ = "-ry";
718	<	*xfp++ = xp[2] < 0.0 ? "90" : "-90";
719	<	*xfp++ = "-rz";
720	<	sprintf(bufs[bn], "%f", theta*(180./PI));
721	<	*xfp++ = bufs[bn++];
722	<	return(xfp - xfarg);
714	>	/* Sample BSDF direction based on the given random variable */
715	>	SDError
716	>	SDsampBSDF(SDValue *sv, FVECT ioVec, double randX, int sflags, const SDData *sd)
717	>	{
718	>	SDError         ec;
719	>	FVECT           inVec;
720	>	int             inFront;
721	>	SDSpectralDF    *rdf, *tdf;
722	>	double          rdiff;
723	>	float           coef[SDmaxCh];
724	>	int             i, j, n, nr;
725	>	SDComponent     *sdc;
726	>	const SDCDst    **cdarr = NULL;
727	>	/* check arguments */
728	>	if ((sv == NULL) | (ioVec == NULL) | (sd == NULL) |
729	>	(randX < 0) | (randX >= 1.))
730	>	return SDEargument;
731	>	/* whose side are we on? */
732	>	VCOPY(inVec, ioVec);
733	>	inFront = (inVec[2] > 0);
734	>	/* remember diffuse portions */
735	>	if (inFront) {
736	>	*sv = sd->rLambFront;
737	>	rdf = sd->rf;
738	>	tdf = (sd->tf != NULL) ? sd->tf : sd->tb;
739	>	} else /* !inFront */ {
740	>	*sv = sd->rLambBack;
741	>	rdf = sd->rb;
742	>	tdf = (sd->tb != NULL) ? sd->tb : sd->tf;
743		}
744	<	theta = atan2(yp[2], zp[2]);
745	<	if (!FEQ(theta,0.0)) {
746	<	*xfp++ = "-rx";
747	<	sprintf(bufs[bn], "%f", theta*(180./PI));
748	<	*xfp++ = bufs[bn++];
744	>	if ((sflags & SDsampDf+SDsampR) != SDsampDf+SDsampR)
745	>	sv->cieY = .0;
746	>	rdiff = sv->cieY;
747	>	if ((sflags & SDsampDf+SDsampT) == SDsampDf+SDsampT)
748	>	sv->cieY += sd->tLamb.cieY;
749	>	/* gather non-diffuse components */
750	>	i = nr = (((sflags & SDsampSp+SDsampR) == SDsampSp+SDsampR) &
751	>	(rdf != NULL)) ? rdf->ncomp : 0;
752	>	j = (((sflags & SDsampSp+SDsampT) == SDsampSp+SDsampT) &
753	>	(tdf != NULL)) ? tdf->ncomp : 0;
754	>	n = i + j;
755	>	if (n > 0 && (cdarr = (const SDCDst **)malloc(n*sizeof(SDCDst *))) == NULL)
756	>	return SDEmemory;
757	>	while (j-- > 0) {               /* non-diffuse transmission */
758	>	cdarr[i+j] = (*tdf->comp[j].func->getCDist)(inVec, &tdf->comp[j]);
759	>	if (cdarr[i+j] == NULL)
760	>	cdarr[i+j] = &SDemptyCD;
761	>	sv->cieY += cdarr[i+j]->cTotal;
762		}
763	<	theta = asin(-xp[2]);
764	<	if (!FEQ(theta,0.0)) {
765	<	*xfp++ = "-ry";
766	<	sprintf(bufs[bn], " %f", theta*(180./PI));
767	<	*xfp++ = bufs[bn++];
763	>	while (i-- > 0) {               /* non-diffuse reflection */
764	>	cdarr[i] = (*rdf->comp[i].func->getCDist)(inVec, &rdf->comp[i]);
765	>	if (cdarr[i] == NULL)
766	>	cdarr[i] = &SDemptyCD;
767	>	else
768	>	sv->cieY += cdarr[i]->cTotal;
769		}
770	<	theta = atan2(xp[1], xp[0]);
771	<	if (!FEQ(theta,0.0)) {
772	<	*xfp++ = "-rz";
773	<	sprintf(bufs[bn], "%f", theta*(180./PI));
651	<	*xfp++ = bufs[bn++];
770	>	if (sv->cieY <= 1e-6) {         /* anything to sample? */
771	>	sv->cieY = .0;
772	>	memset(ioVec, 0, 3*sizeof(double));
773	>	return SDEnone;
774		}
775	<	*xfp = NULL;
776	<	return(xfp - xfarg);
775	>	/* scale random variable */
776	>	randX *= sv->cieY;
777	>	/* diffuse reflection? */
778	>	if (randX < rdiff) {
779	>	SDdiffuseSamp(ioVec, inFront, randX/rdiff);
780	>	goto done;
781	>	}
782	>	randX -= rdiff;
783	>	/* diffuse transmission? */
784	>	if ((sflags & SDsampDf+SDsampT) == SDsampDf+SDsampT) {
785	>	if (randX < sd->tLamb.cieY) {
786	>	sv->spec = sd->tLamb.spec;
787	>	SDdiffuseSamp(ioVec, !inFront, randX/sd->tLamb.cieY);
788	>	goto done;
789	>	}
790	>	randX -= sd->tLamb.cieY;
791	>	}
792	>	/* else one of cumulative dist. */
793	>	for (i = 0; i < n && randX < cdarr[i]->cTotal; i++)
794	>	randX -= cdarr[i]->cTotal;
795	>	if (i >= n)
796	>	return SDEinternal;
797	>	/* compute sample direction */
798	>	sdc = (i < nr) ? &rdf->comp[i] : &tdf->comp[i-nr];
799	>	ec = (*sdc->func->sampCDist)(ioVec, randX/cdarr[i]->cTotal, cdarr[i]);
800	>	if (ec)
801	>	return ec;
802	>	/* compute color */
803	>	j = (*sdc->func->getBSDFs)(coef, ioVec, inVec, sdc);
804	>	if (j <= 0) {
805	>	sprintf(SDerrorDetail, "BSDF \"%s\" sampling value error",
806	>	sd->name);
807	>	return SDEinternal;
808	>	}
809	>	sv->spec = sdc->cspec[0];
810	>	rdiff = coef[0];
811	>	while (--j) {
812	>	c_cmix(&sv->spec, rdiff, &sv->spec, coef[j], &sdc->cspec[j]);
813	>	rdiff += coef[j];
814	>	}
815	>	done:
816	>	if (cdarr != NULL)
817	>	free(cdarr);
818	>	/* make sure everything is set */
819	>	c_ccvt(&sv->spec, C_CSXY+C_CSSPEC);
820	>	return SDEnone;
821		}
822
823	+	/* Compute World->BSDF transform from surface normal and up (Y) vector */
824	+	SDError
825	+	SDcompXform(RREAL vMtx[3][3], const FVECT sNrm, const FVECT uVec)
826	+	{
827	+	if ((vMtx == NULL) | (sNrm == NULL) | (uVec == NULL))
828	+	return SDEargument;
829	+	VCOPY(vMtx[2], sNrm);
830	+	if (normalize(vMtx[2]) == 0)
831	+	return SDEargument;
832	+	fcross(vMtx[0], uVec, vMtx[2]);
833	+	if (normalize(vMtx[0]) == 0)
834	+	return SDEargument;
835	+	fcross(vMtx[1], vMtx[2], vMtx[0]);
836	+	return SDEnone;
837	+	}
838
839	<	int
840	<	getBSDF_xfm(            /* compute BSDF orient. -> world orient. transform */
841	<	MAT4 xm,
661	<	FVECT nrm,
662	<	UpDir ud,
663	<	char *xfbuf
664	<	)
839	>	/* Compute inverse transform */
840	>	SDError
841	>	SDinvXform(RREAL iMtx[3][3], RREAL vMtx[3][3])
842		{
843	<	char    *xfargs[7];
844	<	XF      myxf;
668	<	FVECT   updir, xdest, ydest;
669	<	int     i;
843	>	RREAL   mTmp[3][3];
844	>	double  d;
845
846	<	updir[0] = updir[1] = updir[2] = 0.;
847	<	switch (ud) {
848	<	case UDzneg:
849	<	updir[2] = -1.;
850	<	break;
851	<	case UDyneg:
852	<	updir[1] = -1.;
853	<	break;
854	<	case UDxneg:
855	<	updir[0] = -1.;
681	<	break;
682	<	case UDxpos:
683	<	updir[0] = 1.;
684	<	break;
685	<	case UDypos:
686	<	updir[1] = 1.;
687	<	break;
688	<	case UDzpos:
689	<	updir[2] = 1.;
690	<	break;
691	<	case UDunknown:
692	<	return(0);
846	>	if ((iMtx == NULL) | (vMtx == NULL))
847	>	return SDEargument;
848	>	/* compute determinant */
849	>	mTmp[0][0] = vMtx[2][2]*vMtx[1][1] - vMtx[2][1]*vMtx[1][2];
850	>	mTmp[0][1] = vMtx[2][1]*vMtx[0][2] - vMtx[2][2]*vMtx[0][1];
851	>	mTmp[0][2] = vMtx[1][2]*vMtx[0][1] - vMtx[1][1]*vMtx[0][2];
852	>	d = vMtx[0][0]*mTmp[0][0] + vMtx[1][0]*mTmp[0][1] + vMtx[2][0]*mTmp[0][2];
853	>	if (d == 0) {
854	>	strcpy(SDerrorDetail, "Zero determinant in matrix inversion");
855	>	return SDEargument;
856		}
857	<	fcross(xdest, updir, nrm);
858	<	if (normalize(xdest) == 0.0)
859	<	return(0);
860	<	fcross(ydest, nrm, xdest);
861	<	xf(&myxf, addrot(xfargs, xdest, ydest, nrm), xfargs);
862	<	copymat4(xm, myxf.xfm);
863	<	if (xfbuf == NULL)
864	<	return(1);
865	<	/* return xf arguments as well */
866	<	for (i = 0; xfargs[i] != NULL; i++) {
867	<	*xfbuf++ = ' ';
868	<	strcpy(xfbuf, xfargs[i]);
869	<	while (*xfbuf) ++xfbuf;
857	>	d = 1./d;                       /* invert matrix */
858	>	mTmp[0][0] *= d; mTmp[0][1] *= d; mTmp[0][2] *= d;
859	>	mTmp[1][0] = d*(vMtx[2][0]*vMtx[1][2] - vMtx[2][2]*vMtx[1][0]);
860	>	mTmp[1][1] = d*(vMtx[2][2]*vMtx[0][0] - vMtx[2][0]*vMtx[0][2]);
861	>	mTmp[1][2] = d*(vMtx[1][0]*vMtx[0][2] - vMtx[1][2]*vMtx[0][0]);
862	>	mTmp[2][0] = d*(vMtx[2][1]*vMtx[1][0] - vMtx[2][0]*vMtx[1][1]);
863	>	mTmp[2][1] = d*(vMtx[2][0]*vMtx[0][1] - vMtx[2][1]*vMtx[0][0]);
864	>	mTmp[2][2] = d*(vMtx[1][1]*vMtx[0][0] - vMtx[1][0]*vMtx[0][1]);
865	>	memcpy(iMtx, mTmp, sizeof(mTmp));
866	>	return SDEnone;
867	>	}
868	>
869	>	/* Transform and normalize direction (column) vector */
870	>	SDError
871	>	SDmapDir(FVECT resVec, RREAL vMtx[3][3], const FVECT inpVec)
872	>	{
873	>	FVECT   vTmp;
874	>
875	>	if ((resVec == NULL) | (inpVec == NULL))
876	>	return SDEargument;
877	>	if (vMtx == NULL) {             /* assume they just want to normalize */
878	>	if (resVec != inpVec)
879	>	VCOPY(resVec, inpVec);
880	>	return (normalize(resVec) > 0) ? SDEnone : SDEargument;
881		}
882	<	return(1);
882	>	vTmp[0] = DOT(vMtx[0], inpVec);
883	>	vTmp[1] = DOT(vMtx[1], inpVec);
884	>	vTmp[2] = DOT(vMtx[2], inpVec);
885	>	if (normalize(vTmp) == 0)
886	>	return SDEargument;
887	>	VCOPY(resVec, vTmp);
888	>	return SDEnone;
889		}

Diff Legend

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