main.cpp

#include <algorithm>
#include <cstdint>

#include <vtkAVIWriter.h>
#include <vtkOSPRayPass.h>
#include <vtkPNGWriter.h>
#include <vtkPolyDataMapper.h>
#include <vtkRenderer.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkSmartPointer.h>
#include <vtkOSPRayVolumeMapper.h>
#include <vtkVolume.h>
#include <vtkWindowToImageFilter.h>

#include <poly_data_io.hpp>
#include <settings.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]);

  std::cout << "Setting up renderer.\n";
  auto renderer    = vtkSmartPointer<vtkRenderer>    ::New();
  auto window      = vtkSmartPointer<vtkRenderWindow>::New();
  auto ospray_pass = vtkSmartPointer<vtkOSPRayPass>  ::New();
  window  ->AddRenderer          (renderer);
  window  ->SetOffScreenRendering(true);
  window  ->SetSize              (settings.image_size[0], settings.image_size[1]);
  window  ->SetMultiSamples      (settings.samples);
  renderer->SetPass              (ospray_pass);

  std::cout << "Setting up mappers, actors and volumes.\n";
  auto pd_mapper = vtkSmartPointer<vtkPolyDataMapper>    ::New();
  auto ug_mapper = vtkSmartPointer<vtkOSPRayVolumeMapper>::New();
  auto pd_actor  = vtkSmartPointer<vtkActor>             ::New();
  auto ug_volume = vtkSmartPointer<vtkVolume>            ::New();
  pd_actor ->SetMapper(pd_mapper);
  ug_volume->SetMapper(ug_mapper);
  renderer ->AddActor (pd_actor );
  renderer ->AddVolume(ug_volume);

  std::cout << "Setting up image and video writers.\n";
  auto window_to_image = vtkSmartPointer<vtkWindowToImageFilter>::New();
  auto image_writer    = vtkSmartPointer<vtkPNGWriter>          ::New();
  auto video_writer    = vtkSmartPointer<vtkAVIWriter>          ::New();
  window_to_image->SetInput          (window);
  image_writer   ->SetInputConnection(window_to_image->GetOutputPort());
  video_writer   ->SetInputConnection(window_to_image->GetOutputPort());
  video_writer   ->SetFileName       ("video.avi");
  video_writer   ->SetQuality        (2);
  video_writer   ->SetRate           (settings.update_rate); // 24
  video_writer   ->Start             ();

  std::cout << "Starting render.\n";
  auto current_time = 0.0f;
  auto counter      = 0;
  auto last_slice   = -1;
  while (current_time < settings.key_frames.back().time && counter < 10)
  {
    std::cout << "Rendering frame " << counter << ".\n";

    auto  iterator        = std::lower_bound(settings.key_frames.begin(), settings.key_frames.end(), current_time, [ ] (const rt::settings::key_frame& key_frame, const float value)
    {
      return key_frame.time < value;
    });
    auto& key_frame_1     = *(iterator    );
    auto& key_frame_2     = *(iterator + 1);
    auto  parametric_time = (current_time - key_frame_1.time) / (key_frame_2.time - key_frame_1.time);
    // TODO: Update camera.

    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)
    {
      last_slice = slice;
      pd_mapper->SetInputData(rt::poly_data_io        ::read(settings.data_filepaths[slice].geometry));
      //ug_mapper->SetInputData(rt::unstructured_grid_io::read(settings.data_filepaths[slice].volume  ));
    }

    window      ->Render     ();
    image_writer->SetFileName((std::string("frame_") + std::to_string(counter) + std::string(".png")).c_str());
    image_writer->Write      ();
    video_writer->Write      ();

    current_time += settings.update_rate;
    counter      ++;
  }
  std::cout << "Finished render.\n";
  video_writer->End();

  return 0;
}