Fuck modularity. Make it work.

offline_ray_tracer/include/poly_data_io.hpp

-#ifndef POLY_DATA_IO_HPP
-#define POLY_DATA_IO_HPP
-
-#include <string>
-
-#include <vtkPolyData.h>
-#include <vtkSmartPointer.h>
-#include <vtkXMLPolyDataReader.h>
-#include <vtkXMLPolyDataWriter.h>
-
-namespace rt
-{
-class poly_data_io
-{
-public:
-  static vtkSmartPointer<vtkPolyData> read (const std::string& filepath)
-  {
-    auto reader = vtkSmartPointer<vtkXMLPolyDataReader>::New();
-    auto data   = vtkSmartPointer<vtkPolyData>         ::New();
-    reader->SetFileName(filepath.c_str());
-    reader->Update     ();
-    data  ->ShallowCopy(reader->GetOutput());
-    return data;
-  }
-  static void                         write(const std::string& filepath, vtkPolyData* data, const bool compress = false)
-  {
-    auto writer = vtkSmartPointer<vtkXMLPolyDataWriter>::New();
-    writer->SetDataModeToBinary  ();
-    writer->SetFileName          (filepath.c_str());
-    writer->SetHeaderTypeToUInt64();
-    writer->SetInputData         (data);
-    compress
-      ? writer->SetCompressorTypeToZLib()
-      : writer->SetCompressorTypeToNone();
-    writer->Write                ();
-  }
-};
-}
-
-#endif

offline_ray_tracer/include/unstructured_grid_io.hpp

-#ifndef UNSTRUCTURED_GRID_IO_HPP
-#define UNSTRUCTURED_GRID_IO_HPP
-
-#include <optional>
-#include <string>
-
-#include <vtkSmartPointer.h>
-#include <vtkXMLUnstructuredGridReader.h>
-#include <vtkXMLUnstructuredGridWriter.h>
-#include <vtkUnstructuredGrid.h>
-
-namespace rt
-{
-class unstructured_grid_io
-{
-public:
-  static vtkSmartPointer<vtkUnstructuredGrid> read (const std::string& filepath, std::optional<std::string> field_name)
-  {
-    auto reader = vtkSmartPointer<vtkXMLUnstructuredGridReader>::New();
-    auto data   = vtkSmartPointer<vtkUnstructuredGrid>         ::New();
-    reader->SetFileName(filepath.c_str());
-
-    if (field_name)
-      reader->SetInputArrayToProcess(0, 0, 0, vtkDataObject::FIELD_ASSOCIATION_CELLS, field_name->c_str());
-
-    reader->Update     ();
-    data  ->ShallowCopy(reader->GetOutput());
-    return data;
-  }
-  static void                                 write(const std::string& filepath, vtkUnstructuredGrid* data, const bool compress = false)
-  {
-    auto writer = vtkSmartPointer<vtkXMLUnstructuredGridWriter>::New();
-    writer->SetDataModeToBinary  ();
-    writer->SetFileName          (filepath.c_str());
-    writer->SetHeaderTypeToUInt64();
-    writer->SetInputData         (data);
-    compress
-      ? writer->SetCompressorTypeToZLib()
-      : writer->SetCompressorTypeToNone();
-    writer->Write                ();
-  }
-};
-}
-
-#endif

offline_ray_tracer/source/main.cpp

@@ -51,26 +51,11 @@ std::int32_t main(std::int32_t argc, char** argv)
     interpolator->AddCamera    (key_frame.time, camera);
   }
 
