Fixed global transparent effect with depth alpha.

src/codec/mesh_encoder.cpp

@@ -30,7 +30,7 @@ struct mesh_encoder::impl {
     data_type encode(const mesh_ptr &mesh) {
         // handle no transfer situation
         if (auto no_transfer_any = mesh->get_meta_any(META_MESH_NO_TRANSFER);
-                boost::any_cast<bool>(no_transfer_any)) {
+                !no_transfer_any.empty() && boost::any_cast<bool>(no_transfer_any)) {
             auto name = mesh->get_meta_ext<size_t>(META_SERIES_NAME);
             auto writer = network_writer();
             writer << FLAG_NO_TRANSFER << name;

src/impl/apps/depth_guide_v2/depth_guide_v2.cpp

@@ -58,9 +58,8 @@ app_depth_guide_v2::app_depth_guide_v2(const create_config &_conf) {
     aug_manager = std::make_unique<augment_manager_v2>(aug_conf);
 
     auto view_conf = camera_augment_helper_v2::create_config{
-            .camera = camera_augment_helper_v2::create_config::fixed_camera_config{
-                    .fov = 54.75355, .transform_var = LOAD_STR("camera_transform_var")},
-//            .camera = camera_augment_helper_v2::create_config::freedom_camera_config{},
+            .camera = camera_augment_helper_v2::create_config::freedom_camera_config{
+                    .transform_var = LOAD_STR("camera_transform_var")},
             .sophiar_conn= sophiar_conn.get(),
             .manager = aug_manager.get(),
             .ctx = main_conf.asio_ctx,

src/module/camera_augment_helper_v2.h

@@ -28,6 +28,7 @@ public:
         };
 
         struct freedom_camera_config {
+            std::string transform_var; // for sophiar
         };
 
         using camera_config_type = std::variant<std::monostate,

src/module/impl/augment_manager_v2.cpp

@@ -133,6 +133,8 @@ void augment_manager_v2::impl::show() {
     }
     for (auto &item: item_list) {
         if (ImGui::TreeNode(item.disp_name.c_str())) {
+            auto tree_close = sg::make_scope_guard([] { ImGui::TreePop(); });
+
             ImGui::Checkbox("Visibility", &item.visible);
             if (!item.visible) continue;
 
@@ -158,8 +160,6 @@ void augment_manager_v2::impl::show() {
                 ImGui::DragFloat("Point Size", &item.point_size, ps_interval,
                                  ps_range.min, ps_range.max, "%.01f");
             }
-
-            ImGui::TreePop();
         }
     }
     if (ImGui::TreeNode("Light")) {

src/module/impl/camera_augment_helper_v2.cpp

@@ -6,18 +6,34 @@
 #include <glm/gtc/type_ptr.hpp>
 #include <glm/gtx/rotate_vector.hpp>
 
+#include <glm/gtx/string_cast.hpp>
+
 #include <boost/asio/post.hpp>
 
 #include <vtkSphereSource.h>
 
 using boost::asio::post;
 
+void camera_augment_helper_v2::impl::freedom_info_type::reset() {
+    if (auto &mat = pimpl->tracked_transform; mat.has_value()) {
+        static constexpr auto default_focal_length = 8.0f; // 8mm
+        eye = glm::vec3((*mat)[3]);
+        auto rot_part = glm::mat3(*mat);
+        center = eye + rot_part[2] * default_focal_length;
+        view_up = -rot_part[1];
+    } else {
+        eye = glm::vec3();
+        center = glm::vec3(0.f, 0.f, 100.f);
+        view_up = glm::vec3(0.0f, -1.0f, 0.0f);
+    }
+}
+
 glm::mat4 camera_augment_helper_v2::impl::freedom_info_type::to_transform() {
     // normalize view up
     view_up -= view_dir() * glm::dot(view_up, view_dir());
     view_up = glm::normalize(view_up);
 
-    auto ret = glm::lookAt(eye, center, view_up);
+    auto ret = glm::inverse(glm::lookAt(eye, center, view_up));
     ret = glm::rotate(ret, glm::radians(180.0f), glm::vec3(1.0f, 0.0f, 0.0f)); // viewport -> camera
     return ret;
 }
@@ -84,13 +100,16 @@ camera_augment_helper_v2::impl::impl(const create_config &conf) {
     switch (conf.camera.index()) {
         case 1: {
             mode = MODE_FREEDOM;
+            auto info = std::get<1>(conf.camera);
+            transform_var = info.transform_var;
+            freedom_info.pimpl = this;
             break;
         }
         case 2: {
             mode = MODE_FIXED;
             auto info = std::get<2>(conf.camera);
             fov = info.fov;
-            fixed_info.transform_var = info.transform_var;
+            transform_var = info.transform_var;
             break;
         }
         case 3: {
@@ -111,18 +130,30 @@ camera_augment_helper_v2::impl::~impl() {
     pre_render_conn.disconnect();
 }
 
+void camera_augment_helper_v2::impl::update_tracked_transform() {
+    if (sophiar_conn == nullptr) return;
+    auto trans = sophiar_conn->
+            query_transform_variable(transform_var);
+    is_missing = !trans.has_value();
+    if (trans.has_value()) {
+        tracked_transform = to_mat4(*trans);
+    } else {
+        tracked_transform = {};
+    }
+}
+
 void camera_augment_helper_v2::impl::update_freedom() {
+    update_tracked_transform();
     transform = freedom_info.to_transform();
     is_missing = false;
 }
 
 void camera_augment_helper_v2::impl::update_fixed() {
     assert(sophiar_conn != nullptr);
-    auto trans = sophiar_conn->
-            query_transform_variable(fixed_info.transform_var);
-    is_missing = !trans.has_value();
-    if (trans.has_value()) {
-        transform = to_mat4(*trans) * fixed_info.extra_transform();
+    update_tracked_transform();
+    if (tracked_transform.has_value()) {
+        auto extra_mat = fixed_info.extra_transform();
+        transform = *tracked_transform * extra_mat;
     }
 }
 
@@ -178,6 +209,10 @@ void camera_augment_helper_v2::impl::render_image(output_config conf) {
 void camera_augment_helper_v2::impl::show_freedom() {
     auto &info = freedom_info;
 
+    if (ImGui::Button("Reset")) {
+        freedom_info.reset();
+    }
+
     if (ImGui::TreeNode("Center")) {
         if (ImGui::Button("X+")) { info.move_right(info.linear_speed); }
         ImGui::SameLine();

src/module/impl/camera_augment_helper_v2_impl.h

@@ -6,6 +6,8 @@
 
 struct camera_augment_helper_v2::impl {
 
+    std::string transform_var; // sophiar
+    std::optional<glm::mat4> tracked_transform; // transform matrix from sophiar
     bool is_missing = false;
     bool ignore_missing = false;
 
@@ -24,7 +26,6 @@ struct camera_augment_helper_v2::impl {
     struct fixed_info_type {
         glm::vec3 extra_offset = glm::vec3();
         glm::vec3 extra_rotation = glm::vec3();
-        std::string transform_var; // sophiar
 
         glm::mat4 extra_transform() const;
 
@@ -32,11 +33,15 @@ struct camera_augment_helper_v2::impl {
 
     struct freedom_info_type {
         glm::vec3 eye = glm::vec3();
-        glm::vec3 center = glm::vec3(0.0f, 0.0f, 100.0f);
+        glm::vec3 center = glm::vec3(0.0f, 0.0f, 100.0f); // focus
         glm::vec3 view_up = glm::vec3(0.0f, -1.0f, 0.0f);
 
-        float angle_speed = 1.0f; // degree
-        float linear_speed = 0.1f; // mm
+        float angle_speed = 5.0f; // degree
+        float linear_speed = 20.0f; // mm
+
+        impl *pimpl = nullptr;
+
+        void reset();
 
         glm::vec3 view_dir() const;
 
@@ -95,6 +100,8 @@ struct camera_augment_helper_v2::impl {
 
     ~impl();
 
+    void update_tracked_transform();
+
     void update_freedom();
 
     void update_fixed();

src/render/impl/render_mesh.cpp

@@ -263,6 +263,7 @@ namespace render_mesh_impl {
         auto tex_info = tex_render_info();
         tex_info.mode = TEX_COLOR_DEPTH;
         tex_info.color.id = mesh_fbo.color_tex[0].id;
+        tex_info.color.alpha = extra.alpha;
         tex_info.depth.id = mesh_fbo.depth_tex.id;
         tex_info.depth.enable_alpha_effect = true;
         auto &tex_extra = tex_info.extra.color_depth;

src/render/impl/render_scene.cpp

@@ -49,6 +49,7 @@ namespace render_scene_impl {
             auto &extra = ren_conf.extra.depth_alpha;
             extra.bg_tex = scene_fbo.depth_tex.id;
             extra.alpha_factor = info.alpha_factor;
+            extra.alpha = req.item.alpha;
         }
 
         render_mesh(ren_conf);

src/render/render_mesh.h

@@ -102,6 +102,7 @@ struct mesh_render_info {
             mesh_info_type bg; // if nullptr, bg_tex should be provided.
             GLuint bg_tex = 0; // background depth texture
             float alpha_factor;
+            float alpha;
             bool show_bg;
         } depth_alpha;
     } extra = {};