viz.hpp

Go to the documentation of this file.

// Copyright (c) 2026 Capgemini Engineering Research and Development.
//
// This file is part of OCCT-Light software library.
//
// This library is free software; you can redistribute it and/or modify it under
// the terms of the GNU Affero General Public License version 3 as published
// by the Free Software Foundation, with an option to use any later version.
// Consult the file LICENSE_AGPL_30.txt included in OCCT-Light distribution
// for complete text of the license and disclaimer of any warranty.
//
// Alternatively, this file may be used under the terms of a commercial
// license or contractual agreement.
//
// SPDX-License-Identifier: AGPL-3.0-or-later
 
#ifndef OCCTL_HPP_VIZ_HPP
#define OCCTL_HPP_VIZ_HPP
 
#include <occtl/occtl_viz.h>
 
#include <occtl-hpp/core.hpp>
#include <occtl-hpp/topo.hpp>
 
#include <cstddef>
#include <cstdint>
#include <string>
#include <vector>
 
namespace occtl::viz
{
 
enum class DisplayMode
{
  Wireframe       = OCCTL_VIZ_DISPLAY_WIREFRAME,
  Shaded          = OCCTL_VIZ_DISPLAY_SHADED,
  ShadedWithEdges = OCCTL_VIZ_DISPLAY_SHADED_WITH_EDGES,
  MeshDebug       = OCCTL_VIZ_DISPLAY_MESH_DEBUG
};
 
enum class SelectionMode
{
  Whole     = OCCTL_VIZ_SELECT_WHOLE,
  Face      = OCCTL_VIZ_SELECT_FACE,
  Edge      = OCCTL_VIZ_SELECT_EDGE,
  Vertex    = OCCTL_VIZ_SELECT_VERTEX,
  Wire      = OCCTL_VIZ_SELECT_WIRE,
  Shell     = OCCTL_VIZ_SELECT_SHELL,
  Solid     = OCCTL_VIZ_SELECT_SOLID,
  CoEdge    = OCCTL_VIZ_SELECT_COEDGE,
  Product   = OCCTL_VIZ_SELECT_PRODUCT,
  Compound  = OCCTL_VIZ_SELECT_COMPOUND,
  CompSolid = OCCTL_VIZ_SELECT_COMPSOLID
};
 
enum class StandardView
{
  Front  = OCCTL_VIZ_VIEW_FRONT,
  Back   = OCCTL_VIZ_VIEW_BACK,
  Left   = OCCTL_VIZ_VIEW_LEFT,
  Right  = OCCTL_VIZ_VIEW_RIGHT,
  Top    = OCCTL_VIZ_VIEW_TOP,
  Bottom = OCCTL_VIZ_VIEW_BOTTOM,
  Iso    = OCCTL_VIZ_VIEW_ISO
};
 
struct DriverOptions
{
  bool enable_vbo   = true; 
  bool enable_vsync = true; 
 
  [[nodiscard]] ::occtl_viz_driver_options_t to_c() const noexcept
  {
    ::occtl_viz_driver_options_t anOptions = OCCTL_VIZ_DRIVER_OPTIONS_INIT;
    anOptions.enable_vbo                   = enable_vbo ? 1 : 0;
    anOptions.enable_vsync                 = enable_vsync ? 1 : 0;
    return anOptions;
  }
};
 
struct ViewOptions
{
  int   width         = 640;     
  int   height        = 480;     
  void* native_handle = nullptr; 
  bool  offscreen     = true;    
 
  [[nodiscard]] ::occtl_viz_view_options_t to_c() const noexcept
  {
    ::occtl_viz_view_options_t anOptions = OCCTL_VIZ_VIEW_OPTIONS_INIT;
    anOptions.width                      = width;
    anOptions.height                     = height;
    anOptions.native_handle              = native_handle;
    anOptions.offscreen                  = offscreen ? 1 : 0;
    return anOptions;
  }
};
 
struct Camera
{
  Point3  eye;    
  Point3  center; 
  Vector3 up;     
 
  [[nodiscard]] ::occtl_viz_camera_t to_c() const noexcept
  {
    ::occtl_viz_camera_t aCamera;
    aCamera.eye    = eye.c_type();
    aCamera.center = center.c_type();
    aCamera.up     = up.c_type();
    return aCamera;
  }
 
  static Camera from_c(const ::occtl_viz_camera_t& theC) noexcept
  {
    return Camera{Point3(theC.eye), Point3(theC.center), Vector3(theC.up)};
  }
};
 
struct PickResult
{
  UID           uid;             
  NodeId        node;            
  RefId         ref;             
  SelectionMode selection_mode;  
  Transform     usage_transform; 
 