-  std::cout << "Setting up geometry.\n";
-  auto pd_mapper = vtkSmartPointer<vtkPolyDataMapper>::New();
-  auto pd_actor  = vtkSmartPointer<vtkActor>         ::New();
-  if (!settings.data_filepaths[0].geometry.empty())
-  {
-    pd_actor->SetMapper(pd_mapper);
-    renderer->AddActor (pd_actor );
-  }
-
-  std::cout << "Setting up volume.\n";
-  auto ug_mapper = vtkSmartPointer<vtkUnstructuredGridVolumeRayCastMapper>::New();
-  auto ug_volume = vtkSmartPointer<vtkVolume>                             ::New();
-  if (!settings.data_filepaths[0].volume.empty())
-  {
-    auto tf = rt::transfer_function(settings.transfer_function);
-    ug_volume->GetProperty()->SetScalarOpacity(tf.opacity_function);
-    ug_volume->GetProperty()->SetColor        (tf.color_function  );
-    ug_volume->SetMapper  (ug_mapper);
-    renderer ->AddVolume  (ug_volume);
-  }
+  std::cout << "Setting up geometry and volume.\n";
+  auto pd_mapper = vtkSmartPointer<vtkPolyDataMapper>                     ();
+  auto pd_actor  = vtkSmartPointer<vtkActor>                              ();
+  auto ug_mapper = vtkSmartPointer<vtkUnstructuredGridVolumeRayCastMapper>();
+  auto ug_volume = vtkSmartPointer<vtkVolume>                             ();
 
   std::cout << "Setting up video writer.\n";
   auto window_to_image = vtkSmartPointer<vtkWindowToImageFilter>::New();
@@ -89,14 +74,55 @@ std::int32_t main(std::int32_t argc, char** argv)
   {
     std::size_t slice = std::floor(current_time / settings.time_scale);
     slice = settings.loop ? slice % settings.data_filepaths.size() : std::min(slice, settings.data_filepaths.size() - 1);
+
     if (last_slice != slice)
     {
-      std::cout << "Loading slice " << slice << ".\n";
       last_slice = slice;
+
+      std::cout << "Clearing previous slice.\n";
+      renderer ->RemoveActor (pd_actor );
+      pd_actor ->SetMapper   (nullptr  );
+      renderer ->RemoveVolume(ug_volume);
+      ug_volume->SetMapper   (nullptr  );
+      
+      pd_mapper = nullptr;
+      pd_actor  = nullptr;
+      ug_mapper = nullptr;
+      ug_volume = nullptr;
+
+      
+    auto reader = vtkSmartPointer<vtkXMLPolyDataReader>::New();
+    auto data   = vtkSmartPointer<vtkPolyData>         ::New();
+    reader->SetFileName(filepath.c_str());
+    reader->Update     ();
+    data  ->ShallowCopy(reader->GetOutput());
+    return data;
+
+      
+    auto reader = vtkSmartPointer<vtkXMLUnstructuredGridReader>::New();
+    auto data   = vtkSmartPointer<vtkUnstructuredGrid>         ::New();
+    reader->SetFileName(filepath.c_str());
+
+    if (field_name)
+      reader->SetInputArrayToProcess(0, 0, 0, vtkDataObject::FIELD_ASSOCIATION_CELLS, field_name->c_str());
+
+    reader->Update     ();
+    data  ->ShallowCopy(reader->GetOutput());
+    return data;
+
+      std::cout << "Loading next slice (" << slice << ").\n";
       if (!settings.data_filepaths[slice].geometry.empty())
         pd_mapper->SetInputData(rt::poly_data_io        ::read(settings.data_filepaths[slice].geometry));
       if (!settings.data_filepaths[slice].volume  .empty())
         ug_mapper->SetInputData(rt::unstructured_grid_io::read(settings.data_filepaths[slice].volume  , "Q"));
+
+      auto tf = rt::transfer_function(settings.transfer_function);
+      pd_actor->SetMapper                       (pd_mapper);
+      renderer->AddActor                        (pd_actor );
+      ug_volume->GetProperty()->SetScalarOpacity(tf.opacity_function);
+      ug_volume->GetProperty()->SetColor        (tf.color_function  );
+      ug_volume->SetMapper                      (ug_mapper);
+      renderer ->AddVolume                      (ug_volume);
     }
 
     std::cout << "Rendering frame " << current_time << ".\n";
@@ -108,7 +134,8 @@ std::int32_t main(std::int32_t argc, char** argv)
 
     current_time += settings.update_rate;
   }
-  std::cout << "Finished rendering.\n";
+
+  std::cout << "Finished rendering. Finalizing video.\n";
   video_writer->End();
 
   return 0;