scene.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 Povl Filip Sonne-Frederiksen
//
// SPDX-License-Identifier: GPL-3.0-or-later
 
#pragma once
 
// The scene builder shared by `rux render` (render_view, headless) and the
// Qt client's 3D workspace (an interactive QVTKOpenGLNativeWidget).
//
// render_view() used to build its VTK scene inline, so the only way for an
// interactive viewer to show "the same thing rux render shows" was to copy
// that code. populate_scene() is the one definition instead: it loads a
// project's layers and adds them to a caller's vtkRenderer, and the camera and
// cut-plane helpers below place the camera the way the presets do. Both front
// ends call them; render_view() is now validation + populate_scene() + camera
// + an offscreen render window.
//
// Header hygiene (STANDARDS §2): VTK types are forward-declared, so a consumer
// that only needs SceneOptions/SceneInfo compiles no VTK header.
 
#include "reusex/visualize/render_view.hpp"
 
#include <array>
#include <cstddef>
#include <cstdint>
#include <optional>
#include <string>
#include <string_view>
#include <vector>
 
class vtkActor;
class vtkRenderer;
 
namespace reusex::visualize {

struct SceneBounds {
  std::array<double, 3> min{0, 0, 0};
  std::array<double, 3> max{0, 0, 0};
  bool valid = false;
 
  void add(double x, double y, double z);
  std::array<double, 3> center() const;
  double extent(int axis) const { return max[axis] - min[axis]; }
  double diagonal() const;
};

struct LabelPalette {
  std::vector<std::array<std::uint8_t, 3>> colors; 
  std::array<std::uint8_t, 3> unlabeled{0, 0, 0};  
  std::array<std::uint8_t, 3> invalid{0, 0, 0};
};

const LabelPalette &default_label_palette();

inline constexpr int kUnlabeledSlot = -1;
inline constexpr int kInvalidSlot = -2;

int label_palette_slot(std::uint32_t label, std::size_t size);

std::array<std::uint8_t, 3> label_palette_color(const LabelPalette &palette,
                                                std::uint32_t label);

enum class LodMethod {
  all,           
  morton_prefix, 
  stride,        
};
 
std::string_view to_string(LodMethod method);

std::vector<std::uint32_t> lod_indices(std::size_t total, std::size_t budget,
                                       std::string_view storage_order,
                                       LodMethod *method = nullptr);

struct SceneOptions {
  std::vector<Layer> layers{Layer::cloud};
  std::string cloud_name = "cloud";
  std::string mesh_name = "mesh";
  double point_size = 2.0;
  std::optional<InstanceHighlight> highlight;
  std::optional<LabelPalette> palette;

  std::size_t max_points = 0;
  std::size_t coarse_points = 0;

  std::size_t max_frustums = 300;
  double frustum_depth = 0.25;
  std::array<std::uint8_t, 3> frustum_rgb{150, 160, 176};
  std::array<std::uint8_t, 3> panorama_rgb{255, 176, 64};
};

struct SceneLayer {
  Layer layer = Layer::cloud;
  std::vector<vtkActor *> actors;
  vtkActor *coarse = nullptr;
  std::size_t points = 0; 
  std::size_t faces = 0;  
  std::size_t items = 0;  
};

struct SceneInfo {
  SceneBounds bounds;
  std::size_t drawn_points = 0;
  std::size_t drawn_faces = 0;
  std::vector<SceneLayer> layers;
  std::size_t source_points = 0;
  LodMethod lod = LodMethod::all;
  std::vector<std::uint32_t> indices;
};

SceneInfo populate_scene(vtkRenderer *renderer, const ProjectDB &db,
                         const SceneOptions &opts);

struct CutPlane {
  double z = 0.0;           
  double floor_z = 0.0;     
  double height = 0.0;      
  bool from_planes = false; 
};

CutPlane resolve_cut_plane(const ProjectDB &db, const SceneBounds &bounds,
                           std::optional<double> height);

void apply_cut_plane(vtkRenderer *renderer, double z);

void clear_cut_planes(vtkRenderer *renderer);

struct CameraFraming {
  ViewPreset view = ViewPreset::top; 
  int orbit_count = 8;
  int orbit_index = 0;
  double orbit_elevation_deg = 25.0;
  double margin = 1.08;
  double aspect = 4.0 / 3.0; 
};

void place_preset_camera(vtkRenderer *renderer, const CameraFraming &framing,
                         const SceneBounds &bounds);

void place_explicit_camera(vtkRenderer *renderer, const CameraSpec &spec,
                           int width, int height, const SceneBounds &bounds);

void install_vtk_log_bridge();
 
} // namespace reusex::visualize