This should do it.

offline_ray_tracer/source/main.cpp

@@ -2,12 +2,10 @@
 #include <iostream>
 
 #include <vtkActor.h>
+#include <vtkAVIWriter.h>
 #include <vtkCamera.h>
 #include <vtkCameraInterpolator.h>
-#include <vtkColorTransferFunction.h>
-#include <vtkOggTheoraWriter.h>
 #include <vtkOSPRayPass.h>
-#include <vtkPiecewiseFunction.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkRenderer.h>
 #include <vtkRenderWindow.h>
@@ -16,16 +14,17 @@
 #include <vtkVolume.h>
 #include <vtkVolumeProperty.h>
 #include <vtkWindowToImageFilter.h>
+#include <vtkXMLPolyDataReader.h>
+#include <vtkXMLUnstructuredGridReader.h>
 
-#include <poly_data_io.hpp>
 #include <settings.hpp>
 #include <transfer_function.hpp>
-#include <unstructured_grid_io.hpp>
 
 std::int32_t main(std::int32_t argc, char** argv)
 {
   std::cout << "Parsing settings.\n";
   auto settings = rt::settings(argv[1]);
+  auto tf       = rt::transfer_function(settings.transfer_function);
 
   std::cout << "Setting up renderer.\n";
   auto renderer    = vtkSmartPointer<vtkRenderer>    ::New();
@@ -52,17 +51,19 @@ std::int32_t main(std::int32_t argc, char** argv)
   }
 
   std::cout << "Setting up geometry and volume.\n";
+  auto pd_reader = vtkSmartPointer<vtkXMLPolyDataReader>                  ();
   auto pd_mapper = vtkSmartPointer<vtkPolyDataMapper>                     ();
   auto pd_actor  = vtkSmartPointer<vtkActor>                              ();
+  auto ug_reader = vtkSmartPointer<vtkXMLUnstructuredGridReader>          ();
   auto ug_mapper = vtkSmartPointer<vtkUnstructuredGridVolumeRayCastMapper>();
   auto ug_volume = vtkSmartPointer<vtkVolume>                             ();
 
   std::cout << "Setting up video writer.\n";
   auto window_to_image = vtkSmartPointer<vtkWindowToImageFilter>::New();
-  auto video_writer    = vtkSmartPointer<vtkOggTheoraWriter>    ::New();
+  auto video_writer    = vtkSmartPointer<vtkAVIWriter>          ::New();
   window_to_image->SetInput          (window);
   video_writer   ->SetInputConnection(window_to_image->GetOutputPort());
-  video_writer   ->SetFileName       ("video.ogg");
+  video_writer   ->SetFileName       ("video.avi");
   video_writer   ->SetQuality        (1);
   video_writer   ->SetRate           (1000.0 / settings.update_rate);
   video_writer   ->Start             ();
@@ -77,55 +78,53 @@ std::int32_t main(std::int32_t argc, char** argv)
 
     if (last_slice != slice)
     {
-      last_slice = slice;
-
+      if (last_slice != -1)
+      {
         std::cout << "Clearing previous slice.\n";
+
         renderer ->RemoveActor          (pd_actor );
         pd_actor ->SetMapper            (nullptr  );
+        pd_mapper->RemoveInputConnection(0, pd_reader->GetOutputPort());
+
         renderer ->RemoveVolume         (ug_volume);
         ug_volume->SetMapper            (nullptr  );
+        ug_mapper->RemoveInputConnection(0, ug_reader->GetOutputPort());
         
+        pd_reader = nullptr;
         pd_mapper = nullptr;
         pd_actor  = nullptr;
+
+        ug_reader = nullptr;
         ug_mapper = nullptr;
         ug_volume = nullptr;
+      }
 
+      pd_reader = vtkSmartPointer<vtkXMLPolyDataReader>                  ::New();
+      pd_mapper = vtkSmartPointer<vtkPolyDataMapper>                     ::New();
+      pd_actor  = vtkSmartPointer<vtkActor>                              ::New();
 
-    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"));
+      ug_reader = vtkSmartPointer<vtkXMLUnstructuredGridReader>          ::New();
+      ug_mapper = vtkSmartPointer<vtkUnstructuredGridVolumeRayCastMapper>::New();
+      ug_volume = vtkSmartPointer<vtkVolume>                             ::New();
 
-      auto tf = rt::transfer_function(settings.transfer_function);
+      std::cout << "Loading next slice: " << slice << ".\n";
+      pd_reader->SetFileName                    (settings.data_filepaths[slice].geometry.c_str());
+      pd_mapper->SetInputConnection             (pd_reader->GetOutputPort());
       pd_actor ->SetMapper                      (pd_mapper);
       renderer ->AddActor                       (pd_actor );
+
+      ug_reader->SetFileName                    (settings.data_filepaths[slice].volume  .c_str());
+      ug_reader->SetInputArrayToProcess         (0, 0, 0, vtkDataObject::FIELD_ASSOCIATION_CELLS, "Q");
+      ug_mapper->SetInputConnection             (ug_reader->GetOutputPort());
+      ug_volume->SetMapper                      (ug_mapper);
       ug_volume->GetProperty()->SetScalarOpacity(tf.opacity_function);
       ug_volume->GetProperty()->SetColor        (tf.color_function  );
-      ug_volume->SetMapper                      (ug_mapper);
       renderer ->AddVolume                      (ug_volume);
+
+      last_slice = slice;
     }
 
-    std::cout << "Rendering frame " << current_time << ".\n";
+    std::cout << "Rendering frame: " << current_time << ".\n";
     interpolator   ->InterpolateCamera       (current_time, renderer->GetActiveCamera());
     renderer       ->ResetCameraClippingRange();
     window         ->Render                  ();