added support for #45

Author: PearCoding

src/device/DeviceInterface.cpp

@@ -87,6 +87,16 @@ inline IDeviceInterface::DeviceImageProxy<T> mapToProxyDevice(const DeviceImageB
     };
 }
 
+template <typename T>
+inline IDeviceInterface::DeviceImageProxy<T> mapToProxyHost(const DeviceImageBase<T>& buffer)
+{
+    return IDeviceInterface::DeviceImageProxy<T>{
+        .DataPtr = const_cast<T*>(buffer.Data.HostPtr),
+        .Width   = buffer.Width,
+        .Height  = buffer.Height
+    };
+}
+
 template <typename T>
 inline IDeviceInterface::DeviceStreamProxy<T> mapToProxyDevice(const DeviceStreamBase<T>& buffer)
 {
@@ -928,7 +938,7 @@ IDeviceInterface::DeviceImageProxy<float> DeviceInterface::loadAOVImageForDevice
     const std::string& actual_name = handleAOVName(aov_name);
 
     if (const auto it = mDeviceData.aovs.find(actual_name); it != mDeviceData.aovs.end()) {
-        IG_ASSERT(it->second.Width == mFramebufferWidth && it->second.Height == mFramebufferHeight, "Size of framebuffer changed inbetween iterations");
+        IG_ASSERT(it->second.Width == mFramebufferWidth && it->second.Height == mFramebufferHeight, "Size of framebuffer changed between iterations");
         it->second.Data.syncForDevice();
         if (willBeModified)
             it->second.Data.markDirtyOnDevice();
@@ -957,19 +967,25 @@ IDeviceInterface::DeviceImageProxy<float> DeviceInterface::loadAOVImageForHost(c
     const std::string& actual_name = handleAOVName(aov_name);
 
     if (const auto it = mDeviceData.aovs.find(actual_name); it != mDeviceData.aovs.end()) {
-        IG_ASSERT(it->second.Width == mFramebufferWidth && it->second.Height == mFramebufferHeight, "Size of framebuffer changed inbetween iterations");
+        IG_ASSERT(it->second.Width == mFramebufferWidth && it->second.Height == mFramebufferHeight, "Size of framebuffer changed between iterations");
         it->second.Data.syncForHost();
         if (willBeModified)
             it->second.Data.markDirtyOnHost();
-        return DeviceImageProxy<float>{
-            .DataPtr = it->second.Data.HostPtr,
-            .Width   = it->second.Width,
-            .Height  = it->second.Height
-        };
+        return mapToProxyHost(it->second);
     } else {
-        // Note: Currently only the device side is allowed to create new AOVs. This is only by design to catch some common mistakes, but if a use-case arise we might change this in the future.
-        IG_LOG(L_ERROR) << "Unknown aov '" << actual_name << "' access for host" << std::endl;
-        return DeviceImageProxy<float>::Invalid();
+        const size_t expectedSize = framebufferArea() * 3;
+
+        auto aov = DeviceImage{
+            .Data   = createAOVArray(mDeviceID, expectedSize),
+            .Width  = mFramebufferWidth,
+            .Height = mFramebufferHeight
+        };
+
+        if (willBeModified)
+            aov.Data.markDirtyOnHost();
+        else
+            aov.Data.fillHostWithZero();
+        return mapToProxyHost(mDeviceData.aovs.try_emplace(actual_name, std::move(aov)).first->second);
     }
 }
 

src/frontend/cli/main.cpp

@@ -97,6 +97,10 @@ int main(int argc, char** argv)
     }
 
     runtime->mergeParametersFrom(cmd.UserEntries);
+
+    if (!cmd.ContinueImage.empty())
+        runtime->loadPreviousFramebuffer(cmd.ContinueImage);
+
     timer_loading.stop();
 
     auto orientation = runtime->initialCameraOrientation();
@@ -111,6 +115,9 @@ int main(int argc, char** argv)
     if (cmd.SPP.has_value() && (cmd.SPP.value() % SPI) != 0)
         IG_LOG(L_WARNING) << "Given spp " << cmd.SPP.value() << " is not a multiple of the spi " << SPI << ". Using spp " << desired_iter * SPI << " instead" << std::endl;
 
+    if (runtime->currentSampleCount() >= (size_t)cmd.SPP.value_or(std::numeric_limits<int>::max()))
+        IG_LOG(L_WARNING) << "Requested spp already satisfied. No need to continue." << std::endl;
+
     StatusObserver observer(!cmd.NoColor, 2, desired_iter * SPI /* Approx */, cmd.RenderTime.value_or(0));
     observer.begin();
 
@@ -119,7 +126,7 @@ int main(int argc, char** argv)
     std::vector<double> samples_sec;
 
     SectionTimer timer_render;
-    while (true) {
+    while (runtime->currentSampleCount() < (size_t)cmd.SPP.value_or(std::numeric_limits<int>::max())) {
         if (!cmd.NoProgress)
             observer.update(runtime->currentSampleCount());
 
@@ -132,15 +139,18 @@ int main(int argc, char** argv)
         auto elapsed_ms = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now() - ticks).count();
 
         samples_sec.emplace_back(1000.0 * double(SPI * runtime->framebufferWidth() * runtime->framebufferHeight()) / double(elapsed_ms));
-        if (desired_iter > 0 && samples_sec.size() == desired_iter)
-            break;
-        else if (cmd.RenderTime.has_value() && timer_render.duration_ms / 1000 > cmd.RenderTime.value())
+        if (cmd.RenderTime.has_value() && timer_render.duration_ms / 1000 > cmd.RenderTime.value())
             break;
     }
 
     if (!cmd.NoProgress)
         observer.end();
 
+    if (samples_sec.empty()) {
+        IG_LOG(L_WARNING) << "Nothing rendered." << std::endl;
+        return EXIT_SUCCESS;
+    }
+
     SectionTimer timer_saving;
     timer_saving.start();
     if (!runtime->saveFramebuffer(cmd.Output))

src/frontend/common/ProgramOptions.cpp

@@ -53,6 +53,10 @@ ProgramOptions::ProgramOptions(int argc, char** argv, ApplicationType type, cons
     app.set_help_flag("-h,--help", "Shows help message and exit");
 
     app.add_option("scene", InputScene, "Scene file to load. Can be a Ignis scene file or a glTF file.")->required()->check(CLI::ExistingFile);
+
+    if (type != ApplicationType::Trace)
+        app.add_option("--continue", ContinueImage, "Image to continue rendering from. Must be an output of Ignis with embedded meta-data and the same input scene and settings.")->check(CLI::ExistingFile);
+
     app.add_flag("-q,--quiet", Quiet, "Do not print messages into console");
     app.add_flag_callback(
         "-v,--verbose", [&]() { VerbosityLevel = L_DEBUG; }, "Set the verbosity level to 'debug'. Shortcut for --log-level debug");

src/frontend/common/ProgramOptions.h

@@ -85,6 +85,7 @@ class ProgramOptions {
     Path Output;
     Path InputScene;
     Path InputRay;
+    Path ContinueImage;
 
     Path ScriptDir;
 

src/frontend/view/main.cpp

@@ -93,6 +93,10 @@ int main(int argc, char** argv)
     }
 
     runtime->mergeParametersFrom(cmd.UserEntries);
+
+    if (!cmd.ContinueImage.empty())
+        runtime->loadPreviousFramebuffer(cmd.ContinueImage);
+
     timer_loading.stop();
 
     const auto def = runtime->initialCameraOrientation();

src/runtime/Image.cpp

@@ -594,37 +594,37 @@ Image Image::load(const Path& path, ImageMetaData* metaData, const std::string*
         int channels = 0;
         std::unordered_set<std::string> channel_names; // Only populated if metaData != nullptr
         for (int c = 0; c < exr_header.num_channels; ++c) {
-            const std::string name = to_lowercase(std::string(exr_header.channels[c].name));
+            const std::string name = std::string(exr_header.channels[c].name);
 
             if (optionalLayerName) {
-                if (name == (*optionalLayerName + ".a"))
+                if (string_equal_icase(name, (*optionalLayerName + ".a")))
                     idxA = c;
-                else if (name == (*optionalLayerName + ".r"))
+                else if (string_equal_icase(name, (*optionalLayerName + ".r")))
                     idxR = c;
-                else if (name == (*optionalLayerName + ".g"))
+                else if (string_equal_icase(name, (*optionalLayerName + ".g")))
                     idxG = c;
-                else if (name == (*optionalLayerName + ".b"))
+                else if (string_equal_icase(name, (*optionalLayerName + ".b")))
                     idxB = c;
-                else if (name == (*optionalLayerName + ".y"))
+                else if (string_equal_icase(name, (*optionalLayerName + ".y")))
                     idxY = c;
-                else if (name == *optionalLayerName)
+                else if (string_equal_icase(name, *optionalLayerName))
                     idxY = c;
             } else {
-                if (name == "a" || name == "default.a")
+                if (string_equal_icase(name, "a") || string_equal_icase(name, "default.a"))
                     idxA = c;
-                else if (name == "r" || name == "default.r")
+                else if (string_equal_icase(name, "r") || string_equal_icase(name, "default.r"))
                     idxR = c;
-                else if (name == "g" || name == "default.g")
+                else if (string_equal_icase(name, "g") || string_equal_icase(name, "default.g"))
                     idxG = c;
-                else if (name == "b" || name == "default.b")
+                else if (string_equal_icase(name, "b") || string_equal_icase(name, "default.b"))
                     idxB = c;
-                else if (name == "y" || name == "default.y")
+                else if (string_equal_icase(name, "y") || string_equal_icase(name, "default.y"))
                     idxY = c;
             }
 
             if (metaData) {
                 const std::string extractedName = extractChannelName(name);
-                if (extractedName != "a" && extractedName != "r" && extractedName != "g" && extractedName != "b" && extractedName != "y")
+                if (!string_equal_icase(extractedName, "a") && !string_equal_icase(extractedName, "r") && !string_equal_icase(extractedName, "g") && !string_equal_icase(extractedName, "b") && !string_equal_icase(extractedName, "y"))
                     channel_names.emplace(extractedName);
             }
             ++channels;

src/runtime/Runtime.cpp

@@ -469,6 +469,67 @@ void Runtime::clearFramebuffer(const std::string& name)
     mDevice->clearFramebuffer(name);
 }
 
+bool Runtime::loadPreviousFramebuffer(const Path& path)
+{
+    if (mOptions.IsTracer) {
+        IG_LOG(L_ERROR) << "Trying to load a previous framebuffer for a trace runtime!" << std::endl;
+        return false;
+    }
+
+    ImageMetaData metaData;
+    Image image = Image::load(path, &metaData);
+    if (!image.isValid()) {
+        IG_LOG(L_ERROR) << "Could not load previous framebuffer " << path << std::endl;
+        return false;
+    }
+    image.flipY();
+
+    if (!metaData.Frame.has_value()
+        || !metaData.Iteration.has_value()
+        || !metaData.SamplePerIteration.has_value()
+        || !metaData.SamplePerPixel.has_value()) {
+        IG_LOG(L_ERROR) << "Trying to load a previous framebuffer using an image without proper meta-data. Are you sure this image was generated with Ignis?" << std::endl;
+        return false;
+    }
+
+    if (metaData.TechniqueType.has_value() && *metaData.TechniqueType != technique())
+        IG_LOG(L_WARNING) << "Previous framebuffer was rendered with a different technique. Previous '" << *metaData.TechniqueType << "' might be incompatible with the current '" << technique() << "'." << std::endl;
+    if (metaData.CameraType.has_value() && *metaData.CameraType != camera())
+        IG_LOG(L_WARNING) << "Previous framebuffer was rendered with a different camera. Previous '" << *metaData.CameraType << "' might be incompatible with the current '" << camera() << "'." << std::endl;
+
+    if (image.channels != 3)
+        image = image.castTo(3);
+
+    IG_ASSERT(mDevice, "Expected device to be available");
+    mDevice->resize(mFilmWidth, mFilmHeight); // Ensure the device is properly sized
+
+    const auto framebuffer = mDevice->getFramebufferForHost({}, true);
+    std::memcpy(framebuffer.Data, image.pixels.get(), image.width * image.height * image.channels * sizeof(float));
+
+    for (const auto& layerName : metaData.AdditionalLayerNames) {
+        if (layerName.empty() || layerName == "Color")
+            continue;
+
+        Image layer = Image::load(path, nullptr, &layerName);
+        IG_ASSERT(layer.isValid(), "Loading a promised layer from an existing image failed.");
+        layer.flipY();
+
+        if (layer.channels != 3)
+            layer = layer.castTo(3);
+
+        const auto aov = mDevice->getFramebufferForHost(layerName, true);
+        std::memcpy(aov.Data, layer.pixels.get(), layer.width * layer.height * layer.channels * sizeof(float));
+    }
+
+    mCurrentIteration   = *metaData.Iteration;
+    mCurrentSampleCount = *metaData.SamplePerPixel;
+    mCurrentFrame       = *metaData.Frame;
+
+    IG_LOG(L_INFO) << "Continuing rendering from " << mCurrentSampleCount << " samples per pixel." << std::endl;
+
+    return true;
+}
+
 size_t Runtime::getBufferSizeInBytes(const std::string& name) const
 {
     return mDevice->getBufferSizeInBytes(name);
@@ -806,20 +867,17 @@ bool Runtime::saveFramebuffer(const Path& path) const
         float* dst_g     = &images[width * height * (3 * aov + 1)];
         float* dst_b     = &images[width * height * (3 * aov + 2)];
 
-        const auto pixelF = [&](size_t ind) {
-            float r = src[ind * 3 + 0];
-            float g = src[ind * 3 + 1];
-            float b = src[ind * 3 + 2];
-
-            dst_r[ind] = r * scale;
-            dst_g[ind] = g * scale;
-            dst_b[ind] = b * scale;
-        };
-
         tbb::parallel_for(tbb::blocked_range<size_t>(0, width * height),
                           [&](tbb::blocked_range<size_t> r) {
-                              for (size_t i = r.begin(); i < r.end(); ++i)
-                                  pixelF(i);
+                              for (size_t i = r.begin(); i < r.end(); ++i) {
+                                  const float r = src[i * 3 + 0];
+                                  const float g = src[i * 3 + 1];
+                                  const float b = src[i * 3 + 2];
+
+                                  dst_r[i] = r * scale;
+                                  dst_g[i] = g * scale;
+                                  dst_b[i] = b * scale;
+                              }
                           });
     }
 

src/runtime/Runtime.h

@@ -77,6 +77,9 @@ class IG_LIB Runtime {
     /// Will clear specific framebuffer
     void clearFramebuffer(const std::string& name);
 
+    /// Will try to recover the framebuffer and spp settings from a previous image
+    bool loadPreviousFramebuffer(const Path& path);
+
     [[nodiscard]] size_t getBufferSizeInBytes(const std::string& name) const;
     [[nodiscard]] BufferAccessor getBufferForDevice(const std::string& name) const;
     BufferAccessor requestBufferForDevice(const std::string& name, size_t sizeInBytes) const;

src/runtime/StringUtils.cpp

@@ -63,6 +63,11 @@ bool string_ends_with(const std::string& str, const std::string& suffix)
     return string_ends_with((std::string_view)str, (std::string_view)suffix);
 }
 
+bool string_equal_icase(std::string_view a, std::string_view b)
+{
+    return std::equal(a.begin(), a.end(), b.begin(), b.end(), [](auto ca, auto cb) { return ::tolower(ca) == ::tolower(cb); });
+}
+
 void string_left_trim(std::string& s)
 {
     s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](unsigned char ch) {

src/runtime/StringUtils.h

@@ -22,6 +22,8 @@ namespace IG {
 [[nodiscard]] IG_LIB bool string_ends_with(std::string_view str, std::string_view suffix);
 [[nodiscard]] IG_LIB bool string_ends_with(const std::string& str, const std::string& suffix);
 
+[[nodiscard]] IG_LIB bool string_equal_icase(std::string_view a, std::string_view b);
+
 /// Trim string from the left side in place
 IG_LIB void string_left_trim(std::string& s);