  static PickResult from_c(const ::occtl_viz_pick_result_t& theC) noexcept
  {
    PickResult aResult;
    aResult.uid             = UID(theC.uid);
    aResult.node            = NodeId(theC.node);
    aResult.ref             = RefId(theC.ref);
    aResult.selection_mode  = static_cast<SelectionMode>(theC.selection_mode);
    aResult.usage_transform = Transform(theC.usage_transform);
    return aResult;
  }
};
 
class Driver
{
public:
  explicit Driver(const DriverOptions& theOptions = DriverOptions{})
  {
    ::occtl_viz_driver_options_t anOptions = theOptions.to_c();
    check(::occtl_viz_driver_create(&anOptions, &myHandle));
  }
 
  ~Driver() noexcept { ::occtl_viz_driver_free(myHandle); }
 
  Driver(const Driver&)            = delete;
  Driver& operator=(const Driver&) = delete;
 
  Driver(Driver&& theOther) noexcept
      : myHandle(theOther.myHandle)
  {
    theOther.myHandle = nullptr;
  }
 
  Driver& operator=(Driver&& theOther) noexcept
  {
    if (this != &theOther)
    {
      ::occtl_viz_driver_free(myHandle);
      myHandle          = theOther.myHandle;
      theOther.myHandle = nullptr;
    }
    return *this;
  }
 
  ::occtl_viz_driver_t* get() const noexcept { return myHandle; }
 
private:
  ::occtl_viz_driver_t* myHandle = nullptr;
};
 
class Viewer
{
public:
  explicit Viewer(Driver& theDriver)
  {
    check(::occtl_viz_viewer_create(theDriver.get(), &myHandle));
  }
 
  ~Viewer() noexcept { ::occtl_viz_viewer_free(myHandle); }
 
  Viewer(const Viewer&)            = delete;
  Viewer& operator=(const Viewer&) = delete;
 
  Viewer(Viewer&& theOther) noexcept
      : myHandle(theOther.myHandle)
  {
    theOther.myHandle = nullptr;
  }
 
  Viewer& operator=(Viewer&& theOther) noexcept
  {
    if (this != &theOther)
    {
      ::occtl_viz_viewer_free(myHandle);
      myHandle          = theOther.myHandle;
      theOther.myHandle = nullptr;
    }
    return *this;
  }
 
  ::occtl_viz_viewer_t* get() const noexcept { return myHandle; }
 
private:
  ::occtl_viz_viewer_t* myHandle = nullptr;
};
 
class Presentable
{
public:
  Presentable(Viewer& theViewer, Graph& theGraph, const NodeId theRoot)
  {
    check(
      ::occtl_viz_presentable_create(theViewer.get(), theGraph.get(), theRoot.get(), &myHandle));
  }
 
  ~Presentable() noexcept { ::occtl_viz_presentable_free(myHandle); }
 
  Presentable(const Presentable&)            = delete;
  Presentable& operator=(const Presentable&) = delete;
 
  Presentable(Presentable&& theOther) noexcept
      : myHandle(theOther.myHandle)
  {
    theOther.myHandle = nullptr;
  }
 
  Presentable& operator=(Presentable&& theOther) noexcept
  {
    if (this != &theOther)
    {
      ::occtl_viz_presentable_free(myHandle);
      myHandle          = theOther.myHandle;
      theOther.myHandle = nullptr;
    }
    return *this;
  }
 
  void set_display_mode(const DisplayMode theMode)
  {
    check(
      ::occtl_viz_presentable_set_display_mode(myHandle,
                                               static_cast<::occtl_viz_display_mode_t>(theMode)));
  }
 
  bool synchronize()
  {
    int32_t aChanged = 0;
    check(::occtl_viz_presentable_synchronize(myHandle, &aChanged));
    return aChanged != 0;
  }
 
  void invalidate() { check(::occtl_viz_presentable_invalidate(myHandle)); }
 
  void set_visible_nodes(const std::vector<NodeId>& theNodes)
  {
    std::vector<::occtl_node_id_t> aIds;
    aIds.reserve(theNodes.size());
    for (const NodeId& aNode : theNodes)
      aIds.push_back(aNode.get());
    check(::occtl_viz_presentable_set_visible_nodes(myHandle, aIds.data(), aIds.size()));
  }
 
  void clear_visible_nodes() { check(::occtl_viz_presentable_clear_visible_nodes(myHandle)); }
 
