ViewVC Help

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

root/Development/ray/src/rt/pmapmat.c

Comparing ray/src/rt/pmapmat.c (file contents):
Revision 2.2 by rschregle, Wed Apr 22 15:50:44 2015 UTC vs.
Revision 2.8 by greg, Tue Aug 18 18:45:55 2015 UTC

#	Line 1 | Line 1
1	+	#ifndef lint
2	+	static const char RCSid[] = "$Id$";
3	+	#endif
4		/*
5		==================================================================
6		Photon map support routines for scattering by materials.
7
8		Roland Schregle (roland.schregle@{hslu.ch, gmail.com})
9		(c) Fraunhofer Institute for Solar Energy Systems,
10	<	Lucerne University of Applied Sciences & Arts
10	>	(c) Lucerne University of Applied Sciences and Arts,
11	>	supported by the Swiss National Science Foundation (SNSF, #147053)
12		==================================================================
13
14		$Id$
#	Line 198 | Line 202 | static int isoSpecPhotonScatter (NORMDAT *nd, RAY *ray
202		int      niter, i = 0;
203
204		/* Set up sample coordinates */
205	<	do {
202	<	v [0] = v [1] = v [2] = 0;
203	<	v [i++] = 1;
204	<	fcross(u, v, nd -> pnorm);
205	<	} while (normalize(u) < FTINY);
206	<
205	>	getperpendicular(u, nd -> pnorm, 1);
206		fcross(v, nd -> pnorm, u);
207
208		if (nd -> specfl & SP_REFL) {
#	Line 267 | Line 266 | static void diffPhotonScatter (FVECT normal, RAY* rayO
266		int         i = 0;
267
268		/* Set up sample coordinates */
269	<	do {
271	<	v [0] = v [1] = v [2] = 0;
272	<	v [i++] = 1;
273	<	fcross(u, v, normal);
274	<	} while (normalize(u) < FTINY);
275	<
269	>	getperpendicular(u, normal, 1);
270		fcross(v, normal, u);
271
272		/* Convert theta & phi to cartesian */
#	Line 323 | Line 317 | static int normalPhotonScatter (OBJREC *mat, RAY *rayI
317		nd.specfl |= SP_FLAT;
318
319		/* Perturb normal */
320	<	if ((hastexture = DOT(rayIn -> pert, rayIn -> pert)) > sqr(FTINY))
320	>	if ((hastexture = (DOT(rayIn -> pert, rayIn -> pert) > sqr(FTINY)) ))
321		nd.pdot = raynormal(nd.pnorm, rayIn);
322		else {
323		VCOPY(nd.pnorm, rayIn -> ron);
#	Line 752 | Line 746 | static int dielectricPhotonScatter (OBJREC *mat, RAY *
746		/* get modifiers */
747		raytexture(rayIn, mat -> omod);
748
749	<	if ((hastexture = DOT(rayIn -> pert, rayIn -> pert)) > FTINY * FTINY)
749	>	if ((hastexture = (DOT(rayIn -> pert, rayIn -> pert) > FTINY * FTINY)))
750		/* Perturb normal */
751		cos1 = raynormal(dnorm, rayIn);
752		else {
#	Line 899 | Line 893 | static int glassPhotonScatter (OBJREC *mat, RAY *rayIn
893		/* reorient if necessary */
894		if (rayIn -> rod < 0)
895		flipsurface(rayIn);
896	<	if ((hastexture = DOT(rayIn -> pert, rayIn -> pert)) > FTINY * FTINY)
896	>	if ((hastexture = (DOT(rayIn -> pert, rayIn -> pert) > FTINY * FTINY) ))
897		pdot = raynormal(pnorm, rayIn);
898		else {
899		VCOPY(pnorm, rayIn -> ron);
#	Line 1383 | Line 1377 | static int pattexPhotonScatter (OBJREC *mat, RAY *rayI
1377
1378
1379
1380	<	#if 0
1381	<	static int bsdfPhotonScatter (OBJREC *mat, RAY *rayIn)
1382	<	/* Generate new photon ray for BSDF modifier and recurse. */
1383	<	{
1384	<	int      hitFront;
1385	<	SDError  err;
1386	<	FVECT        upvec;
1393	<	MFUNC        *mf;
1394	<	BSDFDAT   nd;
1395	<	RAY      rayOut;
1380	>	/*
1381	>	==================================================================
1382	>	The following code is
1383	>	(c) Lucerne University of Applied Sciences and Arts,
1384	>	supported by the Swiss National Science Foundation (SNSF, #147053)
1385	>	==================================================================
1386	>	*/
1387
1397	–	/* Following code adapted from m_bsdf() */
1398	–	/* Check arguments */
1399	–	if (mat -> oargs.nsargs < 6 || mat -> oargs.nfargs > 9 ||
1400	–	mat -> oargs.nfargs % 3)
1401	–	objerror(mat, USER, "bad # arguments");
1402	–
1403	–	hitFront = (rayIn -> rod > 0);
1404	–
1405	–	/* Load cal file */
1406	–	mf = getfunc(mat, 5, 0x1d, 1);
1407	–
1408	–	/* Get thickness */
1409	–	nd.thick = evalue(mf -> ep [0]);
1410	–	if ((-FTINY <= nd.thick) & (nd.thick <= FTINY))
1411	–	nd.thick = .0;
1412	–
1413	–	if (nd.thick != .0 || (!hitFront && !backvis)) {
1414	–	/* Proxy geometry present, so use it instead and transfer ray */
1415	–	photonRay(rayIn, &rayOut, PMAP_XFER, NULL);
1416	–	tracePhoton(&rayOut);
1417	–
1418	–	return 0;
1419	–	}
1420	–
1421	–	/* Get BSDF data */
1422	–	nd.sd = loadBSDF(mat -> oargs.sarg [1]);
1423	–
1424	–	/* Diffuse reflectance */
1425	–	if (hitFront) {
1426	–	if (mat -> oargs.nfargs < 3)
1427	–	setcolor(nd.rdiff, .0, .0, .0);
1428	–	else setcolor(nd.rdiff, mat -> oargs.farg [0], mat -> oargs.farg [1],
1429	–	mat -> oargs.farg [2]);
1430	–	}
1431	–	else if (mat -> oargs.nfargs < 6) {
1432	–	/* Check for absorbing backside */
1433	–	if (!backvis && !nd.sd -> rb && !nd.sd -> tf) {
1434	–	SDfreeCache(nd.sd);
1435	–	return 0;
1436	–	}
1437	–
1438	–	setcolor(nd.rdiff, .0, .0, .0);
1439	–	}
1440	–	else setcolor(nd.rdiff, mat -> oargs.farg [3], mat -> oargs.farg [4],
1441	–	mat -> oargs.farg [5]);
1442	–
1443	–	/* Diffuse transmittance */
1444	–	if (mat -> oargs.nfargs < 9)
1445	–	setcolor(nd.tdiff, .0, .0, .0);
1446	–	else setcolor(nd.tdiff, mat -> oargs.farg [6], mat -> oargs.farg [7],
1447	–	mat -> oargs.farg [8]);
1448	–
1449	–	nd.mp = mat;
1450	–	nd.pr = rayIn;
1451	–
1452	–	/* Get modifiers */
1453	–	raytexture(rayIn, mat -> omod);
1454	–
1455	–	/* Modify diffuse values */
1456	–	multcolor(nd.rdiff, rayIn -> pcol);
1457	–	multcolor(nd.tdiff, rayIn -> pcol);
1458	–
1459	–	/* Get up vector & xform to world coords */
1460	–	upvec [0] = evalue(mf -> ep [1]);
1461	–	upvec [1] = evalue(mf -> ep [2]);
1462	–	upvec [2] = evalue(mf -> ep [3]);
1463	–
1464	–	if (mf -> fxp != &unitxf) {
1465	–	multv3(upvec, upvec, mf -> fxp -> xfm);
1466	–	nd.thick *= mf -> fxp -> sca;
1467	–	}
1468	–
1469	–	if (rayIn -> rox) {
1470	–	multv3(upvec, upvec, rayIn -> rox -> f.xfm);
1471	–	nd.thick *= rayIn -> rox -> f.sca;
1472	–	}
1473	–
1474	–	/* Perturb normal */
1475	–	raynormal(nd.pnorm, rayIn);
1476	–
1477	–	/* Xform incident dir to local BSDF coords */
1478	–	err = SDcompXform(nd.toloc, nd.pnorm, upvec);
1479	–
1480	–	if (!err) {
1481	–	nd.vray [0] = -rayIn -> rdir [0];
1482	–	nd.vray [1] = -rayIn -> rdir [1];
1483	–	nd.vray [2] = -rayIn -> rdir [2];
1484	–	err = SDmapDir(nd.vray, nd.toloc, nd.vray);
1485	–	}
1486	–
1487	–	if (!err)
1488	–	err = SDinvXform(nd.fromloc, nd.toloc);
1489	–
1490	–	if (err) {
1491	–	objerror(mat, WARNING, "Illegal orientation vector");
1492	–	return 0;
1493	–	}
1494	–
1495	–	/* Determine BSDF resolution */
1496	–	err = SDsizeBSDF(nd.sr_vpsa, nd.vray, NULL, SDqueryMin + SDqueryMax, nd.sd);
1497	–
1498	–	if (err)
1499	–	objerror(mat, USER, transSDError(err));
1500	–
1501	–	nd.sr_vpsa [0] = sqrt(nd.sr_vpsa [0]);
1502	–	nd.sr_vpsa [1] = sqrt(nd.sr_vpsa [1]);
1503	–
1504	–	/* Orient perturbed normal towards incident side */
1505	–	if (!hitFront) {
1506	–	nd.pnorm [0] = -nd.pnorm [0];
1507	–	nd.pnorm [1] = -nd.pnorm [1];
1508	–	nd.pnorm [2] = -nd.pnorm [2];
1509	–	}
1510	–
1511	–	/* Following code adapted from SDsampBSDF() */
1512	–	{
1513	–	SDSpectralDF   *rdf, *tdf;
1514	–	SDValue        bsdfVal;
1515	–	double         xi, rhoDiff = 0;
1516	–	float          coef [SDmaxCh];
1517	–	int            i, j, n, nr;
1518	–	SDComponent       *sdc;
1519	–	const SDCDst   **cdarr = NULL;
1520	–
1521	–	/* Get diffuse albedo (?) */
1522	–	if (hitFront) {
1523	–	bsdfVal = nd.sd -> rLambFront;
1524	–	rdf = nd.sd -> rf;
1525	–	tdf = nd.sd -> tf ? nd.sd -> tf : nd.sd -> tb;
1526	–	}
1527	–	else {
1528	–	bsdfVal = nd.sd -> rLambBack;
1529	–	rdf = nd.sd -> rb;
1530	–	tdf = nd.sd -> tb ? nd.sd -> tb : nd.sd -> tf;
1531	–	}
1532	–
1533	–	rhoDiff = bsdfVal.cieY;
1534	–	bsdfVal.cieY += nd.sd -> tLamb.cieY;
1535	–
1536	–	/* Allocate non-diffuse sampling */
1537	–	i = nr = rdf ? rdf -> ncomp : 0;
1538	–	j = tdf ? tdf -> ncomp : 0;
1539	–	n = i + j;
1540	–
1541	–	if (n > 0 && !(cdarr = (const SDCDst**)malloc(n * sizeof(SDCDst*))))
1542	–	objerror(mat, USER, transSDError(SDEmemory));
1543	–
1544	–	while (j-- > 0) {
1545	–	/* Sum up non-diffuse transmittance */
1546	–	cdarr [i + j] = (*tdf -> comp [j].func -> getCDist)(nd.vray, &tdf -> comp [j]);
1547	–
1548	–	if (!cdarr [i + j])
1549	–	cdarr [i + j] = &SDemptyCD;
1550	–	else bsdfVal.cieY += cdarr [i + j] -> cTotal;
1551	–	}
1552	–
1553	–	while (i-- > 0) {
1554	–	/* Sum up non-diffuse reflectance */
1555	–	cdarr [i] = (*rdf -> comp [i].func -> getCDist)(nd.vray, &rdf -> comp [i]);
1556	–
1557	–	if (!cdarr [i])
1558	–	cdarr [i] = &SDemptyCD;
1559	–	else bsdfVal.cieY += cdarr [i] -> cTotal;
1560	–	}
1561	–
1562	–	if (bsdfVal.cieY <= FTINY) {
1563	–	/* Don't bother sampling, just absorb photon */
1564	–	if (cdarr)
1565	–	free(cdarr);
1566	–	return 0;
1567	–	}
1568	–
1569	–	/* Insert direct and indirect photon hits if diffuse component */
1570	–	if (rhoDiff > FTINY || nd.sd -> tLamb.cieY > FTINY)
1571	–	addPhotons(rayIn);
1572	–
1573	–	xi = pmapRandom(rouletteState);
1574	–
1575	–	if ((xi -= rhoDiff) <= 0) {
1576	–	/* Diffuse reflection */
1577	–	photonRay(rayIn, &rayOut, PMAP_DIFFREFL, nd.rdiff);
1578	–	diffPhotonScatter(nd.pnorm, &rayOut);
1579	–	}
1580	–	else if ((xi -= nd.sd -> tLamb.cieY) <= 0) {
1581	–	/* Diffuse transmission */
1582	–	flipsurface(rayIn);
1583	–	photonRay(rayIn, &rayOut, PMAP_DIFFTRANS, nd.tdiff);
1584	–	bsdfVal.spec = nd.sd -> tLamb.spec;
1585	–	diffPhotonScatter(nd.pnorm, &rayOut);
1586	–	}
1587	–	else {
1588	–	int rayOutType;
1589	–	COLOR bsdfRGB;
1590	–
1591	–	/* Non-diffuse CDF inversion (?) */
1592	–	for (i = 0; i < n && (xi -= cdarr [i] -> cTotal) > 0; i++);
1593	–
1594	–	if (i >= n) {
1595	–	/* Absorbed -- photon went Deer Hunter */
1596	–	if (cdarr)
1597	–	free(cdarr);
1598	–	return 0;
1599	–	}
1600	–
1601	–	if (i < nr) {
1602	–	/* Non-diffuse reflection */
1603	–	sdc = &rdf -> comp [i];
1604	–	rayOutType = PMAP_SPECREFL;
1605	–	}
1606	–	else {
1607	–	/* Non-diffuse transmission */
1608	–	sdc = &tdf -> comp [i - nr];
1609	–	rayOutType = PMAP_SPECTRANS;
1610	–	}
1611	–
1612	–	/* Generate non-diff sample dir */
1613	–	VCOPY(rayOut.rdir, nd.vray);
1614	–	err = (*sdc -> func -> sampCDist)
1615	–	(rayOut.rdir, pmapRandom(scatterState), cdarr [i]);
1616	–	if (err)
1617	–	objerror(mat, USER, transSDError(SDEinternal));
1618	–
1619	–	/* Get colour */
1620	–	j = (*sdc -> func -> getBSDFs)(coef, rayOut.rdir, nd.vray, sdc);
1621	–
1622	–	if (j <= 0) {
1623	–	sprintf(SDerrorDetail, "BSDF \"%s\" sampling value error",
1624	–	nd.sd -> name);
1625	–	objerror(mat, USER, transSDError(SDEinternal));
1626	–	}
1627	–
1628	–	bsdfVal.spec = sdc -> cspec [0];
1629	–	rhoDiff = coef [0];
1630	–
1631	–	while (--j) {
1632	–	c_cmix(&bsdfVal.spec, rhoDiff, &bsdfVal.spec, coef [j],
1633	–	&sdc -> cspec [j]);
1634	–	rhoDiff += coef [j];
1635	–	}
1636	–
1637	–	/* ? */
1638	–	c_ccvt(&bsdfVal.spec, C_CSXY + C_CSSPEC);
1639	–	ccy2rgb(&bsdfVal.spec, bsdfVal.cieY, bsdfRGB);
1640	–
1641	–	/* Xform outgoing dir to world coords */
1642	–	if ((err = SDmapDir(rayOut.rdir, nd.fromloc, rayOut.rdir))) {
1643	–	objerror(mat, USER, transSDError(err));
1644	–	return 0;
1645	–	}
1646	–
1647	–	photonRay(rayIn, &rayOut, rayOutType, bsdfRGB);
1648	–	}
1649	–
1650	–	if (cdarr)
1651	–	free(cdarr);
1652	–	}
1653	–
1654	–	/* Clean up BSDF */
1655	–	SDfreeCache(nd.sd);
1656	–
1657	–	tracePhoton(&rayOut);
1658	–	return 0;
1659	–	}
1660	–	#else
1661	–
1388		static int bsdfPhotonScatter (OBJREC *mat, RAY *rayIn)
1389		/* Generate new photon ray for BSDF modifier and recurse. */
1390		{
#	Line 1670 | Line 1396 | static int bsdfPhotonScatter (OBJREC *mat, RAY *rayIn)
1396		BSDFDAT      nd;
1397		RAY      rayOut;
1398		COLOR    bsdfRGB;
1399	+	int      transmitted;
1400		double   prDiff, ptDiff, prDiffSD, ptDiffSD, prSpecSD, ptSpecSD,
1401	<	albedo, xi, xi2;
1402	<	const double patAlb = colorAvg(rayIn -> pcol);
1401	>	albedo, xi;
1402	>	const double patAlb = bright(rayIn -> pcol);
1403
1404		/* Following code adapted from m_bsdf() */
1405		/* Check arguments */
#	Line 1689 | Line 1416 | static int bsdfPhotonScatter (OBJREC *mat, RAY *rayIn)
1416		nd.thick = evalue(mf -> ep [0]);
1417		if ((-FTINY <= nd.thick) & (nd.thick <= FTINY))
1418		nd.thick = .0;
1692	–
1693	–	if (nd.thick != .0 || (!hitFront && !backvis)) {
1694	–	/* Proxy geometry present, so use it instead and transfer ray */
1695	–	photonRay(rayIn, &rayOut, PMAP_XFER, NULL);
1696	–	tracePhoton(&rayOut);
1697	–
1698	–	return 0;
1699	–	}
1419
1420		/* Get BSDF data */
1421		nd.sd = loadBSDF(mat -> oargs.sarg [1]);
#	Line 1810 | Line 1529 | static int bsdfPhotonScatter (OBJREC *mat, RAY *rayIn)
1529		if (prDiff + ptDiff + prDiffSD + ptDiffSD > FTINY)
1530		addPhotons(rayIn);
1531
1532	<	xi = xi2 = pmapRandom(rouletteState);
1532	>	xi = pmapRandom(rouletteState);
1533
1534		if (xi > albedo)
1535		/* Absorbtion */
1536		return 0;
1537
1538	+	transmitted = 0;
1539	+
1540		if ((xi -= prDiff) <= 0) {
1541		/* Diffuse reflection (extra component in material def) */
1542		photonRay(rayIn, &rayOut, PMAP_DIFFREFL, nd.rdiff);
#	Line 1825 | Line 1546 | static int bsdfPhotonScatter (OBJREC *mat, RAY *rayIn)
1546		else if ((xi -= ptDiff) <= 0) {
1547		/* Diffuse transmission (extra component in material def) */
1548		flipsurface(rayIn);
1549	+	nd.thick = -nd.thick;
1550		photonRay(rayIn, &rayOut, PMAP_DIFFTRANS, nd.tdiff);
1551	<	diffPhotonScatter(nd.pnorm, &rayOut);
1551	>	diffPhotonScatter(nd.pnorm, &rayOut);
1552	>	transmitted = 1;
1553		}
1554	<
1554	>
1555		else {   /* Sample SDF */
1556		if ((xi -= prDiffSD) <= 0) {
1557		/* Diffuse SDF reflection (constant component) */
1558	<	if ((err = SDsampBSDF(&bsdfVal, nd.vray, xi2,
1558	>	if ((err = SDsampBSDF(&bsdfVal, nd.vray, pmapRandom(scatterState),
1559		SDsampDf | SDsampR, nd.sd)))
1560		objerror(mat, USER, transSDError(err));
1561
#	Line 1844 | Line 1567 | static int bsdfPhotonScatter (OBJREC *mat, RAY *rayIn)
1567
1568		else if ((xi -= ptDiffSD) <= 0) {
1569		/* Diffuse SDF transmission (constant component) */
1570	<	if ((err = SDsampBSDF(&bsdfVal, nd.vray, xi2,
1570	>	if ((err = SDsampBSDF(&bsdfVal, nd.vray, pmapRandom(scatterState),
1571		SDsampDf | SDsampT, nd.sd)))
1572		objerror(mat, USER, transSDError(err));
1573
#	Line 1853 | Line 1576 | static int bsdfPhotonScatter (OBJREC *mat, RAY *rayIn)
1576		multcolor(bsdfRGB, rayIn -> pcol);
1577		addcolor(bsdfRGB, nd.tdiff);
1578		flipsurface(rayIn);  /* Necessary? */
1579	+	nd.thick = -nd.thick;
1580		photonRay(rayIn, &rayOut, PMAP_DIFFTRANS, bsdfRGB);
1581	+	transmitted = 1;
1582		}
1583
1584		else if ((xi -= prSpecSD) <= 0) {
1585		/* Non-diffuse ("specular") SDF reflection */
1586	<	if ((err = SDsampBSDF(&bsdfVal, nd.vray, xi2,
1586	>	if ((err = SDsampBSDF(&bsdfVal, nd.vray, pmapRandom(scatterState),
1587		SDsampSp | SDsampR, nd.sd)))
1588		objerror(mat, USER, transSDError(err));
1589
#	Line 1868 | Line 1593 | static int bsdfPhotonScatter (OBJREC *mat, RAY *rayIn)
1593
1594		else {
1595		/* Non-diffuse ("specular") SDF transmission */
1596	<	if ((err = SDsampBSDF(&bsdfVal, nd.vray, xi2,
1596	>	if ((err = SDsampBSDF(&bsdfVal, nd.vray, pmapRandom(scatterState),
1597		SDsampSp | SDsampT, nd.sd)))
1598		objerror(mat, USER, transSDError(err));
1599
#	Line 1876 | Line 1601 | static int bsdfPhotonScatter (OBJREC *mat, RAY *rayIn)
1601		ccy2rgb(&bsdfVal.spec, bsdfVal.cieY, bsdfRGB);
1602		multcolor(bsdfRGB, rayIn -> pcol);
1603		flipsurface(rayIn);  /* Necessary? */
1604	+	nd.thick = -nd.thick;
1605		photonRay(rayIn, &rayOut, PMAP_SPECTRANS, bsdfRGB);
1606	+	transmitted = 1;
1607		}
1608
1609		/* Xform outgoing dir to world coords */
#	Line 1889 | Line 1616 | static int bsdfPhotonScatter (OBJREC *mat, RAY *rayIn)
1616		/* Clean up */
1617		SDfreeCache(nd.sd);
1618
1619	+	/* Need to offset ray origin to get past detail geometry? */
1620	+	if (transmitted && nd.thick != 0)
1621	+	VSUM(rayOut.rorg, rayOut.rorg, rayIn -> ron, -nd.thick);
1622	+
1623		tracePhoton(&rayOut);
1624		return 0;
1625		}
1895	–	#endif
1626
1627
1628

Diff Legend

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