Update from book source.

SceneStateManager -> BasicSceneBuilder
Add various object creation methods to BasicScene
Remove redundant threadAllocators parameter from BasicScene::CreateMaterials()

src/pbrt/cmd/pbrt.cpp

@@ -256,8 +256,8 @@ int main(int argc, char *argv[]) {
     } else {
         // Parse provided scene description files
         BasicScene scene;
-        SceneStateManager manager(&scene);
-        ParseFiles(&manager, filenames);
+        BasicSceneBuilder builder(&scene);
+        ParseFiles(&builder, filenames);
 
         // Render the scene
         if (options.useGPU || options.wavefront)

src/pbrt/cpu/render.cpp

@@ -42,8 +42,7 @@ void RenderCPU(BasicScene &parsedScene) {
     };
 
     // Filter
-    Filter filter = Filter::Create(parsedScene.filter.name, parsedScene.filter.parameters,
-                                   &parsedScene.filter.loc, alloc);
+    Filter filter = parsedScene.CreateFilter();
 
     // Film
     // It's a little ugly to poke into the camera's parameters here, but we
@@ -56,21 +55,14 @@ void RenderCPU(BasicScene &parsedScene) {
         ErrorExit(&parsedScene.camera.loc,
                   "The specified camera shutter times imply that the shutter "
                   "does not open.  A black image will result.");
-    Film film = Film::Create(parsedScene.film.name, parsedScene.film.parameters,
-                             exposureTime, parsedScene.camera.cameraTransform, filter,
-                             &parsedScene.film.loc, alloc);
+    Film film = parsedScene.CreateFilm(exposureTime, filter);
 
     // Camera
     Medium cameraMedium = findMedium(parsedScene.camera.medium, &parsedScene.camera.loc);
-    Camera camera = Camera::Create(parsedScene.camera.name, parsedScene.camera.parameters,
-                                   cameraMedium, parsedScene.camera.cameraTransform, film,
-                                   &parsedScene.camera.loc, alloc);
+    Camera camera = parsedScene.CreateCamera(cameraMedium, film);
 
-    // Create _Sampler_ for rendering
     Point2i fullImageResolution = camera.GetFilm().FullResolution();
-    Sampler sampler =
-        Sampler::Create(parsedScene.sampler.name, parsedScene.sampler.parameters,
-                        fullImageResolution, &parsedScene.sampler.loc, alloc);
+    Sampler sampler = parsedScene.CreateSampler(fullImageResolution);
 
     // Textures
     LOG_VERBOSE("Starting textures");
@@ -85,17 +77,15 @@ void RenderCPU(BasicScene &parsedScene) {
     LOG_VERBOSE("Starting materials");
     std::map<std::string, pbrt::Material> namedMaterials;
     std::vector<pbrt::Material> materials;
-    parsedScene.CreateMaterials(textures, threadAllocators, &namedMaterials, &materials);
+    parsedScene.CreateMaterials(textures, &namedMaterials, &materials);
     LOG_VERBOSE("Finished materials");
 
     Primitive accel = parsedScene.CreateAggregate(textures, shapeIndexToAreaLights, media,
                                                   namedMaterials, materials);
 
     // Integrator
-    const RGBColorSpace *integratorColorSpace = parsedScene.film.parameters.ColorSpace();
-    std::unique_ptr<Integrator> integrator(Integrator::Create(
-        parsedScene.integrator.name, parsedScene.integrator.parameters, camera, sampler,
-        accel, lights, integratorColorSpace, &parsedScene.integrator.loc));
+    std::unique_ptr<Integrator> integrator(
+        parsedScene.CreateIntegrator(camera, sampler, accel, lights));
 
     // Helpful warnings
     for (const auto &sh : parsedScene.shapes)

src/pbrt/paramdict.h

@@ -67,7 +67,7 @@ enum class ParameterType {
 };
 
 // SpectrumType Definition
-enum class SpectrumType { Albedo, Unbounded, Illuminant };
+enum class SpectrumType { Illuminant, Albedo, Unbounded };
 
 inline std::string ToString(SpectrumType t) {
     switch (t) {

src/pbrt/parser.cpp

@@ -603,7 +603,7 @@ void parse(ParserTarget *target, std::unique_ptr<Tokenizer> t) {
 
     static std::atomic<bool> warnedTransformBeginEndDeprecated{false};
 
-    std::vector<std::pair<Future<void>, SceneStateManager *>> imports;
+    std::vector<std::pair<Future<void>, BasicSceneBuilder *>> imports;
 
     LOG_VERBOSE("Started parsing %s",
                 std::string(t->loc.filename.begin(), t->loc.filename.end()));
@@ -659,11 +659,9 @@ void parse(ParserTarget *target, std::unique_ptr<Tokenizer> t) {
 
     // Helper function for pbrt API entrypoints that take a single string
     // parameter and a ParameterVector (e.g. pbrtShape()).
-    // using BasicEntrypoint = void (SceneStateManager::*)(const std::string &,
-    // ParsedParameterVector, FileLoc);
     auto basicParamListEntrypoint =
         [&](void (ParserTarget::*apiFunc)(const std::string &,
-                                                 ParsedParameterVector, FileLoc),
+                                          ParsedParameterVector, FileLoc),
             FileLoc loc) {
             Token t = *nextToken(TokenRequired);
             std::string_view dequoted = dequoteString(t);
@@ -773,34 +771,34 @@ void parse(ParserTarget *target, std::unique_ptr<Tokenizer> t) {
                     Printf("%sImport \"%s\"\n",
                            dynamic_cast<FormattingParserTarget *>(target)->indent(), filename);
                 else {
-                    SceneStateManager *stateManager = dynamic_cast<SceneStateManager *>(target);
-                    CHECK(stateManager);
+                    BasicSceneBuilder *builder = dynamic_cast<BasicSceneBuilder *>(target);
+                    CHECK(builder);
 
-                    if (stateManager->currentBlock != SceneStateManager::BlockState::WorldBlock)
+                    if (builder->currentBlock != BasicSceneBuilder::BlockState::WorldBlock)
                         ErrorExit(&tok->loc, "Import statement only allowed inside world "
                                              "definition block.");
 
                     filename = ResolveFilename(filename);
-                    SceneStateManager *importScene = stateManager->CopyForImport();
+                    BasicSceneBuilder *importBuilder = builder->CopyForImport();
 
                     if (RunningThreads() == 1) {
                         std::unique_ptr<Tokenizer> timport =
                             Tokenizer::CreateFromFile(filename, parseError);
                         if (timport)
-                            parse(importScene, std::move(timport));
-                        stateManager->MergeImported(importScene);
+                            parse(importBuilder, std::move(timport));
+                        builder->MergeImported(importBuilder);
                     } else {
                         auto job = [=](std::string filename) {
                             Timer timer;
                             std::unique_ptr<Tokenizer> timport =
                                 Tokenizer::CreateFromFile(filename, parseError);
                             if (timport)
-                                parse(importScene, std::move(timport));
+                                parse(importBuilder, std::move(timport));
                             LOG_VERBOSE("Elapsed time to parse \"%s\": %.2fs", filename,
                                         timer.ElapsedSeconds());
                         };
                         Future<void> jobFinished = RunAsync(job, filename);
-                        imports.push_back(std::make_pair(std::move(jobFinished), importScene));
+                        imports.push_back(std::make_pair(std::move(jobFinished), importBuilder));
                     }
                 }
             } else if (tok->token == "Identity")
@@ -984,9 +982,9 @@ void parse(ParserTarget *target, std::unique_ptr<Tokenizer> t) {
     for (auto &import : imports) {
         import.first.Wait();
 
-        SceneStateManager *stateManager = dynamic_cast<SceneStateManager *>(target);
-        CHECK(stateManager);
-        stateManager->MergeImported(import.second);
+        BasicSceneBuilder *builder = dynamic_cast<BasicSceneBuilder *>(target);
+        CHECK(builder);
+        builder->MergeImported(import.second);
         // HACK: let import.second leak so that its TransformCache isn't deallocated...
     }
 }

src/pbrt/scene.h

@@ -21,6 +21,7 @@
 
 #include <functional>
 #include <map>
+#include <memory>
 #include <set>
 #include <string>
 #include <unordered_set>
@@ -28,6 +29,8 @@
 
 namespace pbrt {
 
+class Integrator;
+
 // SceneEntity Definition
 struct SceneEntity {
     // SceneEntity Public Methods
@@ -170,21 +173,7 @@ struct InstanceDefinitionSceneEntity {
     std::vector<AnimatedShapeSceneEntity> animatedShapes;
 };
 
-struct TextureSceneEntity : public TransformedSceneEntity {
-    TextureSceneEntity() = default;
-    TextureSceneEntity(const std::string &texName, ParameterDictionary parameters,
-                       FileLoc loc, const AnimatedTransform &renderFromObject)
-        : TransformedSceneEntity("", std::move(parameters), loc, renderFromObject),
-          texName(texName) {}
-
-    std::string ToString() const {
-        return StringPrintf("[ TextureSeneEntity name: %s parameters: %s loc: %s "
-                            "renderFromObject: %s texName: %s ]",
-                            name, parameters, loc, renderFromObject, texName);
-    }
-
-    std::string texName;
-};
+using TextureSceneEntity = TransformedSceneEntity;
 
 struct LightSceneEntity : public TransformedSceneEntity {
     LightSceneEntity() = default;
@@ -272,10 +261,12 @@ struct TransformSet {
 // BasicScene Definition
 class BasicScene {
   public:
+    // BasicScene Public Methods
     BasicScene();
 
-    void SetFilm(SceneEntity film);
     void SetSampler(SceneEntity sampler);
+
+    void SetFilm(SceneEntity film);
     void SetIntegrator(SceneEntity integrator);
     void SetFilter(SceneEntity filter);
     void SetAccelerator(SceneEntity accelerator);
@@ -295,19 +286,16 @@ class BasicScene {
 
     void Done();
 
-    NamedTextures CreateTextures();
-
     void CreateMaterials(const NamedTextures &sceneTextures,
-                         ThreadLocal<Allocator> &threadAllocators,
                          std::map<std::string, Material> *namedMaterials,
                          std::vector<Material> *materials);
 
-    std::map<std::string, Medium> CreateMedia();
-
     std::vector<Light> CreateLights(
         const NamedTextures &textures,
         std::map<int, pstd::vector<Light> *> *shapeIndexToAreaLights);
 
+    std::map<std::string, Medium> CreateMedia();
+
     Primitive CreateAggregate(
         const NamedTextures &textures,
         const std::map<int, pstd::vector<Light> *> &shapeIndexToAreaLights,
@@ -315,12 +303,20 @@ class BasicScene {
         const std::map<std::string, Material> &namedMaterials,
         const std::vector<Material> &materials);
 
-    // Public for now...
-  public:
+    Sampler CreateSampler(Point2i res) const;
+
+    Filter CreateFilter() const;
+    Film CreateFilm(Float exposureTime, Filter filter) const;
+    Camera CreateCamera(Medium cameraMedium, Film film) const;
+    std::unique_ptr<Integrator> CreateIntegrator(Camera camera, Sampler sampler,
+                                                 Primitive accel,
+                                                 std::vector<Light> lights) const;
+
+    NamedTextures CreateTextures();
+
     // BasicScene Public Members
     SceneEntity film, sampler, integrator, filter, accelerator;
     CameraSceneEntity camera;
-
     std::vector<std::pair<std::string, SceneEntity>> namedMaterials;
     std::vector<SceneEntity> materials;
     std::vector<ShapeSceneEntity> shapes;
@@ -329,14 +325,14 @@ class BasicScene {
     std::map<InternedString, InstanceDefinitionSceneEntity *> instanceDefinitions;
 
   private:
+    // BasicScene Private Methods
     void startLoadingNormalMaps(const ParameterDictionary &parameters);
 
-    ThreadLocal<Allocator> threadAllocators;
-
+    // BasicScene Private Members
     std::mutex mediaMutex;
     std::map<std::string, Future<Medium>> mediaFutures;
+    mutable ThreadLocal<Allocator> threadAllocators;
     std::map<std::string, Medium> mediaMap;
-
     std::mutex materialMutex;
     std::map<std::string, Future<Image *>> normalMapFutures;
     std::map<std::string, Image *> normalMaps;
@@ -361,11 +357,11 @@ class BasicScene {
     std::mutex instanceDefinitionMutex, instanceUseMutex;
 };
 
-// SceneStateManager Definition
-class SceneStateManager : public ParserTarget {
+// BasicSceneBuilder Definition
+class BasicSceneBuilder : public ParserTarget {
   public:
-    // SceneStateManager Public Methods
-    SceneStateManager(BasicScene *scene);
+    // BasicSceneBuilder Public Methods
+    BasicSceneBuilder(BasicScene *scene);
     void Option(const std::string &name, const std::string &value, FileLoc loc);
     void Identity(FileLoc loc);
     void Translate(Float dx, Float dy, Float dz, FileLoc loc);
@@ -413,13 +409,13 @@ class SceneStateManager : public ParserTarget {
 
     void EndOfFiles();
 
-    SceneStateManager *CopyForImport();
-    void MergeImported(SceneStateManager *);
+    BasicSceneBuilder *CopyForImport();
+    void MergeImported(BasicSceneBuilder *);
 
     std::string ToString() const;
 
   private:
-    // SceneStateManager::GraphicsState Definition
+    // BasicSceneBuilder::GraphicsState Definition
     struct GraphicsState {
         // GraphicsState Public Methods
         GraphicsState();
@@ -447,7 +443,7 @@ class SceneStateManager : public ParserTarget {
     };
 
     friend void parse(ParserTarget *scene, std::unique_ptr<Tokenizer> t);
-    // SceneStateManager Private Methods
+    // BasicSceneBuilder Private Methods
     class Transform RenderFromObject(int index) const {
         return pbrt::Transform((renderFromWorld * graphicsState.ctm[index]).GetMatrix());
     }
@@ -459,7 +455,7 @@ class SceneStateManager : public ParserTarget {
 
     bool CTMIsAnimated() const { return graphicsState.ctm.IsAnimated(); }
 
-    // SceneStateManager Private Members
+    // BasicSceneBuilder Private Members
     BasicScene *scene;
     GraphicsState graphicsState;
     enum class BlockState { OptionsBlock, WorldBlock };
@@ -490,9 +486,6 @@ class SceneStateManager : public ParserTarget {
     std::set<std::string> namedMaterialNames, mediumNames;
     std::set<std::string> floatTextureNames, spectrumTextureNames, instanceNames;
     int currentMaterialIndex = 0, currentLightIndex = -1;
-
-    // These have to wait until WorldBegin to be passed along since they
-    // may be updated until then.
     SceneEntity film, sampler, integrator, filter, accelerator;
     CameraSceneEntity camera;
 };

src/pbrt/wavefront/integrator.cpp

@@ -120,8 +120,7 @@ WavefrontPathIntegrator::WavefrontPathIntegrator(
         return iter->second;
     };
 
-    filter = Filter::Create(scene.filter.name, scene.filter.parameters, &scene.filter.loc,
-                            alloc);
+    filter = scene.CreateFilter();
 
     Float exposureTime = scene.camera.parameters.GetOneFloat("shutterclose", 1.f) -
                          scene.camera.parameters.GetOneFloat("shutteropen", 0.f);
@@ -130,17 +129,14 @@ WavefrontPathIntegrator::WavefrontPathIntegrator(
                   "The specified camera shutter times imply that the shutter "
                   "does not open.  A black image will result.");
 
-    film = Film::Create(scene.film.name, scene.film.parameters, exposureTime,
-                        scene.camera.cameraTransform, filter, &scene.film.loc, alloc);
+    film = scene.CreateFilm(exposureTime, filter);
     initializeVisibleSurface = film.UsesVisibleSurface();
 
-    sampler = Sampler::Create(scene.sampler.name, scene.sampler.parameters,
-                              film.FullResolution(), &scene.sampler.loc, alloc);
+    sampler = scene.CreateSampler(film.FullResolution());
     samplesPerPixel = sampler.SamplesPerPixel();
 
     Medium cameraMedium = findMedium(scene.camera.medium, &scene.camera.loc);
-    camera = Camera::Create(scene.camera.name, scene.camera.parameters, cameraMedium,
-                            scene.camera.cameraTransform, film, &scene.camera.loc, alloc);
+    camera = scene.CreateCamera(cameraMedium, film);
 
     // Textures
     LOG_VERBOSE("Starting to create textures");
@@ -165,7 +161,7 @@ WavefrontPathIntegrator::WavefrontPathIntegrator(
     LOG_VERBOSE("Starting to create materials");
     std::map<std::string, pbrt::Material> namedMaterials;
     std::vector<pbrt::Material> materials;
-    scene.CreateMaterials(textures, threadAllocators, &namedMaterials, &materials);
+    scene.CreateMaterials(textures, &namedMaterials, &materials);
 
     haveBasicEvalMaterial.fill(false);
     haveUniversalEvalMaterial.fill(false);