VisualizerImpl.h

Go to the documentation of this file.

#ifndef VolViz_VisualizerImpl_h
#define VolViz_VisualizerImpl_h

#include "AtomicCache.h"
#include "GL/Binding.h"
#include "GL/Buffer.h"
#include "GL/Framebuffer.h"
#include "GL/GLFW.h"
#include "GL/Textures.h"
#include "GL/VertexArray.h"
#include "GeometryFactory.h"
#include "Shaders.h"
#include "Types.h"

#include <Eigen/Core>
#include <Eigen/Geometry>
#include <VolViz/VolViz.h>
#include <concurrentqueue.h>

#include <atomic>
#include <chrono>
#include <mutex>
#include <thread>
#include <unordered_map>

namespace VolViz {
namespace Private_ {

class VisualizerImpl {
  using InitQueueEntry =
      std::pair<Visualizer::GeometryName, Geometry::UniquePtr>;
  using GeometryList =
      std::unordered_map<Visualizer::GeometryName, Geometry::UniquePtr>;
  using GeometryInitQueue = moodycamel::ConcurrentQueue<InitQueueEntry>;

public:
  using Point2 = Eigen::Vector2f;
  using Size2 = Eigen::Vector2f;
  using Lights = std::unordered_map<Visualizer::LightName, Light>;

  VisualizerImpl(Visualizer *vis);

  void start();

  void enableMultithreading() noexcept;

  void renderOneFrame(bool block = true);

  operator bool() const noexcept;

  void setVolume(VolumeDescriptor descriptor, span<float const> data);
  void setVolume(VolumeDescriptor descriptor, span<Color const> data);

  Size3f volumeSize() const noexcept;

  template <class Descriptor,
            typename = std::enable_if_t<std::is_base_of<
                GeometryDescriptor, std::decay_t<Descriptor>>::value>>
  inline void addGeometry(Visualizer::GeometryName name,
                          Descriptor const &descriptor) {
    geometryInitQueue_.enqueue({name, geomFactory_.create(descriptor)});
  }

  template <class Descriptor,
            typename = std::enable_if_t<std::is_base_of<
                GeometryDescriptor, std::decay_t<Descriptor>>::value>>
  inline bool updateGeometry(Visualizer::GeometryName name,
                             Descriptor &&descriptor) {
    std::lock_guard<std::mutex> lock{geometriesMutex_};
    auto search = geometries_.find(name);
    if (search == geometries_.end()) {
      // There are two reasons for not finding a geometry:
      //   1. The geometry was not added (usage error). Nothing can be done to
      //      recover -> throw exception.
      //   2. Multithreading is enabled, in this case the geometry might have
      //      been added but was not initialized, yet. In this case the user
      //      can repeat the update later -> return false.
      if (multithreadingEnabled_) return false;
      throw std::logic_error("Geometry " + name + " not found");
    }

    search->second->enqueueUpdate(std::forward<Descriptor>(descriptor));
    return true;
  }

  inline Camera const &camera() const noexcept { return visualizer_->camera; }
  inline Camera &camera() noexcept { return visualizer_->camera; }

  inline auto cameraClient() const noexcept { return camera().client(); }

  inline Shaders &shaders() noexcept { return shaders_; }

  void attachVolumeToShader(GL::ShaderProgram &shader) const;

  void drawSingleVertex() const noexcept;

  void bindVolume(GLuint unitIdx = 0) const noexcept;

  Eigen::Matrix4f textureTransformationMatrix() const noexcept;

  AtomicCache<Length> cachedScale{
      [this]() -> Length { return visualizer_->scale; }};

  AtomicCache<Color> cachedBackgroundColor{
      [this]() -> Color { return visualizer_->backgroundColor; }};

private:
  friend class ::VolViz::Visualizer;

  using Clock = std::chrono::steady_clock;
  using TimePoint = std::chrono::time_point<Clock>;
  using GeometryNameAndPosition = struct {
    Visualizer::GeometryName name;
    Position position;
    float depth;
  };

  enum class TextureID : std::size_t {
    NormalsAndSpecular = 0,
    Albedo = 1,
    Depth = 2,
    RenderedImage = 3,
    FinalDepth = 4,
    VolumeTexture = 5,
    SelectionTexture = 6
  };

  void setupFBOs();

  void setupSelectionBuffers();

  Position unproject(Position2 const &screenPoint, float depth) const noexcept;

  void handleKeyInput(int key, int scancode, int action, int mode);

  void renderGeometry();

  void updateGeometries();

  void renderGrid();

  void renderPoint(Position const &position, Color const &color, float size);

  void renderQuad(Point2 const &topLeft, Size2 const &size, TextureID texture,
                  GL::ShaderProgram &prog);

  void renderFullscreenQuad(TextureID texture, GL::ShaderProgram &quad);

  void renderLightingTextures();

  void renderLights();

  void renderAmbientLighting();
  void renderDiffuseLighting();
  void renderSpecularLighting();

  void renderLightDiffuse(Light const &light);

  void renderLightSpecular(Light const &light);

  void renderSelectionIndexTexture();

  GeometryNameAndPosition getGeometryUnderCursor();

  void dragSelectedGeometry();

  void renderFinalPass();

  void renderBoundingBox(Position const &position,
                         Orientation const &orientation, Size3f const &size,
                         Color const &color);

  void renderVolumeBBox();

  void addLight(Visualizer::LightName name, Light const &light);


  Visualizer *visualizer_ = nullptr;
  GeometryFactory geomFactory_;

  struct DepthRange {
    float near, far;
  } depthRange_;

  GL::GLFW glfw_;

  Shaders shaders_;

  struct TextureWrapper {
    inline GLuint operator[](TextureID id) const noexcept {
      return textures_.names[static_cast<std::size_t>(id)];
    }

  private:
    GL::Textures<7> textures_;
  } textures_;
  GL::Framebuffer finalFbo_{0};
  GL::Framebuffer lightingFbo_{0};

  struct SelectionBuffer {
    using Buffers = std::array<GL::Buffer, 2>;
    using Handle = Buffers::iterator;

    Buffers buffers;
    Handle readBuffer{buffers.begin()}, writeBuffer{buffers.begin() + 1};
    inline void swap() noexcept {
      using std::swap;
      swap(readBuffer, writeBuffer);
    }
  } selectionBuffer_;

  GeometryList geometries_;
  std::mutex geometriesMutex_;
  GeometryInitQueue geometryInitQueue_;

  struct SingleVertData {
    GL::Buffer vBuff{0};
    GL::VertexArray vao{0};
  } singleVertexData_;

  enum class ViewState {
    Scene3D,
    LightingComponents,
    SelectionIndices
  } viewState_{ViewState::Scene3D};

  bool inSelectionMode{false};
  Visualizer::GeometryName selectedGeometry_;
  Position selectedPoint_{Position::Zero()};

  Lights lights_;
  std::mutex lightMutex_;

  enum class MoveState {
    None,
    Rotating,
    Dragging
  } moveState_ = MoveState::None;

  Position2 lastMousePos_ = Position2::Zero();
  Position2 lastMouseDelta_ = Position2::Zero();

  VolumeDescriptor currentVolume_;

  bool multithreadingEnabled_{false};

};

} // namespace Private_
} // namespace VolViz

#endif // VolViz_VisualizerImpl_h