ViewVC Help

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

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

Comparing ray/src/common/bsdf.c (file contents):
Revision 2.45 by greg, Wed Jul 3 18:56:19 2013 UTC vs.
Revision 2.59 by greg, Sat Mar 27 17:50:18 2021 UTC

#	Line 47 | Line 47 | const SDCDst           SDemptyCD;
47		/* Cache of loaded BSDFs */
48		struct SDCache_s        *SDcacheList = NULL;
49
50	<	/* Retain BSDFs in cache list */
50	>	/* Retain BSDFs in cache list? */
51		int                     SDretainSet = SDretainNone;
52
53	+	/* Maximum cache size for any given BSDF? */
54	+	unsigned long           SDmaxCache = 0;         /* 0 == unlimited */
55	+
56		/* Report any error to the indicated stream */
57		SDError
58		SDreportError(SDError ec, FILE *fp)
#	Line 199 | Line 202 | SDloadFile(SDData *sd, const char *fname)
202		}
203		wtl = ezxml_child(ezxml_child(fl, "Optical"), "Layer");
204		if (wtl == NULL) {
205	<	sprintf(SDerrorDetail, "BSDF \"%s\": no optical layers'",
205	>	sprintf(SDerrorDetail, "BSDF \"%s\": no optical layers",
206		sd->name);
207		ezxml_free(fl);
208		return SDEformat;
#	Line 378 | Line 381 | SDfreeBSDF(SDData *sd)
381		sd->rLambFront.spec.flags = 0;
382		sd->rLambBack.cieY = .0;
383		sd->rLambBack.spec.flags = 0;
384	<	sd->tLamb.cieY = .0;
385	<	sd->tLamb.spec.flags = 0;
384	>	sd->tLambFront.cieY = .0;
385	>	sd->tLambFront.spec.flags = 0;
386	>	sd->tLambBack.cieY = .0;
387	>	sd->tLambBack.spec.flags = 0;
388		}
389
390		/* Find writeable BSDF by name, or allocate new cache entry if absent */
#	Line 422 | Line 427 | SDcacheFile(const char *fname)
427		if (fname == NULL || !*fname)
428		return NULL;
429		SDerrorDetail[0] = '\0';
430	+	/* PLACE MUTEX LOCK HERE FOR THREAD-SAFE */
431		if ((sd = SDgetCache(fname)) == NULL) {
432		SDreportError(SDEmemory, stderr);
433		return NULL;
#	Line 429 | Line 435 | SDcacheFile(const char *fname)
435		if (!SDisLoaded(sd) && (ec = SDloadFile(sd, fname))) {
436		SDreportError(ec, stderr);
437		SDfreeCache(sd);
438	<	return NULL;
438	>	sd = NULL;
439		}
440	+	/* END MUTEX LOCK */
441		return sd;
442		}
443
#	Line 494 | Line 501 | SDsampComponent(SDValue *sv, FVECT ioVec, double randX
501		sv->cieY = cd->cTotal;
502		if (sv->cieY <= 1e-6) {         /* nothing to sample? */
503		sv->spec = c_dfcolor;
504	<	memset(ioVec, 0, 3*sizeof(double));
504	>	memset(ioVec, 0, sizeof(FVECT));
505		return SDEnone;
506		}
507		/* compute sample direction */
#	Line 513 | Line 520 | SDsampComponent(SDValue *sv, FVECT ioVec, double randX
520		c_cmix(&sv->spec, d, &sv->spec, coef[n], &sdc->cspec[n]);
521		d += coef[n];
522		}
523	<	/* make sure everything is set */
517	<	c_ccvt(&sv->spec, C_CSXY+C_CSSPEC);
523	>	c_ccvt(&sv->spec, C_CSXY);      /* make sure (x,y) is set */
524		return SDEnone;
525		}
526
#	Line 558 | Line 564 | SDdiffuseSamp(FVECT outVec, int outFront, double randX
564		SDmultiSamp(outVec, 2, randX);
565		SDsquare2disk(outVec, outVec[0], outVec[1]);
566		outVec[2] = 1. - outVec[0]*outVec[0] - outVec[1]*outVec[1];
567	<	if (outVec[2] > 0)              /* a bit of paranoia */
562	<	outVec[2] = sqrt(outVec[2]);
567	>	outVec[2] = sqrt(outVec[2]*(outVec[2]>0));
568		if (!outFront)                  /* going out back? */
569		outVec[2] = -outVec[2];
570		}
#	Line 596 | Line 601 | SDsizeBSDF(double *projSA, const FVECT v1, const RREAL
601		rdf = sd->rb;
602		tdf = (sd->tb != NULL) ? sd->tb : sd->tf;
603		}
604	<	if (v2 != NULL)                 /* bidirectional? */
604	>	if (v2 != NULL) {               /* bidirectional? */
605		if (v1[2] > 0 ^ v2[2] > 0)
606		rdf = NULL;
607		else
608		tdf = NULL;
609	+	}
610		ec = SDEdata;                   /* run through components */
611		for (i = (rdf==NULL) ? 0 : rdf->ncomp; i--; ) {
612		ec = (*rdf->comp[i].func->queryProjSA)(projSA, v1, v2,
#	Line 618 | Line 624 | SDsizeBSDF(double *projSA, const FVECT v1, const RREAL
624		projSA[0] = M_PI;
625		if (qflags == SDqueryMin+SDqueryMax)
626		projSA[1] = M_PI;
627	<	}
627	>	} else if (qflags == SDqueryMin+SDqueryMax && projSA[0] > projSA[1])
628	>	projSA[0] = projSA[1];
629		return SDEnone;
630		}
631
#	Line 644 | Line 651 | SDevalBSDF(SDValue *sv, const FVECT outVec, const FVEC
651		*sv = sd->rLambBack;
652		sdf = sd->rb;
653		} else if (inFront) {
654	<	*sv = sd->tLamb;
654	>	*sv = sd->tLambFront;
655		sdf = (sd->tf != NULL) ? sd->tf : sd->tb;
656	<	} else /* inBack */ {
657	<	*sv = sd->tLamb;
656	>	} else /* outFront & !inFront */ {
657	>	*sv = sd->tLambBack;
658		sdf = (sd->tb != NULL) ? sd->tb : sd->tf;
659		}
660		sv->cieY *= 1./M_PI;
#	Line 662 | Line 669 | SDevalBSDF(SDValue *sv, const FVECT outVec, const FVEC
669		sv->cieY += coef[nch];
670		}
671		}
672	<	/* make sure everything is set */
666	<	c_ccvt(&sv->spec, C_CSXY+C_CSSPEC);
672	>	c_ccvt(&sv->spec, C_CSXY);      /* make sure (x,y) is set */
673		return SDEnone;
674		}
675
#	Line 691 | Line 697 | SDdirectHemi(const FVECT inVec, int sflags, const SDDa
697		if ((sflags & SDsampDf+SDsampR) != SDsampDf+SDsampR)
698		hsum = .0;
699		if ((sflags & SDsampDf+SDsampT) == SDsampDf+SDsampT)
700	<	hsum += sd->tLamb.cieY;
700	>	hsum += (inVec[2] > 0) ?
701	>	sd->tLambFront.cieY : sd->tLambBack.cieY;
702		/* gather non-diffuse components */
703		i = (((sflags & SDsampSp+SDsampR) == SDsampSp+SDsampR) &
704		(rdf != NULL)) ? rdf->ncomp : 0;
#	Line 744 | Line 751 | SDsampBSDF(SDValue *sv, FVECT ioVec, double randX, int
751		sv->cieY = .0;
752		rdiff = sv->cieY;
753		if ((sflags & SDsampDf+SDsampT) == SDsampDf+SDsampT)
754	<	sv->cieY += sd->tLamb.cieY;
754	>	sv->cieY += inFront ? sd->tLambFront.cieY : sd->tLambBack.cieY;
755		/* gather non-diffuse components */
756		i = nr = (((sflags & SDsampSp+SDsampR) == SDsampSp+SDsampR) &
757		(rdf != NULL)) ? rdf->ncomp : 0;
#	Line 763 | Line 770 | SDsampBSDF(SDValue *sv, FVECT ioVec, double randX, int
770		cdarr[i] = (*rdf->comp[i].func->getCDist)(inVec, &rdf->comp[i]);
771		if (cdarr[i] == NULL)
772		cdarr[i] = &SDemptyCD;
773	<	else
767	<	sv->cieY += cdarr[i]->cTotal;
773	>	sv->cieY += cdarr[i]->cTotal;
774		}
775		if (sv->cieY <= 1e-6) {         /* anything to sample? */
776		sv->cieY = .0;
777	<	memset(ioVec, 0, 3*sizeof(double));
777	>	memset(ioVec, 0, sizeof(FVECT));
778		return SDEnone;
779		}
780		/* scale random variable */
#	Line 781 | Line 787 | SDsampBSDF(SDValue *sv, FVECT ioVec, double randX, int
787		randX -= rdiff;
788		/* diffuse transmission? */
789		if ((sflags & SDsampDf+SDsampT) == SDsampDf+SDsampT) {
790	<	if (randX < sd->tLamb.cieY) {
791	<	sv->spec = sd->tLamb.spec;
792	<	SDdiffuseSamp(ioVec, !inFront, randX/sd->tLamb.cieY);
790	>	const SDValue   *sdt = inFront ? &sd->tLambFront : &sd->tLambBack;
791	>	if (randX < sdt->cieY) {
792	>	sv->spec = sdt->spec;
793	>	SDdiffuseSamp(ioVec, !inFront, randX/sdt->cieY);
794		goto done;
795		}
796	<	randX -= sd->tLamb.cieY;
796	>	randX -= sdt->cieY;
797		}
798		/* else one of cumulative dist. */
799	<	for (i = 0; i < n && randX < cdarr[i]->cTotal; i++)
799	>	for (i = 0; i < n && randX >= cdarr[i]->cTotal; i++)
800		randX -= cdarr[i]->cTotal;
801		if (i >= n)
802		return SDEinternal;
#	Line 814 | Line 821 | SDsampBSDF(SDValue *sv, FVECT ioVec, double randX, int
821		done:
822		if (cdarr != NULL)
823		free(cdarr);
824	<	/* make sure everything is set */
818	<	c_ccvt(&sv->spec, C_CSXY+C_CSSPEC);
824	>	c_ccvt(&sv->spec, C_CSXY);      /* make sure (x,y) is set */
825		return SDEnone;
826		}
827

Diff Legend

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