  ::occtl_viz_presentable_t* get() const noexcept { return myHandle; }
 
private:
  ::occtl_viz_presentable_t* myHandle = nullptr;
};
 
class View
{
public:
  explicit View(Viewer& theViewer, const ViewOptions& theOptions = ViewOptions{})
  {
    ::occtl_viz_view_options_t anOptions = theOptions.to_c();
    check(::occtl_viz_view_create(theViewer.get(), &anOptions, &myHandle));
  }
 
  ~View() noexcept { ::occtl_viz_view_free(myHandle); }
 
  View(const View&)            = delete;
  View& operator=(const View&) = delete;
 
  View(View&& theOther) noexcept
      : myHandle(theOther.myHandle)
  {
    theOther.myHandle = nullptr;
  }
 
  View& operator=(View&& theOther) noexcept
  {
    if (this != &theOther)
    {
      ::occtl_viz_view_free(myHandle);
      myHandle          = theOther.myHandle;
      theOther.myHandle = nullptr;
    }
    return *this;
  }
 
  void display(Presentable& thePresentable)
  {
    check(::occtl_viz_view_display(myHandle, thePresentable.get()));
  }
 
  void erase(Presentable& thePresentable)
  {
    check(::occtl_viz_view_erase(myHandle, thePresentable.get()));
  }
 
  void resize(const int32_t theWidth, const int32_t theHeight)
  {
    check(::occtl_viz_view_resize(myHandle, theWidth, theHeight));
  }
 
  void redraw() { check(::occtl_viz_view_redraw(myHandle)); }
 
  void fit_all() { check(::occtl_viz_view_fit_all(myHandle)); }
 
  void set_background(const ::occtl_color_rgba_t& theColor)
  {
    check(::occtl_viz_view_set_background(myHandle, theColor));
  }
 
  void set_camera(const Camera& theCamera)
  {
    ::occtl_viz_camera_t aCamera = theCamera.to_c();
    check(::occtl_viz_view_set_camera(myHandle, &aCamera));
  }
 
  [[nodiscard]] Camera get_camera() const
  {
    ::occtl_viz_camera_t aCamera{};
    check(::occtl_viz_view_get_camera(myHandle, &aCamera));
    return Camera::from_c(aCamera);
  }
 
  void set_standard_view(const StandardView theView)
  {
    check(::occtl_viz_view_set_standard_view(myHandle,
                                             static_cast<::occtl_viz_standard_view_t>(theView)));
  }
 
  void pan(const int32_t theDx, const int32_t theDy)
  {
    check(::occtl_viz_view_pan(myHandle, theDx, theDy));
  }
 
  void zoom(const int32_t theX1, const int32_t theY1, const int32_t theX2, const int32_t theY2)
  {
    check(::occtl_viz_view_zoom(myHandle, theX1, theY1, theX2, theY2));
  }
 
  void orbit_start(const int32_t theX, const int32_t theY)
  {
    check(::occtl_viz_view_orbit_start(myHandle, theX, theY));
  }
 
  void orbit_update(const int32_t theX, const int32_t theY)
  {
    check(::occtl_viz_view_orbit_update(myHandle, theX, theY));
  }
 
  void activate_selection(Presentable& thePresentable, const SelectionMode theMode)
  {
    check(::occtl_viz_view_activate_selection(myHandle,
                                              thePresentable.get(),
                                              static_cast<::occtl_viz_selection_mode_t>(theMode)));
  }
 
  void pick(const int32_t theX, const int32_t theY, const bool theSelect, PickResult& theResult)
  {
    ::occtl_viz_pick_result_t aRaw = OCCTL_VIZ_PICK_RESULT_INIT;
    check(::occtl_viz_view_pick(myHandle, theX, theY, theSelect ? 1 : 0, &aRaw));
    theResult = PickResult::from_c(aRaw);
  }
 
  [[nodiscard]] std::vector<std::uint8_t> read_pixels_rgba()
  {
    size_t aCount = 0;
    check(::occtl_viz_view_read_pixels_rgba(myHandle, nullptr, 0, &aCount));
    std::vector<std::uint8_t> aPixels(aCount);
    check(::occtl_viz_view_read_pixels_rgba(myHandle, aPixels.data(), aPixels.size(), &aCount));
    return aPixels;
  }
 
  void dump_image(const std::string& thePath)
  {
    check(::occtl_viz_view_dump_image(myHandle, thePath.c_str()));
  }
 
  ::occtl_viz_view_t* get() const noexcept { return myHandle; }
 
private:
  ::occtl_viz_view_t* myHandle = nullptr;
};
 
} // namespace occtl::viz
 
#endif // OCCTL_HPP_VIZ_HPP