improve scene mode

Author: FreddyFunk

.github/workflows/ci.yml

@@ -70,7 +70,9 @@ jobs:
             libxkbcommon-dev \
             libinput-dev \
             libudev-dev \
-            libseat-dev
+            libseat-dev \
+            libclang-dev \
+            libusb-1.0-0-dev
 
       - name: Install just
         uses: extractions/setup-just@v3
@@ -147,7 +149,9 @@ jobs:
             libxkbcommon-dev \
             libinput-dev \
             libudev-dev \
-            libseat-dev
+            libseat-dev \
+            libclang-dev \
+            libusb-1.0-0-dev
 
       - name: Install cross
         if: ${{ matrix.use_cross }}
@@ -161,7 +165,7 @@ jobs:
           if [ "${{ matrix.use_cross }}" = "true" ]; then
             cross build --target ${{ matrix.target }}
           else
-            just build-debug --target ${{ matrix.target }}
+            cargo build --target ${{ matrix.target }}
           fi
 
   flatpak-x86_64:

Cargo.toml

@@ -7,6 +7,12 @@ description = "Camera application for the COSMIC™ desktop"
 repository = "https://github.com/cosmic-utils/camera"
 authors = ["Frederic Laing <frederic.laing.development@gmail.com>"]
 
+[features]
+default = ["freedepth"]
+# freedepth userspace library for Kinect depth cameras (fallback when kernel driver unavailable)
+# Only works on x86_64 due to libclang/bindgen requirements
+freedepth = ["dep:freedepth"]
+
 [dependencies]
 futures = "0.3.31"
 i18n-embed = { version = "0.16.0", features = [
@@ -41,9 +47,13 @@ libc = "0.2.178"
 dng = "1.5"
 async-stream = "0.3"
 v4l = "0.14"
-freedepth = { git = "https://github.com/FreddyFunk/freedepth", rev = "aab2bbcc9c1c196751d8eb37a9b704e9b75683cb" }  # Multi-device depth camera library
 las = { version = "0.9", features = ["laz"] }  # LAZ point cloud export
 
+# freedepth is only available on x86_64 (requires libclang for v4l2-sys-mit bindgen)
+# Enabled via the "freedepth" feature flag (on by default)
+[target.'cfg(target_arch = "x86_64")'.dependencies]
+freedepth = { git = "https://github.com/FreddyFunk/freedepth", rev = "aab2bbcc9c1c196751d8eb37a9b704e9b75683cb", optional = true }  # Multi-device depth camera library
+
 # Separate wgpu for compute pipelines (independent from libcosmic's wgpu for UI)
 # This allows us to use the latest wgpu features like open_with_callback for low-priority queues
 [dependencies.wgpu-compute]

src/app/handlers/camera.rs

@@ -585,6 +585,26 @@ impl AppModel {
         // Get scene view mode (point cloud vs mesh)
         let scene_view_mode = self.preview_3d.view_mode;
 
+        // Get filter mode for scene rendering
+        use crate::app::state::FilterType;
+        let filter_mode = match self.selected_filter {
+            FilterType::Standard => 0u32,
+            FilterType::Mono => 1,
+            FilterType::Sepia => 2,
+            FilterType::Noir => 3,
+            FilterType::Vivid => 4,
+            FilterType::Cool => 5,
+            FilterType::Warm => 6,
+            FilterType::Fade => 7,
+            FilterType::Duotone => 8,
+            FilterType::Vignette => 9,
+            FilterType::Negative => 10,
+            FilterType::Posterize => 11,
+            FilterType::Solarize => 12,
+            FilterType::ChromaticAberration => 13,
+            FilterType::Pencil => 14,
+        };
+
         info!(
             depth_format = ?depth_format,
             mirror,
@@ -594,6 +614,7 @@ impl AppModel {
             ?sensor_type,
             showing_depth_colormap,
             ?scene_view_mode,
+            filter_mode,
             "Rendering 3D scene"
         );
 
@@ -616,6 +637,7 @@ impl AppModel {
                         depth_format,
                         mirror,
                         apply_rgb_registration,
+                        filter_mode,
                     )
                     .await
                     .map(|r| (r.width, r.height, r.rgba)),
@@ -638,6 +660,7 @@ impl AppModel {
                             mirror,
                             apply_rgb_registration,
                             DEPTH_DISCONTINUITY_THRESHOLD,
+                            filter_mode,
                         )
                         .await
                         .map(|r| (r.width, r.height, r.rgba))

src/app/handlers/capture.rs

@@ -668,7 +668,6 @@ impl AppModel {
                                 registration_table: shader_reg.registration_table,
                                 depth_to_rgb_shift: shader_reg.depth_to_rgb_shift,
                                 target_offset: shader_reg.target_offset,
-                                reg_x_val_scale: 256, // Standard Kinect scale factor
                                 reg_scale_x,
                                 reg_scale_y,
                                 reg_y_offset,

src/app/handlers/depth_camera.rs

@@ -5,21 +5,32 @@
 //! Handles depth camera device control including motor tilt, native streaming,
 //! 3D preview frame polling, depth visualization settings, and calibration dialogs.
 //! LED is automatically managed by freedepth based on device state.
+//!
+//! When freedepth is not available (non-x86_64 or feature disabled), stub
+//! implementations are provided that return Task::none().
 
-use crate::app::state::{AppModel, Message, SceneViewMode};
+#[cfg(all(target_arch = "x86_64", feature = "freedepth"))]
 use crate::backends::camera::{NativeDepthBackend, depth_device_index, rgb_to_rgba};
-use cosmic::Task;
+#[cfg(all(target_arch = "x86_64", feature = "freedepth"))]
 use freedepth::{DepthRegistration, TILT_MAX_DEGREES, TILT_MIN_DEGREES};
+#[cfg(all(target_arch = "x86_64", feature = "freedepth"))]
 use std::time::{Duration, Instant};
+#[cfg(all(target_arch = "x86_64", feature = "freedepth"))]
 use tracing::{debug, info, warn};
 
+use crate::app::state::{AppModel, Message};
+#[cfg(all(target_arch = "x86_64", feature = "freedepth"))]
+use crate::app::state::SceneViewMode;
+use cosmic::Task;
+
 /// Set up GPU shader registration data from device calibration
 ///
 /// This spawns an async task to update the point cloud and mesh processors
 /// with the device-specific registration tables. Call this after the native
 /// depth backend is initialized.
 ///
 /// Uses the generic DepthRegistration trait for device-agnostic access.
+#[cfg(all(target_arch = "x86_64", feature = "freedepth"))]
 pub fn setup_shader_registration_data(registration: &dyn DepthRegistration) {
     let reg_data = crate::shaders::RegistrationData {
         registration_table: registration.registration_table_flat().to_vec(),
@@ -41,6 +52,8 @@ pub fn setup_shader_registration_data(registration: &dyn DepthRegistration) {
     });
 }
 
+// Full implementation when freedepth is available
+#[cfg(all(target_arch = "x86_64", feature = "freedepth"))]
 impl AppModel {
     /// Handle setting depth camera tilt angle (desired state)
     ///
@@ -58,7 +71,7 @@ impl AppModel {
         self.kinect.tilt_angle = degrees;
 
         // Send command to motor via global motor control
-        use crate::backends::camera::depth_controller::set_motor_tilt;
+        use crate::backends::camera::motor_control::set_motor_tilt;
         if let Err(e) = set_motor_tilt(degrees) {
             tracing::warn!("Failed to set depth camera tilt: {}", e);
         }
@@ -150,7 +163,6 @@ impl AppModel {
                             registration_table: registration.registration_table_flat().to_vec(),
                             depth_to_rgb_shift: registration.depth_to_rgb_shift_table().to_vec(),
                             target_offset: registration.target_offset(),
-                            reg_x_val_scale: 256,
                             reg_scale_x: 1.0,
                             reg_scale_y: 1.0,
                             reg_y_offset: 0,
@@ -207,7 +219,7 @@ impl AppModel {
                 video_frame_is_new =
                     self.preview_3d.last_render_video_timestamp != Some(video_frame.timestamp);
 
-                let rgba_data = rgb_to_rgba(&video_frame.rgb_data);
+                let rgba_data = rgb_to_rgba(&video_frame.data);
 
                 use crate::backends::camera::types::{CameraFrame, PixelFormat};
                 let frame = CameraFrame {
@@ -470,3 +482,88 @@ impl AppModel {
         self.handle_request_point_cloud_render()
     }
 }
+
+// Stub implementations when freedepth is disabled
+#[cfg(not(all(target_arch = "x86_64", feature = "freedepth")))]
+impl AppModel {
+    pub(crate) fn handle_set_kinect_tilt(&mut self, _degrees: i8) -> Task<cosmic::Action<Message>> {
+        Task::none()
+    }
+
+    pub(crate) fn update_kinect_state(&mut self) -> Task<cosmic::Action<Message>> {
+        self.kinect.is_device = false;
+        Task::none()
+    }
+
+    pub(crate) fn is_current_camera_depth_sensor(&self) -> bool {
+        false
+    }
+
+    pub(crate) fn handle_start_native_kinect_streaming(&mut self) -> Task<cosmic::Action<Message>> {
+        Task::none()
+    }
+
+    pub(crate) fn handle_stop_native_kinect_streaming(&mut self) -> Task<cosmic::Action<Message>> {
+        Task::none()
+    }
+
+    pub(crate) fn handle_poll_native_kinect_frames(&mut self) -> Task<cosmic::Action<Message>> {
+        Task::none()
+    }
+
+    pub(crate) fn handle_toggle_depth_overlay(&mut self) -> Task<cosmic::Action<Message>> {
+        Task::none()
+    }
+
+    pub(crate) fn handle_toggle_depth_grayscale(&mut self) -> Task<cosmic::Action<Message>> {
+        Task::none()
+    }
+
+    pub(crate) fn handle_show_calibration_dialog(&mut self) -> Task<cosmic::Action<Message>> {
+        Task::none()
+    }
+
+    pub(crate) fn handle_close_calibration_dialog(&mut self) -> Task<cosmic::Action<Message>> {
+        Task::none()
+    }
+
+    pub(crate) fn handle_start_calibration(&mut self) -> Task<cosmic::Action<Message>> {
+        Task::none()
+    }
+
+    pub(crate) fn handle_toggle_3d_preview(&mut self) -> Task<cosmic::Action<Message>> {
+        Task::none()
+    }
+
+    pub(crate) fn handle_toggle_scene_view_mode(&mut self) -> Task<cosmic::Action<Message>> {
+        Task::none()
+    }
+
+    pub(crate) fn handle_preview_3d_mouse_pressed(
+        &mut self,
+        _x: f32,
+        _y: f32,
+    ) -> Task<cosmic::Action<Message>> {
+        Task::none()
+    }
+
+    pub(crate) fn handle_preview_3d_mouse_moved(
+        &mut self,
+        _x: f32,
+        _y: f32,
+    ) -> Task<cosmic::Action<Message>> {
+        Task::none()
+    }
+
+    pub(crate) fn handle_preview_3d_mouse_released(&mut self) -> Task<cosmic::Action<Message>> {
+        Task::none()
+    }
+
+    pub(crate) fn handle_reset_3d_preview_rotation(&mut self) -> Task<cosmic::Action<Message>> {
+        Task::none()
+    }
+
+    pub(crate) fn handle_zoom_3d_preview(&mut self, _delta: f32) -> Task<cosmic::Action<Message>> {
+        Task::none()
+    }
+}