ViewVC Help

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

root/Development/ray/src/common/bsdf_m.c

Comparing ray/src/common/bsdf_m.c (file contents):
Revision 3.6 by greg, Mon Feb 21 22:50:37 2011 UTC vs.
Revision 3.27 by greg, Sat Jun 29 21:03:44 2013 UTC

#	Line 11 | Line 11 | static const char RCSid[] = "$Id$";
11		*
12		*/
13
14	+	#define _USE_MATH_DEFINES
15		#include "rtio.h"
16		#include <stdlib.h>
17		#include <math.h>
#	Line 28 | Line 29 | static const char RCSid[] = "$Id$";
29		#define RC_INTERR       (-4)
30		#define RC_MEMERR       (-5)
31
32	<	#define MAXLATS         46              /* maximum number of latitudes */
32	<
33	<	/* BSDF angle specification */
34	<	typedef struct {
35	<	char    name[64];               /* basis name */
36	<	int     nangles;                /* total number of directions */
37	<	struct {
38	<	float   tmin;                   /* starting theta */
39	<	int     nphis;                  /* number of phis (0 term) */
40	<	} lat[MAXLATS+1];               /* latitudes */
41	<	} ANGLE_BASIS;
42	<
43	<	#define MAXABASES       7               /* limit on defined bases */
44	<
45	<	static ANGLE_BASIS      abase_list[MAXABASES] = {
32	>	ANGLE_BASIS     abase_list[MAXABASES] = {
33		{
34		"LBNL/Klems Full", 145,
35	<	{ {-5., 1},
35	>	{ {0., 1},
36		{5., 8},
37		{15., 16},
38		{25., 20},
#	Line 57 | Line 44 | static ANGLE_BASIS     abase_list[MAXABASES] = {
44		{90., 0} }
45		}, {
46		"LBNL/Klems Half", 73,
47	<	{ {-6.5, 1},
47	>	{ {0., 1},
48		{6.5, 8},
49		{19.5, 12},
50		{32.5, 16},
#	Line 67 | Line 54 | static ANGLE_BASIS     abase_list[MAXABASES] = {
54		{90., 0} }
55		}, {
56		"LBNL/Klems Quarter", 41,
57	<	{ {-9., 1},
57	>	{ {0., 1},
58		{9., 8},
59		{27., 12},
60		{46., 12},
#	Line 76 | Line 63 | static ANGLE_BASIS     abase_list[MAXABASES] = {
63		}
64		};
65
66	<	static int      nabases = 3;    /* current number of defined bases */
66	>	int             nabases = 3;            /* current number of defined bases */
67
68		static int
69		fequal(double a, double b)
70		{
71	<	if (b != .0)
71	>	if (b != 0)
72		a = a/b - 1.;
73		return (a <= 1e-6) & (a >= -1e-6);
74		}
75
76	<	/* returns the name of the given tag */
90	<	#ifdef ezxml_name
91	<	#undef ezxml_name
92	<	static char *
93	<	ezxml_name(ezxml_t xml)
94	<	{
95	<	if (xml == NULL)
96	<	return NULL;
97	<	return xml->name;
98	<	}
99	<	#endif
100	<
101	<	/* returns the given tag's character content or empty string if none */
76	>	/* Returns the given tag's character content or empty string if none */
77		#ifdef ezxml_txt
78		#undef ezxml_txt
79		static char *
#	Line 157 | Line 132 | SDnewMatrix(int ni, int no)
132		/* Free a BSDF matrix */
133		#define SDfreeMatrix            free
134
135	<	/* get vector for this angle basis index */
136	<	static int
137	<	ab_getvec(FVECT v, int ndx, double randX, void *p)
135	>	/* Get vector for this angle basis index (front exiting) */
136	>	int
137	>	fo_getvec(FVECT v, double ndxr, void *p)
138		{
139	<	ANGLE_BASIS  *ab = (ANGLE_BASIS *)p;
139	>	ANGLE_BASIS     *ab = (ANGLE_BASIS *)p;
140	>	int             ndx = (int)ndxr;
141	>	double          randX = ndxr - ndx;
142		double          rx[2];
143		int             li;
144		double          pol, azi, d;
145
146	<	if ((ndx < 0) | (ndx >= ab->nangles))
146	>	if ((ndxr < 0) | (ndx >= ab->nangles))
147		return RC_FAIL;
148		for (li = 0; ndx >= ab->lat[li].nphis; li++)
149		ndx -= ab->lat[li].nphis;
#	Line 181 | Line 158 | ab_getvec(FVECT v, int ndx, double randX, void *p)
158		return RC_GOOD;
159		}
160
161	<	/* get index corresponding to the given vector */
162	<	static int
163	<	ab_getndx(const FVECT v, void *p)
161	>	/* Get index corresponding to the given vector (front exiting) */
162	>	int
163	>	fo_getndx(const FVECT v, void *p)
164		{
165	<	ANGLE_BASIS  *ab = (ANGLE_BASIS *)p;
165	>	ANGLE_BASIS     *ab = (ANGLE_BASIS *)p;
166		int     li, ndx;
167	<	double  pol, azi, d;
167	>	double  pol, azi;
168
169		if (v == NULL)
170		return -1;
171	<	if ((v[2] < .0) | (v[2] > 1.0))
171	>	if ((v[2] < 0) | (v[2] > 1.))
172		return -1;
173	<	pol = 180.0/M_PI*acos(v[2]);
173	>	pol = 180.0/M_PI*Acos(v[2]);
174		azi = 180.0/M_PI*atan2(v[1], v[0]);
175		if (azi < 0.0) azi += 360.0;
176		for (li = 1; ab->lat[li].tmin <= pol; li++)
#	Line 210 | Line 187 | ab_getndx(const FVECT v, void *p)
187		/* compute square of real value */
188		static double sq(double x) { return x*x; }
189
190	<	/* get projected solid angle for this angle basis index */
191	<	static double
192	<	ab_getohm(int ndx, void *p)
190	>	/* Get projected solid angle for this angle basis index (universal) */
191	>	double
192	>	io_getohm(int ndx, void *p)
193		{
194		static int      last_li = -1;
195		static double   last_ohm;
#	Line 227 | Line 204 | ab_getohm(int ndx, void *p)
204		if (li == last_li)                      /* cached latitude? */
205		return last_ohm;
206		last_li = li;
230	–	theta1 = M_PI/180. * ab->lat[li+1].tmin;
231	–	if (ab->lat[li].nphis == 1)             /* special case */
232	–	return last_ohm = M_PI*(1. - sq(cos(theta1)));
207		theta = M_PI/180. * ab->lat[li].tmin;
208	+	theta1 = M_PI/180. * ab->lat[li+1].tmin;
209		return last_ohm = M_PI*(sq(cos(theta)) - sq(cos(theta1))) /
210		(double)ab->lat[li].nphis;
211		}
212
213	<	/* get reverse vector for this angle basis index */
214	<	static int
215	<	ab_getvecR(FVECT v, int ndx, double randX, void *p)
213	>	/* Get vector for this angle basis index (back incident) */
214	>	int
215	>	bi_getvec(FVECT v, double ndxr, void *p)
216		{
217	<	int     na = (*(ANGLE_BASIS *)p).nangles;
243	<
244	<	if (!ab_getvec(v, ndx, randX, p))
217	>	if (!fo_getvec(v, ndxr, p))
218		return RC_FAIL;
219
220		v[0] = -v[0];
#	Line 251 | Line 224 | ab_getvecR(FVECT v, int ndx, double randX, void *p)
224		return RC_GOOD;
225		}
226
227	<	/* get index corresponding to the reverse vector */
228	<	static int
229	<	ab_getndxR(const FVECT v, void *p)
227	>	/* Get index corresponding to the vector (back incident) */
228	>	int
229	>	bi_getndx(const FVECT v, void *p)
230		{
231		FVECT  v2;
232
#	Line 261 | Line 234 | ab_getndxR(const FVECT v, void *p)
234		v2[1] = -v[1];
235		v2[2] = -v[2];
236
237	<	return ab_getndx(v2, p);
237	>	return fo_getndx(v2, p);
238		}
239
240	+	/* Get vector for this angle basis index (back exiting) */
241	+	int
242	+	bo_getvec(FVECT v, double ndxr, void *p)
243	+	{
244	+	if (!fo_getvec(v, ndxr, p))
245	+	return RC_FAIL;
246	+
247	+	v[2] = -v[2];
248	+
249	+	return RC_GOOD;
250	+	}
251	+
252	+	/* Get index corresponding to the vector (back exiting) */
253	+	int
254	+	bo_getndx(const FVECT v, void *p)
255	+	{
256	+	FVECT  v2;
257	+
258	+	v2[0] = v[0];
259	+	v2[1] = v[1];
260	+	v2[2] = -v[2];
261	+
262	+	return fo_getndx(v2, p);
263	+	}
264	+
265	+	/* Get vector for this angle basis index (front incident) */
266	+	int
267	+	fi_getvec(FVECT v, double ndxr, void *p)
268	+	{
269	+	if (!fo_getvec(v, ndxr, p))
270	+	return RC_FAIL;
271	+
272	+	v[0] = -v[0];
273	+	v[1] = -v[1];
274	+
275	+	return RC_GOOD;
276	+	}
277	+
278	+	/* Get index corresponding to the vector (front incident) */
279	+	int
280	+	fi_getndx(const FVECT v, void *p)
281	+	{
282	+	FVECT  v2;
283	+
284	+	v2[0] = -v[0];
285	+	v2[1] = -v[1];
286	+	v2[2] = v[2];
287	+
288	+	return fo_getndx(v2, p);
289	+	}
290	+
291		/* load custom BSDF angle basis */
292		static int
293		load_angle_basis(ezxml_t wab)
#	Line 295 | Line 319 | load_angle_basis(ezxml_t wab)
319		ezxml_child(ezxml_child(wbb,
320		"ThetaBounds"), "UpperTheta")));
321		if (!i)
322	<	abase_list[nabases].lat[i].tmin =
299	<	-abase_list[nabases].lat[i+1].tmin;
322	>	abase_list[nabases].lat[0].tmin = 0;
323		else if (!fequal(atof(ezxml_txt(ezxml_child(ezxml_child(wbb,
324		"ThetaBounds"), "LowerTheta"))),
325		abase_list[nabases].lat[i].tmin)) {
326		sprintf(SDerrorDetail, "Theta values disagree in '%s'",
327	<	abname);
327	>	abname);
328		return RC_DATERR;
329		}
330		abase_list[nabases].nangles +=
#	Line 311 | Line 334 | load_angle_basis(ezxml_t wab)
334		(abase_list[nabases].lat[i].nphis == 1 &&
335		abase_list[nabases].lat[i].tmin > FTINY)) {
336		sprintf(SDerrorDetail, "Illegal phi count in '%s'",
337	<	abname);
337	>	abname);
338		return RC_DATERR;
339		}
340		}
#	Line 366 | Line 389 | load_bsdf_data(SDData *sd, ezxml_t wdb, int rowinc)
389		int             i;
390		/* allocate BSDF component */
391		sdata = ezxml_txt(ezxml_child(wdb, "WavelengthDataDirection"));
392	<	if (!strcasecmp(sdata, "Transmission Back") || (sd->tf == NULL &&
393	<	!strcasecmp(sdata, "Transmission Front"))) {
392	>	if (!sdata)
393	>	return RC_FAIL;
394	>	/*
395	>	* Remember that front and back are reversed from WINDOW 6 orientations
396	>	*/
397	>	if (!strcasecmp(sdata, "Transmission Front")) {
398	>	if (sd->tb != NULL)
399	>	SDfreeSpectralDF(sd->tb);
400	>	if ((sd->tb = SDnewSpectralDF(1)) == NULL)
401	>	return RC_MEMERR;
402	>	df = sd->tb;
403	>	} else if (!strcasecmp(sdata, "Transmission Back")) {
404		if (sd->tf != NULL)
405		SDfreeSpectralDF(sd->tf);
406		if ((sd->tf = SDnewSpectralDF(1)) == NULL)
407		return RC_MEMERR;
408		df = sd->tf;
409		} else if (!strcasecmp(sdata, "Reflection Front")) {
410	<	if (sd->rb != NULL)     /* note back-front reversal */
410	>	if (sd->rb != NULL)
411		SDfreeSpectralDF(sd->rb);
412		if ((sd->rb = SDnewSpectralDF(1)) == NULL)
413		return RC_MEMERR;
414		df = sd->rb;
415		} else if (!strcasecmp(sdata, "Reflection Back")) {
416	<	if (sd->rf != NULL)     /* note front-back reversal */
416	>	if (sd->rf != NULL)
417		SDfreeSpectralDF(sd->rf);
418		if ((sd->rf = SDnewSpectralDF(1)) == NULL)
419		return RC_MEMERR;
#	Line 422 | Line 455 | load_bsdf_data(SDData *sd, ezxml_t wdb, int rowinc)
455		dp->ib_priv = &abase_list[inbi];
456		dp->ob_priv = &abase_list[outbi];
457		if (df == sd->tf) {
458	<	dp->ib_vec = &ab_getvecR;
459	<	dp->ib_ndx = &ab_getndxR;
460	<	dp->ob_vec = &ab_getvec;
461	<	dp->ob_ndx = &ab_getndx;
458	>	dp->ib_vec = &fi_getvec;
459	>	dp->ib_ndx = &fi_getndx;
460	>	dp->ob_vec = &bo_getvec;
461	>	dp->ob_ndx = &bo_getndx;
462	>	} else if (df == sd->tb) {
463	>	dp->ib_vec = &bi_getvec;
464	>	dp->ib_ndx = &bi_getndx;
465	>	dp->ob_vec = &fo_getvec;
466	>	dp->ob_ndx = &fo_getndx;
467		} else if (df == sd->rf) {
468	<	dp->ib_vec = &ab_getvec;
469	<	dp->ib_ndx = &ab_getndx;
470	<	dp->ob_vec = &ab_getvec;
471	<	dp->ob_ndx = &ab_getndx;
468	>	dp->ib_vec = &fi_getvec;
469	>	dp->ib_ndx = &fi_getndx;
470	>	dp->ob_vec = &fo_getvec;
471	>	dp->ob_ndx = &fo_getndx;
472		} else /* df == sd->rb */ {
473	<	dp->ib_vec = &ab_getvecR;
474	<	dp->ib_ndx = &ab_getndxR;
475	<	dp->ob_vec = &ab_getvecR;
476	<	dp->ob_ndx = &ab_getndxR;
473	>	dp->ib_vec = &bi_getvec;
474	>	dp->ib_ndx = &bi_getndx;
475	>	dp->ob_vec = &bo_getvec;
476	>	dp->ob_ndx = &bo_getndx;
477		}
478	<	dp->ib_ohm = &ab_getohm;
479	<	dp->ob_ohm = &ab_getohm;
478	>	dp->ib_ohm = &io_getohm;
479	>	dp->ob_ohm = &io_getohm;
480		df->comp[0].cspec[0] = c_dfcolor; /* XXX monochrome for now */
481		df->comp[0].dist = dp;
482		df->comp[0].func = &SDhandleMtx;
483		/* read BSDF data */
484	<	sdata  = ezxml_txt(ezxml_child(wdb,"ScatteringData"));
484	>	sdata = ezxml_txt(ezxml_child(wdb, "ScatteringData"));
485		if (!sdata || !*sdata) {
486		sprintf(SDerrorDetail, "Missing BSDF ScatteringData in '%s'",
487		sd->name);
#	Line 457 | Line 495 | load_bsdf_data(SDData *sd, ezxml_t wdb, int rowinc)
495		sd->name);
496		return RC_FORMERR;
497		}
498	<	while (*sdnext && isspace(*sdnext))
498	>	while (isspace(*sdnext))
499		sdnext++;
500		if (*sdnext == ',') sdnext++;
501		if (rowinc) {
502		int     r = i/dp->nout;
503	<	int     c = i - c*dp->nout;
503	>	int     c = i - r*dp->nout;
504		mBSDF_value(dp,r,c) = atof(sdata);
505		} else
506		dp->bsdf[i] = atof(sdata);
#	Line 482 | Line 520 | subtract_min(SDMat *sm)
520		for (i = n; --i; )
521		if (sm->bsdf[i] < minv)
522		minv = sm->bsdf[i];
523	+
524	+	if (minv <= FTINY)
525	+	return .0;
526	+
527		for (i = n; i--; )
528		sm->bsdf[i] -= minv;
529
#	Line 507 | Line 549 | extract_diffuse(SDValue *dv, SDSpectralDF *df)
549		c_cmix(&dv->spec, dv->cieY, &dv->spec, ymin, &df->comp[n].cspec[0]);
550		dv->cieY += ymin;
551		}
552	<	df->maxHemi -= dv->cieY;        /* adjust minimum hemispherical */
552	>	df->maxHemi -= dv->cieY;        /* adjust maximum hemispherical */
553		/* make sure everything is set */
554		c_ccvt(&dv->spec, C_CSXY+C_CSSPEC);
555		}
#	Line 516 | Line 558 | extract_diffuse(SDValue *dv, SDSpectralDF *df)
558		SDError
559		SDloadMtx(SDData *sd, ezxml_t wtl)
560		{
561	<	ezxml_t                 wld, wdb;
562	<	int                     rowIn;
563	<	struct BSDF_data        *dp;
564	<	char                    *txt;
565	<	int                     rval;
524	<
561	>	ezxml_t         wld, wdb;
562	>	int             rowIn;
563	>	char            *txt;
564	>	int             rval;
565	>	/* basic checks and data ordering */
566		txt = ezxml_txt(ezxml_child(ezxml_child(wtl,
567		"DataDefinition"), "IncidentDataStructure"));
568		if (txt == NULL || !*txt) {
#	Line 540 | Line 581 | SDloadMtx(SDData *sd, ezxml_t wtl)
581		sd->name);
582		return SDEsupport;
583		}
584	<	/* get angle basis */
585	<	rval = load_angle_basis(ezxml_child(ezxml_child(wtl,
586	<	"DataDefinition"), "AngleBasis"));
587	<	if (rval < 0)
588	<	return convert_errcode(rval);
589	<	/* load BSDF components */
584	>	/* get angle bases */
585	>	for (wld = ezxml_child(ezxml_child(wtl, "DataDefinition"), "AngleBasis");
586	>	wld != NULL; wld = wld->next) {
587	>	rval = load_angle_basis(wld);
588	>	if (rval < 0)
589	>	return convert_errcode(rval);
590	>	}
591	>	/* load BSDF components */
592		for (wld = ezxml_child(wtl, "WavelengthData");
593		wld != NULL; wld = wld->next) {
594		if (strcasecmp(ezxml_txt(ezxml_child(wld,"Wavelength")),
#	Line 556 | Line 599 | SDloadMtx(SDData *sd, ezxml_t wtl)
599		if ((rval = load_bsdf_data(sd, wdb, rowIn)) < 0)
600		return convert_errcode(rval);
601		}
602	<	/* separate diffuse components */
602	>	/* separate diffuse components */
603		extract_diffuse(&sd->rLambFront, sd->rf);
604		extract_diffuse(&sd->rLambBack, sd->rb);
605	<	extract_diffuse(&sd->tLamb, sd->tf);
606	<	/* return success */
605	>	if (sd->tf != NULL)
606	>	extract_diffuse(&sd->tLamb, sd->tf);
607	>	if (sd->tb != NULL)
608	>	extract_diffuse(&sd->tLamb, sd->tb);
609	>	/* return success */
610		return SDEnone;
611		}
612
613		/* Get Matrix BSDF value */
614		static int
615		SDgetMtxBSDF(float coef[SDmaxCh], const FVECT outVec,
616	<	const FVECT inVec, const void *dist)
616	>	const FVECT inVec, SDComponent *sdc)
617		{
618	<	const SDMat     *dp = (const SDMat *)dist;
618	>	const SDMat     *dp;
619		int             i_ndx, o_ndx;
620	+	/* check arguments */
621	+	if ((coef == NULL) | (outVec == NULL) | (inVec == NULL) | (sdc == NULL)
622	+	|| (dp = (SDMat *)sdc->dist) == NULL)
623	+	return 0;
624		/* get angle indices */
625		i_ndx = mBSDF_incndx(dp, inVec);
626		o_ndx = mBSDF_outndx(dp, outVec);
#	Line 585 | Line 635 | SDgetMtxBSDF(float coef[SDmaxCh], const FVECT outVec,
635		return 1;                       /* XXX monochrome for now */
636		}
637
638	<	/* Query solid angle for vector */
638	>	/* Query solid angle for vector(s) */
639		static SDError
640	<	SDqueryMtxProjSA(double *psa, const FVECT vec, int qflags, const void *dist)
640	>	SDqueryMtxProjSA(double *psa, const FVECT v1, const RREAL *v2,
641	>	int qflags, SDComponent *sdc)
642		{
643	<	const SDMat     *dp = (const SDMat *)dist;
643	>	const SDMat     *dp;
644		double          inc_psa, out_psa;
645		/* check arguments */
646	<	if ((psa == NULL) | (vec == NULL) | (dp == NULL))
646	>	if ((psa == NULL) | (v1 == NULL) | (sdc == NULL) ||
647	>	(dp = (SDMat *)sdc->dist) == NULL)
648		return SDEargument;
649	+	if (v2 == NULL)
650	+	v2 = v1;
651		/* get projected solid angles */
652	<	inc_psa = mBSDF_incohm(dp, mBSDF_incndx(dp, vec));
653	<	out_psa = mBSDF_outohm(dp, mBSDF_outndx(dp, vec));
652	>	out_psa = mBSDF_outohm(dp, mBSDF_outndx(dp, v1));
653	>	inc_psa = mBSDF_incohm(dp, mBSDF_incndx(dp, v2));
654	>	if ((v1 != v2) & (out_psa <= 0) & (inc_psa <= 0)) {
655	>	inc_psa = mBSDF_outohm(dp, mBSDF_outndx(dp, v2));
656	>	out_psa = mBSDF_incohm(dp, mBSDF_incndx(dp, v1));
657	>	}
658
659		switch (qflags) {               /* record based on flag settings */
602	–	case SDqueryVal:
603	–	psa[0] = .0;
604	–	/* fall through */
660		case SDqueryMax:
661		if (inc_psa > psa[0])
662		psa[0] = inc_psa;
#	Line 609 | Line 664 | SDqueryMtxProjSA(double *psa, const FVECT vec, int qfl
664		psa[0] = out_psa;
665		break;
666		case SDqueryMin+SDqueryMax:
667	<	if (inc_psa > psa[0])
667	>	if (inc_psa > psa[1])
668		psa[1] = inc_psa;
669	<	if (out_psa > psa[0])
669	>	if (out_psa > psa[1])
670		psa[1] = out_psa;
671		/* fall through */
672	+	case SDqueryVal:
673	+	if (qflags == SDqueryVal)
674	+	psa[0] = M_PI;
675	+	/* fall through */
676		case SDqueryMin:
677	<	if ((inc_psa > .0) & (inc_psa < psa[0]))
677	>	if ((inc_psa > 0) & (inc_psa < psa[0]))
678		psa[0] = inc_psa;
679	<	if ((out_psa > .0) & (out_psa < psa[0]))
679	>	if ((out_psa > 0) & (out_psa < psa[0]))
680		psa[0] = out_psa;
681		break;
682		}
683		/* make sure it's legal */
684	<	return (psa[0] <= .0) ? SDEinternal : SDEnone;
684	>	return (psa[0] <= 0) ? SDEinternal : SDEnone;
685		}
686
687		/* Compute new cumulative distribution from BSDF */
#	Line 660 | Line 719 | make_cdist(SDMatCDst *cd, const FVECT inVec, SDMat *dp
719		static const SDCDst *
720		SDgetMtxCDist(const FVECT inVec, SDComponent *sdc)
721		{
722	<	SDMat           *dp = (SDMat *)sdc->dist;
722	>	SDMat           *dp;
723		int             reverse;
724		SDMatCDst       myCD;
725		SDMatCDst       *cd, *cdlast;
726		/* check arguments */
727	<	if ((inVec == NULL) | (dp == NULL))
727	>	if ((inVec == NULL) | (sdc == NULL) ||
728	>	(dp = (SDMat *)sdc->dist) == NULL)
729		return NULL;
730		memset(&myCD, 0, sizeof(myCD));
731		myCD.indx = mBSDF_incndx(dp, inVec);
#	Line 684 | Line 744 | SDgetMtxCDist(const FVECT inVec, SDComponent *sdc)
744		reverse = 1;
745		}
746		cdlast = NULL;                  /* check for it in cache list */
747	<	for (cd = (SDMatCDst *)sdc->cdList;
748	<	cd != NULL; cd = (SDMatCDst *)cd->next) {
747	>	for (cd = (SDMatCDst *)sdc->cdList; cd != NULL;
748	>	cdlast = cd, cd = cd->next)
749		if (cd->indx == myCD.indx && (cd->calen == myCD.calen) &
750		(cd->ob_priv == myCD.ob_priv) &
751		(cd->ob_vec == myCD.ob_vec))
752		break;
693	–	cdlast = cd;
694	–	}
753		if (cd == NULL) {               /* need to allocate new entry */
754		cd = (SDMatCDst *)malloc(sizeof(SDMatCDst) +
755	<	myCD.calen*sizeof(myCD.carr[0]));
755	>	sizeof(myCD.carr[0])*myCD.calen);
756		if (cd == NULL)
757		return NULL;
758		*cd = myCD;             /* compute cumulative distribution */
#	Line 706 | Line 764 | SDgetMtxCDist(const FVECT inVec, SDComponent *sdc)
764		}
765		if (cdlast != NULL) {           /* move entry to head of cache list */
766		cdlast->next = cd->next;
767	<	cd->next = sdc->cdList;
767	>	cd->next = (SDMatCDst *)sdc->cdList;
768		sdc->cdList = (SDCDst *)cd;
769		}
770		return (SDCDst *)cd;            /* ready to go */
#	Line 714 | Line 772 | SDgetMtxCDist(const FVECT inVec, SDComponent *sdc)
772
773		/* Sample cumulative distribution */
774		static SDError
775	<	SDsampMtxCDist(FVECT outVec, double randX, const SDCDst *cdp)
775	>	SDsampMtxCDist(FVECT ioVec, double randX, const SDCDst *cdp)
776		{
777		const unsigned  maxval = ~0;
778		const SDMatCDst *mcd = (const SDMatCDst *)cdp;
779		const unsigned  target = randX*maxval;
780		int             i, iupper, ilower;
781		/* check arguments */
782	<	if ((outVec == NULL) | (mcd == NULL))
782	>	if ((ioVec == NULL) | (mcd == NULL))
783		return SDEargument;
784		/* binary search to find index */
785		ilower = 0; iupper = mcd->calen;
786		while ((i = (iupper + ilower) >> 1) != ilower)
787	<	if ((long)target >= (long)mcd->carr[i])
787	>	if (target >= mcd->carr[i])
788		ilower = i;
789		else
790		iupper = i;
#	Line 734 | Line 792 | SDsampMtxCDist(FVECT outVec, double randX, const SDCDs
792		randX = (randX*maxval - mcd->carr[ilower]) /
793		(double)(mcd->carr[iupper] - mcd->carr[ilower]);
794		/* convert index to vector */
795	<	if ((*mcd->ob_vec)(outVec, i, randX, mcd->ob_priv))
795	>	if ((*mcd->ob_vec)(ioVec, i+randX, mcd->ob_priv))
796		return SDEnone;
797	<	strcpy(SDerrorDetail, "BSDF sampling fault");
797	>	strcpy(SDerrorDetail, "Matrix BSDF sampling fault");
798		return SDEinternal;
799		}
800

Diff Legend

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