EBGeometry_Render.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2026 Robert Marskar <robert.marskar@sintef.no>
//
// SPDX-License-Identifier: GPL-3.0-or-later
 
#ifndef EBGEOMETRY_RENDER_HPP
#define EBGEOMETRY_RENDER_HPP
 
// Std includes
#include <atomic>
#include <cstdint>
#include <string>
#include <vector>
 
// Our includes
#include "EBGeometry_Array.hpp"
#include "EBGeometry_BoundingVolumes.hpp"
#include "EBGeometry_Expr.hpp"
#include "EBGeometry_GPU.hpp"
#include "EBGeometry_Ray.hpp"
#include "EBGeometry_Vec.hpp"
 
namespace EBGeometry {
 
template <class T>
class FlatMeshSDF;
 
template <class T, size_t K>
class MeshSDF;
 
template <class T, size_t K, size_t W>
class TriMeshSDF;
 
} // namespace EBGeometry
 
namespace EBGeometry::Render {
 
template <class S>
inline constexpr bool primitivesAreFaces = false;
 
template <class T>
inline constexpr bool primitivesAreFaces<FlatMeshSDF<T>> = true;
 
template <class T, size_t K>
inline constexpr bool primitivesAreFaces<MeshSDF<T, K>> = true;
 
template <class T, size_t K, size_t W>
inline constexpr bool primitivesAreFaces<TriMeshSDF<T, K, W>> = true;
 
enum class ColorBy : uint8_t
{
  Uniform,   
  Primitive, 
  Normal     
};
 
enum class View : uint8_t
{
  Front,  
  Back,   
  Right,  
  Left,   
  Top,    
  Bottom, 
  Default 
};
 
template <class T>
struct Camera
{
  Vec3T<T> m_target = Vec3T<T>::zeros();
 
  T m_yaw = T(35);
 
  T m_pitch = T(25);
 
  T m_distance = T(4);
 
  T m_fieldOfView = T(40);
 
  Vec3T<T> m_up = Vec3T<T>(T(0), T(1), T(0));
 
  bool m_orthographic = false;
 
  T m_nearClip = T(0);
 
  [[nodiscard]] EBGEOMETRY_HOST
  static inline Camera
  fit(const BoundingVolumes::AABBT<T>& a_box, const Vec3T<T>& a_up = Vec3T<T>(T(0), T(1), T(0)));
 
  [[nodiscard]] EBGEOMETRY_HOST
  static inline Camera
  fit(const BoundingVolumes::AABBT<T>& a_box, View a_view, const Vec3T<T>& a_up = Vec3T<T>(T(0), T(1), T(0)));
 
  [[nodiscard]] EBGEOMETRY_HOST
  static inline Camera
  lookAt(const Vec3T<T>& a_eye,
         const Vec3T<T>& a_target,
         const Vec3T<T>& a_up          = Vec3T<T>(T(0), T(1), T(0)),
         const T         a_fieldOfView = T(40));
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline Vec3T<T>
  eye() const noexcept;
 
  EBGEOMETRY_HOST_DEVICE
  inline void
  frame(Vec3T<T>& a_forward, Vec3T<T>& a_right, Vec3T<T>& a_up) const noexcept;
 
  EBGEOMETRY_HOST_DEVICE
  inline void
  horizontal(Vec3T<T>& a_first, Vec3T<T>& a_second) const noexcept;
};
 
template <class T>
struct Settings
{
  uint32_t m_width = 960;
 
  uint32_t m_height = 960;
 
  uint32_t m_supersampling = 2;
 
  uint32_t m_threads = 0;
 
  bool m_shadows = true;
 
  bool m_occlusion = true;
 
  bool m_floor = true;
 
  bool m_sky = true;
 
  ColorBy m_colorBy = ColorBy::Normal;
 
  Vec3T<T> m_color = Vec3T<T>(T(0.80), T(0.42), T(0.18));
 
  static constexpr uint32_t PrimitiveColors = 16;
 
  Array<Vec3T<T>, PrimitiveColors> m_primitiveColors = unsetColors();
 
  bool m_recordPrimitives = false;
 
  static constexpr uint32_t NoPrimitive = 0xFFFFFFFFU;
 
  static constexpr uint32_t AllPrimitives = 0xFFFFFFFEU;
 
  uint32_t m_highlightPrimitive = NoPrimitive;
 
  Vec3T<T> m_highlightColor = Vec3T<T>(T(1.0), T(0.72), T(0.10));
 
  Vec3T<T> m_insideColor = Vec3T<T>(T(0.90), T(0.08), T(0.08));
 
  Vec3T<T> m_cutColor = Vec3T<T>(T(0.95), T(0.86), T(0.50));
 
  T m_cutOpacity = T(0.6);
 
  Vec3T<T> m_floorColor = Vec3T<T>(T(0.58), T(0.59), T(0.61));
 
  bool m_lightFromCamera = true;
 
  Vec3T<T> m_light = Vec3T<T>(T(-0.45), T(0.75), T(0.55));
 
  T m_lightIntensity = T(1.05);
 
  T m_ambient = T(0.35);
 
  T m_specular = T(0.45);
 
  T m_shininess = T(32);
 
  Vec3T<T> m_skyHorizon = Vec3T<T>(T(0.82), T(0.84), T(0.88));
 
  Vec3T<T> m_skyZenith = Vec3T<T>(T(0.32), T(0.45), T(0.66));
 
  Vec3T<T> m_background = Vec3T<T>(T(0.16), T(0.17), T(0.19));
 
  bool m_floorChecker = true;
 
