std::shared_ptr<Medium> MakeMedium(const std::string &name,
const ParamSet ¶mSet,
const Transform &medium2world) {
Float sig_a_rgb[3] = {.0011f, .0024f, .014f},
sig_s_rgb[3] = {2.55f, 3.21f, 3.77f};
Spectrum sig_a = Spectrum::FromRGB(sig_a_rgb),
sig_s = Spectrum::FromRGB(sig_s_rgb);
std::string preset = paramSet.FindOneString("preset", "");
bool found = GetMediumScatteringProperties(preset, &sig_a, &sig_s);
if (preset != "" && !found)
Warning("Material preset \"%s\" not found. Using defaults.",
preset.c_str());
Float scale = paramSet.FindOneFloat("scale", 1.f);
Float g = paramSet.FindOneFloat("g", 0.0f);
sig_a = paramSet.FindOneSpectrum("sigma_a", sig_a) * scale;
sig_s = paramSet.FindOneSpectrum("sigma_s", sig_s) * scale;
Medium *m = NULL;
if (name == "homogeneous") {
m = new HomogeneousMedium(sig_a, sig_s, g);
} else if (name == "heterogeneous") {
int nitems;
const Float *data = paramSet.FindFloat("density", &nitems);
if (!data) {
Error("No \"density\" values provided for heterogeneous medium?");
return NULL;
}
int nx = paramSet.FindOneInt("nx", 1);
int ny = paramSet.FindOneInt("ny", 1);
int nz = paramSet.FindOneInt("nz", 1);
Point3f p0 = paramSet.FindOnePoint3f("p0", Point3f(0.f, 0.f, 0.f));
Point3f p1 = paramSet.FindOnePoint3f("p1", Point3f(1.f, 1.f, 1.f));
if (nitems != nx * ny * nz) {
Error(
"GridDensityMedium has %d density values; expected nx*ny*nz = "
"%d",
nitems, nx * ny * nz);
return NULL;
}
Transform data2Medium = Translate(Vector3f(p0)) *
Scale(p1.x - p0.x, p1.y - p0.y, p1.z - p0.z);
m = new GridDensityMedium(sig_a, sig_s, g, nx, ny, nz,
medium2world * data2Medium, data);
} else
Warning("Medium \"%s\" unknown.", name.c_str());
paramSet.ReportUnused();
return std::shared_ptr<Medium>(m);
}
std::shared_ptr<AreaLight> CreateDiffuseAreaLight(
const Transform &light2world, const Medium *medium,
const ParamSet ¶mSet, const std::shared_ptr<Shape> &shape) {
Spectrum L = paramSet.FindOneSpectrum("L", Spectrum(1.0));
Spectrum sc = paramSet.FindOneSpectrum("scale", Spectrum(1.0));
int nSamples = paramSet.FindOneInt("nsamples", 1);
if (PbrtOptions.quickRender) nSamples = std::max(1, nSamples / 4);
return std::make_shared<DiffuseAreaLight>(light2world, medium, L * sc,
nSamples, shape);
}
std::shared_ptr<InfiniteAreaLight> CreateInfiniteLight(
const Transform &light2world, const ParamSet ¶mSet) {
Spectrum L = paramSet.FindOneSpectrum("L", Spectrum(1.0));
Spectrum sc = paramSet.FindOneSpectrum("scale", Spectrum(1.0));
std::string texmap = paramSet.FindOneFilename("mapname", "");
int nSamples = paramSet.FindOneInt("nsamples", 1);
if (PbrtOptions.quickRender) nSamples = std::max(1, nSamples / 4);
return std::make_shared<InfiniteAreaLight>(light2world, L * sc, nSamples,
texmap);
}
std::shared_ptr<BVHAccel> CreateBVHAccelerator(
const std::vector<std::shared_ptr<Primitive>> &prims, const ParamSet &ps) {
std::string splitMethodName = ps.FindOneString("splitmethod", "sah");
BVHAccel::SplitMethod splitMethod;
if (splitMethodName == "sah")
splitMethod = BVHAccel::SplitMethod::SAH;
else if (splitMethodName == "hlbvh")
splitMethod = BVHAccel::SplitMethod::HLBVH;
else if (splitMethodName == "middle")
splitMethod = BVHAccel::SplitMethod::Middle;
else if (splitMethodName == "equal")
splitMethod = BVHAccel::SplitMethod::EqualCounts;
else {
Warning("BVH split method \"%s\" unknown. Using \"sah\".",
splitMethodName.c_str());
splitMethod = BVHAccel::SplitMethod::SAH;
}
int maxPrimsInNode = ps.FindOneInt("maxnodeprims", 4);
return std::make_shared<BVHAccel>(prims, maxPrimsInNode, splitMethod);
}
std::vector<std::shared_ptr<Shape>> CreateNURBS(const Transform *o2w,
const Transform *w2o,
bool reverseOrientation,
const ParamSet ¶ms) {
int nu = params.FindOneInt("nu", -1);
if (nu == -1) {
Error("Must provide number of control points \"nu\" with NURBS shape.");
return std::vector<std::shared_ptr<Shape>>();
}
int uorder = params.FindOneInt("uorder", -1);
if (uorder == -1) {
Error("Must provide u order \"uorder\" with NURBS shape.");
return std::vector<std::shared_ptr<Shape>>();
}
int nuknots, nvknots;
const Float *uknots = params.FindFloat("uknots", &nuknots);
if (uknots == nullptr) {
Error("Must provide u knot vector \"uknots\" with NURBS shape.");
return std::vector<std::shared_ptr<Shape>>();
}
if (nuknots != nu + uorder) {
Error(
"Number of knots in u knot vector %d doesn't match sum of "
"number of u control points %d and u order %d.",
nuknots, nu, uorder);
return std::vector<std::shared_ptr<Shape>>();
}
Float u0 = params.FindOneFloat("u0", uknots[uorder - 1]);
Float u1 = params.FindOneFloat("u1", uknots[nu]);
int nv = params.FindOneInt("nv", -1);
if (nv == -1) {
Error("Must provide number of control points \"nv\" with NURBS shape.");
return std::vector<std::shared_ptr<Shape>>();
}
int vorder = params.FindOneInt("vorder", -1);
if (vorder == -1) {
Error("Must provide v order \"vorder\" with NURBS shape.");
return std::vector<std::shared_ptr<Shape>>();
}
const Float *vknots = params.FindFloat("vknots", &nvknots);
if (vknots == nullptr) {
Error("Must provide v knot vector \"vknots\" with NURBS shape.");
return std::vector<std::shared_ptr<Shape>>();
}
if (nvknots != nv + vorder) {
Error(
"Number of knots in v knot vector %d doesn't match sum of "
"number of v control points %d and v order %d.",
nvknots, nv, vorder);
return std::vector<std::shared_ptr<Shape>>();
}
Float v0 = params.FindOneFloat("v0", vknots[vorder - 1]);
Float v1 = params.FindOneFloat("v1", vknots[nv]);
bool isHomogeneous = false;
int npts;
const Float *P = (const Float *)params.FindPoint3f("P", &npts);
if (!P) {
P = params.FindFloat("Pw", &npts);
if (!P) {
Error(
"Must provide control points via \"P\" or \"Pw\" parameter to "
"NURBS shape.");
return std::vector<std::shared_ptr<Shape>>();
}
if ((npts % 4) != 0) {
Error(
"Number of \"Pw\" control points provided to NURBS shape must "
"be "
"multiple of four");
return std::vector<std::shared_ptr<Shape>>();
}
npts /= 4;
isHomogeneous = true;
}
if (npts != nu * nv) {
Error("NURBS shape was expecting %dx%d=%d control points, was given %d",
nu, nv, nu * nv, npts);
return std::vector<std::shared_ptr<Shape>>();
}
// Compute NURBS dicing rates
int diceu = 30, dicev = 30;
std::unique_ptr<Float[]> ueval(new Float[diceu]);
std::unique_ptr<Float[]> veval(new Float[dicev]);
std::unique_ptr<Point3f[]> evalPs(new Point3f[diceu * dicev]);
std::unique_ptr<Normal3f[]> evalNs(new Normal3f[diceu * dicev]);
int i;
for (i = 0; i < diceu; ++i)
ueval[i] = Lerp((float)i / (float)(diceu - 1), u0, u1);
for (i = 0; i < dicev; ++i)
veval[i] = Lerp((float)i / (float)(dicev - 1), v0, v1);
// Evaluate NURBS over grid of points
memset(evalPs.get(), 0, diceu * dicev * sizeof(Point3f));
memset(evalNs.get(), 0, diceu * dicev * sizeof(Point3f));
std::unique_ptr<Point2f[]> uvs(new Point2f[diceu * dicev]);
// Turn NURBS into triangles
std::unique_ptr<Homogeneous3[]> Pw(new Homogeneous3[nu * nv]);
if (isHomogeneous) {
for (int i = 0; i < nu * nv; ++i) {
Pw[i].x = P[4 * i];
Pw[i].y = P[4 * i + 1];
Pw[i].z = P[4 * i + 2];
Pw[i].w = P[4 * i + 3];
}
} else {
for (int i = 0; i < nu * nv; ++i) {
Pw[i].x = P[3 * i];
Pw[i].y = P[3 * i + 1];
Pw[i].z = P[3 * i + 2];
Pw[i].w = 1.;
}
}
for (int v = 0; v < dicev; ++v) {
for (int u = 0; u < diceu; ++u) {
uvs[(v * diceu + u)].x = ueval[u];
uvs[(v * diceu + u)].y = veval[v];
Vector3f dpdu, dpdv;
Point3f pt = NURBSEvaluateSurface(uorder, uknots, nu, ueval[u],
vorder, vknots, nv, veval[v],
Pw.get(), &dpdu, &dpdv);
evalPs[v * diceu + u].x = pt.x;
evalPs[v * diceu + u].y = pt.y;
evalPs[v * diceu + u].z = pt.z;
evalNs[v * diceu + u] = Normal3f(Normalize(Cross(dpdu, dpdv)));
}
}
// Generate points-polygons mesh
int nTris = 2 * (diceu - 1) * (dicev - 1);
std::unique_ptr<int[]> vertices(new int[3 * nTris]);
int *vertp = vertices.get();
// Compute the vertex offset numbers for the triangles
for (int v = 0; v < dicev - 1; ++v) {
for (int u = 0; u < diceu - 1; ++u) {
#define VN(u, v) ((v)*diceu + (u))
*vertp++ = VN(u, v);
*vertp++ = VN(u + 1, v);
*vertp++ = VN(u + 1, v + 1);
*vertp++ = VN(u, v);
*vertp++ = VN(u + 1, v + 1);
*vertp++ = VN(u, v + 1);
#undef VN
}
}
int nVerts = diceu * dicev;
return CreateTriangleMesh(o2w, w2o, reverseOrientation, nTris,
vertices.get(), nVerts, evalPs.get(), nullptr,
evalNs.get(), uvs.get(), nullptr);
}
DistanceEstimatorParams::DistanceEstimatorParams(const ParamSet ¶ms) {
maxIters = params.FindOneInt("maxiters", 1000);
hitEpsilon = params.FindOneFloat("hitepsilon", 1e-5f);
rayEpsilonMultiplier = params.FindOneFloat("rayepsilonmultiplier", 100.f);
normalEpsilon = params.FindOneFloat("normalepsilon", 1e-6f);
}
