[reve] Add ability to sync, save, and restore REveCamera settings

builtins/rendercore/CMakeLists.txt

@@ -1,7 +1,7 @@
 ExternalProject_Add(
   RENDERCORE
-  URL ${CMAKE_SOURCE_DIR}/builtins/rendercore/RenderCore-2.0.tar.gz
-  URL_HASH SHA256=6bdcf70fbdec1f950057ab1df722775c468ad6894f8a364f15f589d58c326667
+  URL ${CMAKE_SOURCE_DIR}/builtins/rendercore/RenderCore-2.1.tar.gz
+  URL_HASH SHA256=fee8250baf8e5e1946170dd91e312d2f4a86f8dedd7f8c4e744c6671587114ab
   CONFIGURE_COMMAND ""
   BUILD_COMMAND ""
   INSTALL_COMMAND ""

graf3d/eve7/CMakeLists.txt

@@ -63,6 +63,7 @@ ROOT_STANDARD_LIBRARY_PACKAGE(ROOTEve
     ROOT/REveUtil.hxx
     ROOT/REveVector.hxx
     ROOT/REveViewer.hxx
+    ROOT/REveCamera.hxx
     ROOT/REveViewContext.hxx
     ROOT/REveVSD.hxx
     ROOT/REveVSDStructs.hxx
@@ -126,6 +127,7 @@ ROOT_STANDARD_LIBRARY_PACKAGE(ROOTEve
     src/REveUtil.cxx
     src/REveVector.cxx
     src/REveViewer.cxx
+    src/REveCamera.cxx
     src/REveVSD.cxx
     src/REveVSDStructs.cxx
   DEPENDENCIES

graf3d/eve7/inc/LinkDef.h

@@ -250,4 +250,8 @@
 // Tables
 #pragma link C++ class ROOT::Experimental::REveTableViewInfo;
 
+// Camera
+#pragma link C++ class ROOT::Experimental::REveCamera+;
+#pragma link C++ enum ROOT::Experimental::REveCamera::ECameraType;
+
 #endif

graf3d/eve7/inc/ROOT/REveCamera.hxx

@@ -0,0 +1,95 @@
+// @(#)root/eve7:$Id$
+// Authors: Yuxiao Wang, 2025
+
+/*************************************************************************
+ * Copyright (C) 1995-2019, Rene Brun and Fons Rademakers.               *
+ * All rights reserved.                                                  *
+ *                                                                       *
+ * For the licensing terms see $ROOTSYS/LICENSE.                         *
+ * For the list of contributors see $ROOTSYS/README/CREDITS.             *
+ *************************************************************************/
+
+#ifndef ROOT7_REveCamera
+#define ROOT7_REveCamera
+
+#include <ROOT/REveElement.hxx>
+#include <ROOT/REveVector.hxx>
+#include <ROOT/REveTrans.hxx>
+
+#include <string>
+
+namespace ROOT {
+namespace Experimental {
+
+class REveCamera : public REveElement
+{
+public:
+   enum ECameraType {
+      // Perspective
+      kCameraPerspXOZ,  // XOZ floor
+      kCameraPerspYOZ,  // YOZ floor
+      kCameraPerspXOY,  // XOY floor
+      // Orthographic
+      kCameraOrthoXOY,  // Looking down Z axis, X horz, Y vert
+      kCameraOrthoXOZ,  // Looking along Y axis, X horz, Z vert
+      kCameraOrthoZOY,  // Looking along X axis, Z horz, Y vert
+      kCameraOrthoZOX,  // Looking along Y axis, Z horz, X vert
+      // Orthographic negative
+      kCameraOrthoXnOY, // Looking along Z axis, -X horz, Y vert
+      kCameraOrthoXnOZ, // Looking down Y axis, -X horz, Z vert
+      kCameraOrthoZnOY, // Looking down X axis, -Z horz, Y vert
+      kCameraOrthoZnOX  // Looking down Y axis, -Z horz, X vert
+   };
+
+private:
+   ECameraType fType;
+   std::string fName;
+
+   // Camera transformation matrices
+   REveTrans   fCamBase;   // Base camera matrix (main positioning)
+   REveTrans   fCamTrans;
+   Bool_t      fInitialized{kFALSE};
+   float       fOrthoZoom{1.f};
+
+public:
+   REveCamera();
+   REveCamera(const std::string &name);
+   virtual ~REveCamera() {}
+
+   void Setup(ECameraType type, const std::string &name, const REveVector &v1, const REveVector &v2);
+
+   ECameraType GetType() const { return fType; }
+   const std::string &GetCameraName() const { return fName; }
+
+   // Camera matrix accessors
+   REveTrans &RefCamBase() { return fCamBase; }
+   const REveTrans &GetCamBase() const { return fCamBase; }
+
+   REveTrans &RefCamTrans() { return fCamTrans; }
+   const REveTrans &GetCamTrans() const { return fCamTrans; }
+
+   void SetCamBase(const REveTrans &base) { fCamBase = base; StampObjProps(); }
+
+   // receive mtx from client
+   void SetCamBaseMtx(const std::vector<Double_t> &arr);
+   void SetCamBaseMtx(const std::string &json_str);
+
+   void SetCamTransMtx(const std::vector<Double_t> &arr);
+   void SetCamTransMtxStr(const char* json_str);
+
+   void SetOrthoZoom(float);
+
+   Bool_t IsInitialized() const { return fInitialized; }
+   void SetInitialized(Bool_t val) { fInitialized = val; }
+
+   void BuildRenderData() override{};
+
+   Int_t WriteCoreJson(nlohmann::json &j, Int_t rnr_offset) override;
+
+   ClassDef(REveCamera, 0);
+};
+
+} // namespace Experimental
+} // namespace ROOT
+
+#endif

graf3d/eve7/inc/ROOT/REveManager.hxx

@@ -15,7 +15,6 @@
 #include <ROOT/REveElement.hxx>
 #include <ROOT/REveSystem.hxx>
 #include <ROOT/RLogger.hxx>
-
 #include <ROOT/RWebDisplayArgs.hxx>
 
 #include "TSysEvtHandler.h"
@@ -127,6 +126,7 @@ protected:
 
    REveViewerList           *fViewers{nullptr};
    REveSceneList            *fScenes{nullptr};
+   REveElement              *fCameras{nullptr}; 
 
    REveScene                *fGlobalScene{nullptr};
    REveScene                *fEventScene{nullptr};
@@ -182,6 +182,7 @@ public:
 
    REveSceneList  *GetScenes()  const { return fScenes;  }
    REveViewerList *GetViewers() const { return fViewers; }
+   REveElement    *GetCameras() const { return fCameras; }
 
    REveScene *GetGlobalScene() const { return fGlobalScene; }
    REveScene *GetEventScene()  const { return fEventScene;  }

graf3d/eve7/inc/ROOT/REveViewer.hxx

@@ -13,6 +13,7 @@
 #define ROOT7_REveViewer
 
 #include <ROOT/REveElement.hxx>
+#include <ROOT/REveCamera.hxx> 
 
 namespace ROOT {
 namespace Experimental {
@@ -27,60 +28,46 @@ class REveScene;
 class REveViewer : public REveElement
 {
 public:
-   enum ECameraType
-   {
-      // Perspective
-      kCameraPerspXOZ,  // XOZ floor
-      kCameraPerspYOZ,  // YOZ floor
-      kCameraPerspXOY,  // XOY floor
-      // Orthographic
-      kCameraOrthoXOY,  // Looking down  Z axis,  X horz, Y vert
-      kCameraOrthoXOZ,  // Looking along Y axis,  X horz, Z vert
-      kCameraOrthoZOY,  // Looking along X axis,  Z horz, Y vert
-      kCameraOrthoZOX,  // Looking along Y axis,  Z horz, X vert
-      // nOrthographic
-      kCameraOrthoXnOY, // Looking along Z axis, -X horz, Y vert
-      kCameraOrthoXnOZ, // Looking down  Y axis, -X horz, Z vert
-      kCameraOrthoZnOY, // Looking down  X axis, -Z horz, Y vert
-      kCameraOrthoZnOX  // Looking down  Y axis, -Z horz, X vert
-   };
+   // set alias instead
+   using ECameraType = REveCamera::ECameraType;
+
+   // backward compatibility
+   static constexpr ECameraType kCameraPerspXOZ   = REveCamera::kCameraPerspXOZ;
+   static constexpr ECameraType kCameraPerspYOZ   = REveCamera::kCameraPerspYOZ;
+   static constexpr ECameraType kCameraPerspXOY   = REveCamera::kCameraPerspXOY;
+   static constexpr ECameraType kCameraOrthoXOY   = REveCamera::kCameraOrthoXOY;
+   static constexpr ECameraType kCameraOrthoXOZ   = REveCamera::kCameraOrthoXOZ;
+   static constexpr ECameraType kCameraOrthoZOY   = REveCamera::kCameraOrthoZOY;
+   static constexpr ECameraType kCameraOrthoZOX   = REveCamera::kCameraOrthoZOX;
+   static constexpr ECameraType kCameraOrthoXnOY  = REveCamera::kCameraOrthoXnOY;
+   static constexpr ECameraType kCameraOrthoXnOZ  = REveCamera::kCameraOrthoXnOZ;
+   static constexpr ECameraType kCameraOrthoZnOY  = REveCamera::kCameraOrthoZnOY;
+   static constexpr ECameraType kCameraOrthoZnOX  = REveCamera::kCameraOrthoZnOX;
 
    enum EAxesType {
       kAxesNone,
       kAxesOrigin,
       kAxesEdge
    };
 
-   // For the moment REveCamera is internal class
-   class REveCamera
-   {
-      ECameraType fType;
-      std::string fName;
-      REveVector fV2;
-      REveVector fV1;
-
-      public:
-       REveCamera() { Setup(kCameraPerspXOZ, "PerspXOZ", REveVector(-1.0, 0.0, 0.0), REveVector(0.0, 1.0, 0.0));}
-       ~REveCamera() {}
-
-       void Setup(ECameraType type, const std::string& name, REveVector v1, REveVector v2);
-
-       ECameraType GetType() const { return fType; }
-
-       int WriteCoreJson(nlohmann::json &j, Int_t /*rnr_offset*/);
-   };
-
 private:
    REveViewer(const REveViewer&) = delete;
    REveViewer& operator=(const REveViewer&) = delete;
 
-   REveCamera fCamera;
+   REveCamera* fCamera{0};
+
    EAxesType fAxesType{kAxesNone};
    bool      fBlackBackground{false};
 
    bool fMandatory{true};
    std::string fPostStreamFlag;
 
+   std::vector<REveCamera*> fCameraList;
+
+   ROOT::Experimental::REveCamera* CreateCamera(ECameraType type);
+
+   bool fSyncCamera{true};
+
 public:
    REveViewer(const std::string &n="REveViewer", const std::string &t="");
    ~REveViewer() override;
@@ -90,8 +77,14 @@ public:
    virtual void AddScene(REveScene* scene);
    // XXX Missing RemoveScene() ????
 
-   void SetCameraType(ECameraType t);
-   ECameraType GetCameraType() const { return fCamera.GetType(); }
+   // Camera setters
+   void SetCamera(ROOT::Experimental::REveCamera *cam);
+   REveCamera* GetCamera() const { return fCamera;}
+   void SetCameraByElementId(ElementId_t cameraId); // set camera via ElementID
+   void SetCameraType(REveCamera::ECameraType type);
+
+   void SyncCamera(bool s) {fSyncCamera = s;}
+   bool GetSyncCamera() const {return fSyncCamera;}
 
    void SetAxesType(int);
    void SetBlackBackground(bool);

graf3d/eve7/src/REveCamera.cxx

@@ -0,0 +1,135 @@
+// @(#)root/eve7:$Id$
+// Authors: Matevz Tadel & Alja Mrak-Tadel: 2006, 2007, 2018
+
+/*************************************************************************
+ * Copyright (C) 1995-2019, Rene Brun and Fons Rademakers.               *
+ * All rights reserved.                                                  *
+ *                                                                       *
+ * For the licensing terms see $ROOTSYS/LICENSE.                         *
+ * For the list of contributors see $ROOTSYS/README/CREDITS.             *
+ *************************************************************************/
+
+#include <ROOT/REveCamera.hxx>
+#include <ROOT/REveManager.hxx>
+
+#include <nlohmann/json.hpp>
+#include <iostream>
+
+using namespace ROOT::Experimental;
+
+////////////////////////////////////////////////////////////////////////////////
+/// Default constructor
+
+REveCamera::REveCamera() : REveElement("REveCamera")
+{
+   Setup(kCameraPerspXOZ, "PerspXOZ", REveVector(-1.0, 0.0, 0.0), REveVector(0.0, 1.0, 0.0));
+   fCamBase.UnitTrans();
+   fCamTrans.UnitTrans();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/// Constructor with name
+
+REveCamera::REveCamera(const std::string &name) : REveElement(name)
+{
+   Setup(kCameraPerspXOZ, name, REveVector(-1.0, 0.0, 0.0), REveVector(0.0, 1.0, 0.0));
+   fCamBase.UnitTrans();
+   fCamTrans.UnitTrans();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/// Setup camera with type, name, direction and up vectors
+
+void REveCamera::Setup(ECameraType type, const std::string &name, const REveVector &hAxis, const REveVector &vAxis)
+{
+   fType = type;
+   fName = name;
+
+   // Set up base camera matrix from direction and up vectors
+   fCamBase.UnitTrans();
+   fCamTrans.UnitTrans();
+
+   fCamBase.SetBaseVec(1, hAxis.fX, hAxis.fY, hAxis.fZ);
+	fCamBase.SetBaseVec(3, vAxis.fX, vAxis.fY, vAxis.fZ);
+
+   REveVector y = vAxis.Cross(hAxis);
+   fCamBase.SetBaseVec(2, y.fX, y.fY, y.fZ);
+
+   StampObjProps();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/// Set camera base matrix from array (called from client via MIR)
+
+void REveCamera::SetCamBaseMtx(const std::vector<Double_t> &arr)
+{
+   if (arr.size() == 16) {
+      fCamBase.SetFromArray(arr.data());
+      StampObjProps();
+   }
+}
+
+void REveCamera::SetCamBaseMtx(const std::string &json_str)
+{
+   auto j = nlohmann::json::parse(json_str);
+   std::vector<Double_t> arr = j.get<std::vector<Double_t>>();
+   SetCamBaseMtx(arr);
+}
+
+void REveCamera::SetCamTransMtx(const std::vector<Double_t> &arr)
+{
+   if (arr.size() == 16) {
+      fCamTrans.SetFromArray(arr.data());
+      fInitialized = kTRUE;
+   }
+}
+
+// Set translation matrix with an array of 17 floats
+// The first 16 floats are 4x4 matrix element
+// The 17th value is setting the zoom value in orthographic type
+void REveCamera::SetCamTransMtxStr(const char *ins)
+{
+   std::stringstream ss(ins);
+   std::vector<double> arr;
+   std::string item;
+   while (std::getline(ss, item, ',')) {
+      arr.push_back(std::stod(item));
+   }
+
+   fOrthoZoom = arr.back();
+   arr.pop_back();
+   fCamTrans.SetFromArray(arr.data());
+
+   fInitialized = true;
+
+   StampObjProps();
+   SetCamTransMtx(arr);
+}
+
+void REveCamera::SetOrthoZoom(float zoom)
+{
+   fOrthoZoom = zoom;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+/// Write core JSON for camera
+
+Int_t REveCamera::WriteCoreJson(nlohmann::json &j, Int_t rnr_offset)
+{
+   Int_t ret = REveElement::WriteCoreJson(j, rnr_offset);
+
+   j["fType"] = fType;
+   j["fName"] = fName;
+   j["fInitialized"] = fInitialized;  // Stream to client
+
+   // Stream both matrices
+   // Client will read these as fMatrix arrays (16 elements each)
+   const Double_t *camBaseArr = fCamBase.Array();
+   j["camBase"] = std::vector<Double_t>(camBaseArr, camBaseArr + 16);
+
+   const Double_t *camTransArr = fCamTrans.Array();
+   j["camTrans"] = std::vector<Double_t>(camTransArr, camTransArr + 16);
+   j["fZoom"] = fOrthoZoom;
+
+   return ret;
+}