  T m_floorCheckerSize = T(0);
 
  bool m_section = false;
 
  Vec3T<T> m_sectionPoint = Vec3T<T>::zeros();
 
  Vec3T<T> m_sectionNormal = Vec3T<T>(T(0), T(0), T(1));
 
  T m_contourWidth = T(2);
 
  Vec3T<T> m_contourColor = Vec3T<T>(T(0.04), T(0.04), T(0.05));
 
  T m_isoSpacing = T(0);
 
  Vec3T<T> m_isoColor = Vec3T<T>(T(0.30), T(0.32), T(0.36));
 
  T m_sheetOpacity = T(0.35);
 
  Vec3T<T> m_sheetColor = Vec3T<T>(T(0.95), T(0.96), T(0.97));
 
  Vec3T<T> m_sheetEdgeColor = Vec3T<T>(T(0.45), T(0.47), T(0.50));
 
  RayOptions<T> m_rays;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  static inline Array<Vec3T<T>, PrimitiveColors>
  unsetColors() noexcept;
};
 
template <class T>
[[nodiscard]] EBGEOMETRY_HOST
inline std::string
toCode(const Camera<T>& a_camera, const Settings<T>& a_settings);
 
struct Image
{
  uint32_t m_width = 0;
 
  uint32_t m_height = 0;
 
  std::vector<uint32_t> m_pixels;
 
  std::vector<uint32_t> m_primitives;
 
  [[nodiscard]] inline uint32_t
  at(const uint32_t a_column, const uint32_t a_row) const noexcept;
};
 
[[nodiscard]] inline bool
writeImage(const Image& a_image, const std::string& a_filename);
 
struct Stats
{
  uint64_t m_rays = 0;
 
  uint64_t m_hits = 0;
 
  uint64_t m_insideHits = 0;
 
  uint64_t m_unresolved = 0;
 
  bool m_cameraInside = false;
 
  bool m_complete = true;
};
 
struct PixelResult
{
  uint32_t m_rgba = 0;
 
  uint8_t m_hits = 0;
 
  uint8_t m_insideHits = 0;
 
  uint8_t m_unresolved = 0;
 
  uint8_t m_cameraInside = 0;
 
  uint32_t m_primitive = 0xFFFFFFFFU;
};
 
namespace RenderDetail {
 
struct StoredPixel
{
  uint32_t m_rgba = 0;
 
  uint8_t m_hits = 0;
 
  uint8_t m_insideHits = 0;
 
  uint8_t m_unresolved = 0;
 
  uint8_t m_cameraInside = 0;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  static inline StoredPixel
  of(const PixelResult& a_result) noexcept
  {
    return StoredPixel{
      a_result.m_rgba, a_result.m_hits, a_result.m_insideHits, a_result.m_unresolved, a_result.m_cameraInside};
  }
};
 
template <class T>
struct CameraView
{
  Vec3T<T> m_eye;
 
  Vec3T<T> m_forward;
 
  Vec3T<T> m_right;
 
  Vec3T<T> m_up;
 
  Vec3T<T> m_axis;
 
  Vec3T<T> m_first;
 
  Vec3T<T> m_second;
 
  T m_tanHalf;
 
  T m_distance;
 
  T m_footprint;
 
  T m_footprintPerLength;
 
  bool m_orthographic;
};
 
} // namespace RenderDetail
 
template <class T, class S>
struct PixelQuery
{
  S m_shape;
 
  Camera<T> m_camera;
 
  Settings<T> m_settings;
 
  RenderDetail::CameraView<T> m_view;
 
  EBGEOMETRY_HOST_DEVICE
  inline PixelQuery(const S& a_shape, const Camera<T>& a_camera, const Settings<T>& a_settings) noexcept;
 
  [[nodiscard]] EBGEOMETRY_HOST_DEVICE
  inline PixelResult
  operator()(const uint32_t& a_index) const noexcept;
};
 
template <class T>
class Renderer
{
public:
  explicit Renderer(const Settings<T>& a_settings = Settings<T>()) noexcept;
 
  [[nodiscard]] inline Settings<T>&
  settings() noexcept;
 
  [[nodiscard]] inline const Settings<T>&
  settings() const noexcept;
 
  template <class S>
  inline Stats
  render(const S& a_shape, const Camera<T>& a_camera, Image& a_image) const;
 
  template <class S>
  inline Stats
  render(const S&                 a_shape,
         const Camera<T>&         a_camera,
         Image&                   a_image,
         const std::atomic<bool>& a_cancel,
         std::atomic<uint32_t>*   a_rowsDone = nullptr) const;
 
  template <class S>
  inline Stats
  renderOnDevice(const S& a_deviceShape, const Camera<T>& a_camera, Image& a_image) const;
 
  template <class S>
  inline Stats
  renderOnDevice(const S&                 a_deviceShape,
                 const Camera<T>&         a_camera,
                 Image&                   a_image,
                 const std::atomic<bool>& a_cancel,
                 std::atomic<uint32_t>*   a_rowsDone = nullptr) const;
 
  template <class S>
  [[nodiscard]] inline HitT<T>
  pick(const S& a_shape, const Camera<T>& a_camera, T a_column, T a_row) const;
 
private:
  Settings<T> m_settings;
 
  inline void
  check(const Camera<T>& a_camera) const;
 
  inline Stats
  collect(const std::vector<RenderDetail::StoredPixel>& a_results,
          std::vector<uint32_t>&                        a_primitives,
          Image&                                        a_image) const;
};
 
} // namespace EBGeometry::Render
 
#include "EBGeometry_RenderImplem.hpp"
 
#endif