/**
* Integrate down the centre of this unknown
* This will not take into account changes
* in the jacobian across the extent of the basis
* function
*/
static
typename UnknownT::NumberT
integrate(
const UnknownT& unknown,
const CoordinatesInterface<DIM,
typename UnknownT::NumberT>& geom,
const int direction)
{
GaussLegendre<UnknownT::ORDER, NumberT> quad;
ValueT integral(0.0);
for (auto interval1D :
unknown.linearIntervals1D(direction)) {
NumberT intervalMin = interval1D.minimum(0);
NumberT intervalMax = interval1D.maximum(0);
auto nodes = quad.nodes(intervalMin, intervalMax);
auto weights = quad.weights(intervalMin, intervalMax);
auto location = unknown.centres();
for (std::size_t j = 0; j < nodes.size(); ++j) {
location[direction] = nodes[j];
integral += weights[j] *
unknown.value(direction, nodes[j]) *
geom.jacobian(direction, nodes[j]);
}
}
return integral;
}
static
std::array<std::array<T, ORDER+1>, DIM>
weights(const GaussLegendre<ORDER, T>& quad,
const Vector<DIM, T>& mins,
const Vector<DIM, T>& maxs)
{
std::array<std::array<T, ORDER+1>, DIM> allWeights;
for (uint i = 0; i < DIM; ++i) {
assert(maxs[i] > mins[i]);
allWeights[i] = quad.weights(mins[i], maxs[i]);
}
return allWeights;
}
static
typename std::array<typename GaussLegendre<ORDER, T>::NodesAndWeights, DIM>
nodesWeightsPairs(
const Vector<DIM, T>& mins,
const Vector<DIM, T>& maxs
)
{
GaussLegendre<ORDER, T> quad;
std::array<GaussLegendre<ORDER, T>, DIM> allNodesAndWeights;
for (int i = 0; i < DIM; ++i) {
assert(maxs[i] > mins[i]);
allNodesAndWeights[i] = quad.weights(mins[i], maxs[i]);
}
return allNodesAndWeights;
}
void HairBcsdf::precomputeAzimuthalDistributions()
{
const int Resolution = PrecomputedAzimuthalLobe::AzimuthalResolution;
std::unique_ptr<Vec3f[]> valuesR (new Vec3f[Resolution*Resolution]);
std::unique_ptr<Vec3f[]> valuesTT (new Vec3f[Resolution*Resolution]);
std::unique_ptr<Vec3f[]> valuesTRT(new Vec3f[Resolution*Resolution]);
// Ideally we could simply make this a constexpr, but MSVC does not support that yet (boo!)
#define NumPoints 140
GaussLegendre<NumPoints> integrator;
const auto points = integrator.points();
const auto weights = integrator.weights();
// Cache the gammaI across all integration points
std::array<float, NumPoints> gammaIs;
for (int i = 0; i < NumPoints; ++i)
gammaIs[i] = std::asin(points[i]);
// Precompute the Gaussian detector and sample it into three 1D tables.
// This is the only part of the precomputation that is actually approximate.
// 2048 samples are enough to support the lowest roughness that the BCSDF
// can reliably simulate
const int NumGaussianSamples = 2048;
std::unique_ptr<float[]> Ds[3];
for (int p = 0; p < 3; ++p) {
Ds[p].reset(new float[NumGaussianSamples]);
for (int i = 0; i < NumGaussianSamples; ++i)
Ds[p][i] = D(_betaR, i/(NumGaussianSamples - 1.0f)*TWO_PI);
}
// Simple wrapped linear interpolation of the precomputed table
auto approxD = [&](int p, float phi) {
float u = std::abs(phi*(INV_TWO_PI*(NumGaussianSamples - 1)));
int x0 = int(u);
int x1 = x0 + 1;
u -= x0;
return Ds[p][x0 % NumGaussianSamples]*(1.0f - u) + Ds[p][x1 % NumGaussianSamples]*u;
};
// Here follows the actual precomputation of the azimuthal scattering functions
// The scattering functions are parametrized with the azimuthal angle phi,
// and the cosine of the half angle, cos(thetaD).
// This parametrization makes the azimuthal function relatively smooth and allows using
// really low resolutions for the table (64x64 in this case) without any visual
// deviation from ground truth, even at the lowest supported roughness setting
for (int y = 0; y < Resolution; ++y) {
float cosHalfAngle = y/(Resolution - 1.0f);
// Precompute reflection Fresnel factor and reduced absorption coefficient
float iorPrime = std::sqrt(Eta*Eta - (1.0f - cosHalfAngle*cosHalfAngle))/cosHalfAngle;
float cosThetaT = std::sqrt(1.0f - (1.0f - cosHalfAngle*cosHalfAngle)*sqr(1.0f/Eta));
Vec3f sigmaAPrime = _sigmaA/cosThetaT;
// Precompute gammaT, f_t and internal absorption across all integration points
std::array<float, NumPoints> fresnelTerms, gammaTs;
std::array<Vec3f, NumPoints> absorptions;
for (int i = 0; i < NumPoints; ++i) {
gammaTs[i] = std::asin(clamp(points[i]/iorPrime, -1.0f, 1.0f));
fresnelTerms[i] = Fresnel::dielectricReflectance(1.0f/Eta, cosHalfAngle*std::cos(gammaIs[i]));
absorptions[i] = std::exp(-sigmaAPrime*2.0f*std::cos(gammaTs[i]));
}
for (int phiI = 0; phiI < Resolution; ++phiI) {
float phi = TWO_PI*phiI/(Resolution - 1.0f);
float integralR = 0.0f;
Vec3f integralTT(0.0f);
Vec3f integralTRT(0.0f);
// Here follows the integration across the fiber width, h.
// Since we were able to precompute most of the factors that
// are constant w.r.t phi for a given h,
// we don't have to do much work here.
for (int i = 0; i < integrator.numSamples(); ++i) {
float fR = fresnelTerms[i];
Vec3f T = absorptions[i];
float AR = fR;
Vec3f ATT = (1.0f - fR)*(1.0f - fR)*T;
Vec3f ATRT = ATT*fR*T;
integralR += weights[i]*approxD(0, phi - Phi(gammaIs[i], gammaTs[i], 0))*AR;
integralTT += weights[i]*approxD(1, phi - Phi(gammaIs[i], gammaTs[i], 1))*ATT;
integralTRT += weights[i]*approxD(2, phi - Phi(gammaIs[i], gammaTs[i], 2))*ATRT;
}
valuesR [phiI + y*Resolution] = Vec3f(0.5f*integralR);
valuesTT [phiI + y*Resolution] = 0.5f*integralTT;
valuesTRT[phiI + y*Resolution] = 0.5f*integralTRT;
}
}
// Hand the values off to the helper class to construct sampling CDFs and so forth
_nR .reset(new PrecomputedAzimuthalLobe(std::move(valuesR)));
_nTT .reset(new PrecomputedAzimuthalLobe(std::move(valuesTT)));
_nTRT.reset(new PrecomputedAzimuthalLobe(std::move(valuesTRT)));
}