Update from book source. No functional changes.

src/pbrt/cpu/render.cpp

@@ -45,22 +45,13 @@ void RenderCPU(BasicScene &parsedScene) {
     Filter filter = parsedScene.CreateFilter();
 
     // Film
-    // It's a little ugly to poke into the camera's parameters here, but we
-    // have this circular dependency that Camera::Create() expects a
-    // Film, yet now the film needs to know the exposure time from
-    // the camera....
-    Float exposureTime = parsedScene.camera.parameters.GetOneFloat("shutterclose", 1.f) -
-                         parsedScene.camera.parameters.GetOneFloat("shutteropen", 0.f);
-    if (exposureTime <= 0)
-        ErrorExit(&parsedScene.camera.loc,
-                  "The specified camera shutter times imply that the shutter "
-                  "does not open.  A black image will result.");
-    Film film = parsedScene.CreateFilm(exposureTime, filter);
+    Film film = parsedScene.CreateFilm(filter);
 
     // Camera
     Medium cameraMedium = findMedium(parsedScene.camera.medium, &parsedScene.camera.loc);
     Camera camera = parsedScene.CreateCamera(cameraMedium, film);
 
+    // Sampler
     Point2i fullImageResolution = camera.GetFilm().FullResolution();
     Sampler sampler = parsedScene.CreateSampler(fullImageResolution);
 

src/pbrt/paramdict.cpp

@@ -191,12 +191,12 @@ typename ParameterTypeTraits<PT>::ReturnType ParameterDictionary::lookupSingle(
         // Extract parameter values from _p_
         const auto &values = traits::GetValues(*p);
 
-        // Issue error if incorrect number of parameter values were provided
+        // Issue error if an incorrect number of parameter values were provided
         if (values.empty())
             ErrorExit(&p->loc, "No values provided for parameter \"%s\".", name);
         if (values.size() > traits::nPerItem)
-            ErrorExit(&p->loc, "More than one value provided for parameter \"%s\".",
-                      name);
+            ErrorExit(&p->loc, "Expected %d values for parameter \"%s\".",
+                      traits::nPerItem, name);
 
         // Return parameter values as _ReturnType_
         p->lookedUp = true;

src/pbrt/samplers.cpp

@@ -434,10 +434,10 @@ Sampler Sampler::Create(const std::string &name, const ParameterDictionary &para
         sampler = StratifiedSampler::Create(parameters, loc, alloc);
     else
         ErrorExit(loc, "%s: sampler type unknown.", name);
-
     if (!sampler)
         ErrorExit(loc, "%s: unable to create sampler.", name);
     parameters.ReportUnused();
+
     return sampler;
 }
 

src/pbrt/scene.cpp

@@ -75,12 +75,6 @@ BasicSceneBuilder::GraphicsState::GraphicsState() {
         return;                                                    \
     } else /* swallow trailing semicolon */
 
-#define FOR_ACTIVE_TRANSFORMS(expr)                         \
-    for (int i = 0; i < MaxTransforms; ++i)                 \
-        if (graphicsState.activeTransformBits & (1 << i)) { \
-            expr                                            \
-        }
-
 STAT_COUNTER("Scene/Object instances created", nObjectInstancesCreated);
 STAT_COUNTER("Scene/Object instances used", nObjectInstancesUsed);
 
@@ -120,12 +114,12 @@ void BasicSceneBuilder::ColorSpace(const std::string &name, FileLoc loc) {
 }
 
 void BasicSceneBuilder::Identity(FileLoc loc) {
-    FOR_ACTIVE_TRANSFORMS(graphicsState.ctm[i] = pbrt::Transform();)
+    graphicsState.ForActiveTransforms([](auto t) { return pbrt::Transform(); });
 }
 
 void BasicSceneBuilder::Translate(Float dx, Float dy, Float dz, FileLoc loc) {
-    FOR_ACTIVE_TRANSFORMS(graphicsState.ctm[i] = graphicsState.ctm[i] *
-                                                 pbrt::Translate(Vector3f(dx, dy, dz));)
+    graphicsState.ForActiveTransforms(
+        [=](auto t) { return t * pbrt::Translate(Vector3f(dx, dy, dz)); });
 }
 
 void BasicSceneBuilder::CoordinateSystem(const std::string &name, FileLoc loc) {
@@ -253,8 +247,7 @@ void BasicSceneBuilder::MakeNamedMedium(const std::string &name,
     }
     mediumNames.insert(name);
 
-    scene->AddMedium(
-        TransformedSceneEntity(name, std::move(dict), loc, RenderFromObject()));
+    scene->AddMedium(MediumSceneEntity(name, std::move(dict), loc, RenderFromObject()));
 }
 
 void BasicSceneBuilder::LightSource(const std::string &name, ParsedParameterVector params,
@@ -540,33 +533,32 @@ void BasicSceneBuilder::Option(const std::string &name, const std::string &value
 }
 
 void BasicSceneBuilder::Transform(Float tr[16], FileLoc loc) {
-    FOR_ACTIVE_TRANSFORMS(graphicsState.ctm[i] = Transpose(
-                              pbrt::Transform(SquareMatrix<4>(pstd::MakeSpan(tr, 16))));)
+    graphicsState.ForActiveTransforms([=](auto t) {
+        return Transpose(pbrt::Transform(SquareMatrix<4>(pstd::MakeSpan(tr, 16))));
+    });
 }
 
 void BasicSceneBuilder::ConcatTransform(Float tr[16], FileLoc loc) {
-    FOR_ACTIVE_TRANSFORMS(
-        graphicsState.ctm[i] =
-            graphicsState.ctm[i] *
-            Transpose(pbrt::Transform(SquareMatrix<4>(pstd::MakeSpan(tr, 16))));)
+    graphicsState.ForActiveTransforms([=](auto t) {
+        return t * Transpose(pbrt::Transform(SquareMatrix<4>(pstd::MakeSpan(tr, 16))));
+    });
 }
 
 void BasicSceneBuilder::Rotate(Float angle, Float dx, Float dy, Float dz, FileLoc loc) {
-    FOR_ACTIVE_TRANSFORMS(graphicsState.ctm[i] =
-                              graphicsState.ctm[i] *
-                              pbrt::Rotate(angle, Vector3f(dx, dy, dz));)
+    graphicsState.ForActiveTransforms(
+        [=](auto t) { return t * pbrt::Rotate(angle, Vector3f(dx, dy, dz)); });
 }
 
 void BasicSceneBuilder::Scale(Float sx, Float sy, Float sz, FileLoc loc) {
-    FOR_ACTIVE_TRANSFORMS(graphicsState.ctm[i] =
-                              graphicsState.ctm[i] * pbrt::Scale(sx, sy, sz);)
+    graphicsState.ForActiveTransforms(
+        [=](auto t) { return t * pbrt::Scale(sx, sy, sz); });
 }
 
 void BasicSceneBuilder::LookAt(Float ex, Float ey, Float ez, Float lx, Float ly, Float lz,
                                Float ux, Float uy, Float uz, FileLoc loc) {
     class Transform lookAt =
         pbrt::LookAt(Point3f(ex, ey, ez), Point3f(lx, ly, lz), Vector3f(ux, uy, uz));
-    FOR_ACTIVE_TRANSFORMS(graphicsState.ctm[i] = graphicsState.ctm[i] * lookAt;);
+    graphicsState.ForActiveTransforms([=](auto t) { return t * lookAt; });
 }
 
 void BasicSceneBuilder::ActiveTransformAll(FileLoc loc) {
@@ -700,14 +692,18 @@ void BasicScene::SetSampler(SceneEntity sampler) {
     this->sampler = std::move(sampler);
 }
 
-void BasicScene::AddMedium(TransformedSceneEntity medium) {
-    std::lock_guard<std::mutex> lock(mediaMutex);
+Sampler BasicScene::CreateSampler(Point2i res) const {
+    Allocator alloc = threadAllocators.Get();
+    return Sampler::Create(sampler.name, sampler.parameters, res, &sampler.loc, alloc);
+}
+
+void BasicScene::AddMedium(MediumSceneEntity medium) {
     // Define _create_ lambda function for _Medium_ creation
     auto create = [=]() {
         std::string type = medium.parameters.GetOneString("type", "");
         // Check for missing medium ``type'' or animated medium transform
         if (type.empty())
-            ErrorExit(&medium.loc, "No parameter string \"type\" found for medium.");
+            ErrorExit(&medium.loc, "No parameter \"string type\" found for medium.");
         if (medium.renderFromObject.IsAnimated())
             Warning(&medium.loc, "Animated transformation provided for medium. Only the "
                                  "start transform will be used.");
@@ -717,6 +713,7 @@ void BasicScene::AddMedium(TransformedSceneEntity medium) {
                               threadAllocators.Get());
     };
 
+    std::lock_guard<std::mutex> lock(mediaMutex);
     mediaFutures[medium.name] = RunAsync(create);
 }
 
@@ -734,18 +731,25 @@ std::map<std::string, Medium> BasicScene::CreateMedia() {
     return mediaMap;
 }
 
-Sampler BasicScene::CreateSampler(Point2i res) const {
-    Allocator alloc = threadAllocators.Get();
-    return Sampler::Create(sampler.name, sampler.parameters, res, &sampler.loc, alloc);
-}
-
 Filter BasicScene::CreateFilter() const {
     Allocator alloc = threadAllocators.Get();
     return Filter::Create(filter.name, filter.parameters, &filter.loc, alloc);
 }
 
-Film BasicScene::CreateFilm(Float exposureTime, Filter filter) const {
+Film BasicScene::CreateFilm(Filter filter) const {
     Allocator alloc = threadAllocators.Get();
+
+    // It's a little ugly to poke into the camera's parameters here, but we
+    // have this circular dependency that Camera::Create() expects a
+    // Film, yet now the film needs to know the exposure time from
+    // the camera....
+    Float exposureTime = camera.parameters.GetOneFloat("shutterclose", 1.f) -
+                         camera.parameters.GetOneFloat("shutteropen", 0.f);
+    if (exposureTime <= 0)
+        ErrorExit(&camera.loc,
+                  "The specified camera shutter times imply that the shutter "
+                  "does not open.  A black image will result.");
+
     return Film::Create(film.name, film.parameters, exposureTime, camera.cameraTransform,
                         filter, &film.loc, alloc);
 }

src/pbrt/scene.h

@@ -173,6 +173,7 @@ struct InstanceDefinitionSceneEntity {
     std::vector<AnimatedShapeSceneEntity> animatedShapes;
 };
 
+using MediumSceneEntity = TransformedSceneEntity;
 using TextureSceneEntity = TransformedSceneEntity;
 
 struct LightSceneEntity : public TransformedSceneEntity {
@@ -274,7 +275,7 @@ class BasicScene {
 
     void AddNamedMaterial(std::string name, SceneEntity material);
     int AddMaterial(SceneEntity material);
-    void AddMedium(TransformedSceneEntity medium);
+    void AddMedium(MediumSceneEntity medium);
     void AddFloatTexture(std::string name, TextureSceneEntity texture);
     void AddSpectrumTexture(std::string name, TextureSceneEntity texture);
     void AddLight(LightSceneEntity light);
@@ -286,6 +287,8 @@ class BasicScene {
 
     void Done();
 
+    Sampler CreateSampler(Point2i res) const;
+
     void CreateMaterials(const NamedTextures &sceneTextures,
                          std::map<std::string, Material> *namedMaterials,
                          std::vector<Material> *materials);
@@ -303,10 +306,8 @@ class BasicScene {
         const std::map<std::string, Material> &namedMaterials,
         const std::vector<Material> &materials);
 
-    Sampler CreateSampler(Point2i res) const;
-
     Filter CreateFilter() const;
-    Film CreateFilm(Float exposureTime, Filter filter) const;
+    Film CreateFilm(Filter filter) const;
     Camera CreateCamera(Medium cameraMedium, Film film) const;
     std::unique_ptr<Integrator> CreateIntegrator(Camera camera, Sampler sampler,
                                                  Primitive accel,
@@ -315,7 +316,8 @@ class BasicScene {
     NamedTextures CreateTextures();
 
     // BasicScene Public Members
-    SceneEntity film, sampler, integrator, filter, accelerator;
+    SceneEntity sampler;
+    SceneEntity film, integrator, filter, accelerator;
     CameraSceneEntity camera;
     std::vector<std::pair<std::string, SceneEntity>> namedMaterials;
     std::vector<SceneEntity> materials;
@@ -420,6 +422,13 @@ class BasicSceneBuilder : public ParserTarget {
         // GraphicsState Public Methods
         GraphicsState();
 
+        template <typename F>
+        void ForActiveTransforms(F func) {
+            for (int i = 0; i < MaxTransforms; ++i)
+                if (activeTransformBits & (1 << i))
+                    ctm[i] = func(ctm[i]);
+        }
+
         // GraphicsState Public Members
         std::string currentInsideMedium, currentOutsideMedium;
 
@@ -457,9 +466,9 @@ class BasicSceneBuilder : public ParserTarget {
 
     // BasicSceneBuilder Private Members
     BasicScene *scene;
-    GraphicsState graphicsState;
     enum class BlockState { OptionsBlock, WorldBlock };
     BlockState currentBlock = BlockState::OptionsBlock;
+    GraphicsState graphicsState;
     static constexpr int StartTransformBits = 1 << 0;
     static constexpr int EndTransformBits = 1 << 1;
     static constexpr int AllTransformsBits = (1 << MaxTransforms) - 1;

src/pbrt/util/lowdiscrepancy.cpp

@@ -5,7 +5,6 @@
 #include <pbrt/util/lowdiscrepancy.h>
 
 #include <pbrt/util/math.h>
-#include <pbrt/util/parallel.h>
 #include <pbrt/util/primes.h>
 #include <pbrt/util/print.h>
 #include <pbrt/util/stats.h>

src/pbrt/wavefront/integrator.cpp

@@ -122,14 +122,7 @@ WavefrontPathIntegrator::WavefrontPathIntegrator(
 
     filter = scene.CreateFilter();
 
-    Float exposureTime = scene.camera.parameters.GetOneFloat("shutterclose", 1.f) -
-                         scene.camera.parameters.GetOneFloat("shutteropen", 0.f);
-    if (exposureTime <= 0)
-        ErrorExit(&scene.camera.loc,
-                  "The specified camera shutter times imply that the shutter "
-                  "does not open.  A black image will result.");
-
-    film = scene.CreateFilm(exposureTime, filter);
+    film = scene.CreateFilm(filter);
     initializeVisibleSurface = film.UsesVisibleSurface();
 
     sampler = scene.CreateSampler(film.FullResolution());