gpu_volume_render/

volume_render.rs

//! 3D Volume Rendering Module
//!
//! Implements GPU-accelerated volume rendering techniques:
//! - MIP (Maximum Intensity Projection)
//! - AIP (Average Intensity Projection)
//! - MinIP (Minimum Intensity Projection)
//! - DVR (Direct Volume Rendering) with transfer functions

use std::sync::Arc;
use tracing::{debug, info};
use wgpu::{
    BindGroupDescriptor, BindGroupEntry, BindGroupLayout, BindGroupLayoutDescriptor,
    BindGroupLayoutEntry, BindingType, Buffer, BufferBindingType, BufferDescriptor, BufferUsages,
    ComputePipeline, ComputePipelineDescriptor, Device, PipelineLayoutDescriptor, Queue,
    ShaderModuleDescriptor, ShaderSource, ShaderStages,
};

use crate::gpu_executor::GpuVolume;
use crate::mpr_ops::MprError;

/// Rendering mode for volume visualization
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum RenderMode {
    /// Maximum Intensity Projection - shows brightest voxel along ray
    MIP,
    /// Average Intensity Projection - shows average of voxels along ray
    AIP,
    /// Minimum Intensity Projection - shows darkest voxel along ray
    MinIP,
    /// Direct Volume Rendering with transfer function
    DVR,
    /// DVR without shading (faster)
    DVRNoShading,
}

/// Transfer function preset for medical imaging
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TransferFunctionPreset {
    /// Bone visualization - high HU values in white/yellow
    Bone,
    /// Soft tissue - muscle, organs
    SoftTissue,
    /// Blood vessels - contrast enhanced angiography
    Vessel,
    /// Lung/Airways - low HU values for airways
    Lung,
    /// Skin surface rendering
    Skin,
    /// Custom - uses provided transfer function
    Custom,
}

/// Single entry in transfer function (RGBA, values 0-1)
#[repr(C)]
#[derive(Debug, Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]
pub struct TransferFunctionEntry {
    pub r: f32,
    pub g: f32,
    pub b: f32,
    pub a: f32,
}

impl TransferFunctionEntry {
    pub fn new(r: f32, g: f32, b: f32, a: f32) -> Self {
        Self { r, g, b, a }
    }

    pub fn transparent() -> Self {
        Self::new(0.0, 0.0, 0.0, 0.0)
    }
}

/// Transfer function for DVR
#[derive(Debug, Clone)]
pub struct TransferFunction {
    /// LUT entries
    pub entries: Vec<TransferFunctionEntry>,
    /// HU range minimum
    pub min_hu: f32,
    /// HU range maximum
    pub max_hu: f32,
}

impl TransferFunction {
    /// Create transfer function with given range
    pub fn new(min_hu: f32, max_hu: f32, size: usize) -> Self {
        Self {
            entries: vec![TransferFunctionEntry::transparent(); size],
            min_hu,
            max_hu,
        }
    }

    /// Get preset transfer function
    pub fn from_preset(preset: TransferFunctionPreset) -> Self {
        match preset {
            TransferFunctionPreset::Bone => Self::bone_preset(),
            TransferFunctionPreset::SoftTissue => Self::soft_tissue_preset(),
            TransferFunctionPreset::Vessel => Self::vessel_preset(),
            TransferFunctionPreset::Lung => Self::lung_preset(),
            TransferFunctionPreset::Skin => Self::skin_preset(),
            TransferFunctionPreset::Custom => Self::new(-1000.0, 3000.0, 256),
        }
    }

    /// Bone visualization preset (HU: 200-2000+)
    pub fn bone_preset() -> Self {
        let mut tf = Self::new(-200.0, 2000.0, 256);
        let range = tf.max_hu - tf.min_hu;

        for (i, entry) in tf.entries.iter_mut().enumerate() {
            let t = i as f32 / 255.0;
            let hu = tf.min_hu + t * range;

            if hu < 150.0 {
                // Below bone threshold - transparent
                *entry = TransferFunctionEntry::transparent();
            } else if hu < 300.0 {
                // Transition zone (cartilage)
                let alpha = (hu - 150.0) / 150.0;
                *entry = TransferFunctionEntry::new(
                    0.9,           // Light gray
                    0.85,
                    0.75,
                    alpha * 0.3,   // Low opacity
                );
            } else if hu < 700.0 {
                // Trabecular bone
                let t_bone = (hu - 300.0) / 400.0;
                *entry = TransferFunctionEntry::new(
                    0.95 - t_bone * 0.1,    // Cream to white
                    0.9 - t_bone * 0.15,
                    0.75 - t_bone * 0.2,
                    0.4 + t_bone * 0.3,     // Medium opacity
                );
            } else {
                // Cortical bone (dense)
                let t_dense = ((hu - 700.0) / 1300.0).min(1.0);
                *entry = TransferFunctionEntry::new(
                    1.0,                      // Pure white
                    1.0 - t_dense * 0.1,
                    0.95 - t_dense * 0.2,
                    0.7 + t_dense * 0.3,     // High opacity
                );
            }
        }

        tf
    }

    /// Soft tissue preset (HU: -100 to 200)
    pub fn soft_tissue_preset() -> Self {
        let mut tf = Self::new(-200.0, 400.0, 256);
        let range = tf.max_hu - tf.min_hu;

        for (i, entry) in tf.entries.iter_mut().enumerate() {
            let t = i as f32 / 255.0;
            let hu = tf.min_hu + t * range;

            if hu < -100.0 {
                // Air/fat - nearly transparent
                *entry = TransferFunctionEntry::transparent();
            } else if hu < 0.0 {
                // Fat tissue - yellowish, low opacity
                let alpha = (hu + 100.0) / 100.0;
                *entry = TransferFunctionEntry::new(
                    1.0,
                    0.85,
                    0.4,
                    alpha * 0.15,
                );
            } else if hu < 50.0 {
                // Water/fluid - bluish
                let t_water = hu / 50.0;
                *entry = TransferFunctionEntry::new(
                    0.5 + t_water * 0.3,
                    0.6 + t_water * 0.2,
                    0.9,
                    0.2,
                );
            } else if hu < 100.0 {
                // Muscle - reddish/brownish
                let t_muscle = (hu - 50.0) / 50.0;
                *entry = TransferFunctionEntry::new(
                    0.8 + t_muscle * 0.15,   // Red
                    0.45 - t_muscle * 0.1,   // Less green
                    0.4 - t_muscle * 0.1,    // Less blue
                    0.25 + t_muscle * 0.1,
                );
            } else {
                // Dense tissue - lighter
                let t_dense = ((hu - 100.0) / 300.0).min(1.0);
                *entry = TransferFunctionEntry::new(
                    0.9 + t_dense * 0.1,
                    0.7 + t_dense * 0.2,
                    0.65 + t_dense * 0.2,
                    0.35 + t_dense * 0.2,
                );
            }
        }

        tf
    }

    /// Blood vessel preset (contrast enhanced, HU: 100-400)
    pub fn vessel_preset() -> Self {
        let mut tf = Self::new(-100.0, 500.0, 256);
        let range = tf.max_hu - tf.min_hu;

        for (i, entry) in tf.entries.iter_mut().enumerate() {
            let t = i as f32 / 255.0;
            let hu = tf.min_hu + t * range;

            if hu < 80.0 {
                // Below vessel threshold
                *entry = TransferFunctionEntry::transparent();
            } else if hu < 150.0 {
                // Transition
                let alpha = (hu - 80.0) / 70.0;
                *entry = TransferFunctionEntry::new(
                    0.9,
                    0.2,
                    0.2,
                    alpha * 0.3,
                );
            } else if hu < 300.0 {
                // Blood vessel (contrast)
                let t_vessel = (hu - 150.0) / 150.0;
                *entry = TransferFunctionEntry::new(
                    1.0,                     // Bright red
                    0.15 + t_vessel * 0.2,
                    0.1 + t_vessel * 0.15,
                    0.5 + t_vessel * 0.3,
                );
            } else {
                // High contrast region
                let t_high = ((hu - 300.0) / 200.0).min(1.0);
                *entry = TransferFunctionEntry::new(
                    1.0,
                    0.4 + t_high * 0.4,     // Toward yellow
                    0.25 + t_high * 0.3,
                    0.8 + t_high * 0.2,
                );
            }
        }

        tf
    }

    /// Lung/airways preset (HU: -1000 to -300)
    pub fn lung_preset() -> Self {
        let mut tf = Self::new(-1100.0, 0.0, 256);
        let range = tf.max_hu - tf.min_hu;

        for (i, entry) in tf.entries.iter_mut().enumerate() {
            let t = i as f32 / 255.0;
            let hu = tf.min_hu + t * range;

            if hu < -950.0 {
                // Outside body
                *entry = TransferFunctionEntry::transparent();
            } else if hu < -700.0 {
                // Lung parenchyma
                let t_lung = (hu + 950.0) / 250.0;
                *entry = TransferFunctionEntry::new(
                    0.3 + t_lung * 0.2,      // Blueish
                    0.4 + t_lung * 0.2,
                    0.7 + t_lung * 0.1,
                    0.05 + t_lung * 0.1,
                );
            } else if hu < -400.0 {
                // Lung vessels/structures
                let t_struct = (hu + 700.0) / 300.0;
                *entry = TransferFunctionEntry::new(
                    0.5 + t_struct * 0.3,
                    0.4 + t_struct * 0.2,
                    0.6 + t_struct * 0.1,
                    0.15 + t_struct * 0.15,
                );
            } else {
                // Bronchi walls / soft tissue
                let t_wall = ((hu + 400.0) / 400.0).min(1.0);
                *entry = TransferFunctionEntry::new(
                    0.8 + t_wall * 0.15,
                    0.6 + t_wall * 0.2,
                    0.5 + t_wall * 0.2,
                    0.3 + t_wall * 0.2,
                );
            }
        }

        tf
    }

    /// Skin surface preset (HU: -200 to 200)
    pub fn skin_preset() -> Self {
        let mut tf = Self::new(-500.0, 500.0, 256);
        let range = tf.max_hu - tf.min_hu;

        for (i, entry) in tf.entries.iter_mut().enumerate() {
            let t = i as f32 / 255.0;
            let hu = tf.min_hu + t * range;

            if hu < -200.0 {
                // Air - transparent
                *entry = TransferFunctionEntry::transparent();
            } else if hu < -50.0 {
                // Skin surface edge
                let alpha = (hu + 200.0) / 150.0;
                *entry = TransferFunctionEntry::new(
                    0.95,                    // Skin tone
                    0.75,
                    0.6,
                    alpha * 0.6,             // Sharp surface
                );
            } else if hu < 100.0 {
                // Below skin - make transparent for surface rendering
                *entry = TransferFunctionEntry::new(
                    0.9,
                    0.7,
                    0.55,
                    0.1,                     // Very low opacity for depth
                );
            } else {
                // Dense structures - transparent for pure skin rendering
                *entry = TransferFunctionEntry::transparent();
            }
        }

        tf
    }
}

/// Camera state for 3D rendering
#[derive(Debug, Clone, Copy)]
pub struct Camera {
    /// Camera position in volume coordinates
    pub position: [f32; 3],
    /// Look direction (normalized)
    pub look_dir: [f32; 3],
    /// Up vector (normalized)
    pub up: [f32; 3],
    /// Field of view in radians
    pub fov: f32,
}

impl Default for Camera {
    fn default() -> Self {
        Self {
            position: [0.0, 0.0, -500.0],
            look_dir: [0.0, 0.0, 1.0],
            up: [0.0, -1.0, 0.0],
            fov: std::f32::consts::PI / 4.0, // 45 degrees
        }
    }
}

impl Camera {
    /// Create camera looking at volume center from given angle
    pub fn orbit(center: [f32; 3], distance: f32, azimuth: f32, elevation: f32) -> Self {
        // Convert spherical to cartesian
        let cos_elev = elevation.cos();
        let sin_elev = elevation.sin();
        let cos_azim = azimuth.cos();
        let sin_azim = azimuth.sin();

        let position = [
            center[0] + distance * cos_elev * sin_azim,
            center[1] + distance * sin_elev,
            center[2] + distance * cos_elev * cos_azim,
        ];

        // Look direction is from camera to center
        let look_dir = [
            center[0] - position[0],
            center[1] - position[1],
            center[2] - position[2],
        ];
        let len = (look_dir[0].powi(2) + look_dir[1].powi(2) + look_dir[2].powi(2)).sqrt();
        let look_dir = [look_dir[0] / len, look_dir[1] / len, look_dir[2] / len];

        // Up vector (world Y up, adjusted for elevation)
        let up = [0.0, -1.0, 0.0];

        Self {
            position,
            look_dir,
            up,
            fov: std::f32::consts::PI / 4.0,
        }
    }
}

/// Parameters for MIP rendering (must match shader MipParams)
#[repr(C)]
#[derive(Debug, Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
struct MipUniforms {
    // Volume dimensions
    volume_width: u32,
    volume_height: u32,
    volume_depth: u32,

    // Output dimensions
    output_width: u32,
    output_height: u32,

    // Camera position
    camera_x: f32,
    camera_y: f32,
    camera_z: f32,

    // Camera look direction
    look_x: f32,
    look_y: f32,
    look_z: f32,

    // Camera up vector
    up_x: f32,
    up_y: f32,
    up_z: f32,

    // Field of view
    fov: f32,

    // Ray marching
    step_size: f32,
    max_steps: u32,

    // Window/level
    window_width: f32,
    window_center: f32,

    // Spacing
    spacing_x: f32,
    spacing_y: f32,
    spacing_z: f32,

    // Threshold
    threshold: f32,

    // Segmentation mask parameters (from Auto Clean)
    mask_enabled: u32,     // 0 = disabled, 1 = enabled
    visible_labels: u32,   // Bitmask of visible labels (bit N = label N visible)

    // Sculpt mask parameters (from Lasso Sculpt) - separate from segmentation
    sculpt_mask_enabled: u32,
    sculpt_visible_labels: u32,

    // Clipping plane parameters
    clip_enabled: u32,
    clip_inverted: u32,
    clip_normal_x: f32,
    clip_normal_y: f32,
    clip_normal_z: f32,
    clip_distance: f32,

    // Padding to align struct to 16 bytes (33 fields * 4 = 132, need 144)
    _pad1: u32,
    _pad2: u32,
    _pad3: u32,
}

/// Clipping plane configuration
#[derive(Debug, Clone, Copy, Default)]
pub struct ClipPlaneConfig {
    pub enabled: bool,
    pub inverted: bool,
    pub normal: [f32; 3],
    pub distance: f32,
}

/// 3D Box region clipping configuration (Sculpt Box)
///
/// Defines a 3D rectangular region for clipping. All values are in voxel coordinates.
/// When enabled, only voxels within (or outside if inverted) the box are rendered.
#[derive(Debug, Clone, Copy)]
pub struct ClipBoxConfig {
    pub enabled: bool,
    pub inverted: bool, // true = show inside box, false = hide inside box
    /// Min/max bounds for X axis (column index)
    pub x_min: f32,
    pub x_max: f32,
    /// Min/max bounds for Y axis (row index)
    pub y_min: f32,
    pub y_max: f32,
    /// Min/max bounds for Z axis (slice/depth index)
    pub z_min: f32,
    pub z_max: f32,
}

impl Default for ClipBoxConfig {
    fn default() -> Self {
        Self {
            enabled: false,
            inverted: false, // Default: hide inside box (remove region)
            x_min: 0.0,
            x_max: 1.0,
            y_min: 0.0,
            y_max: 1.0,
            z_min: 0.0,
            z_max: 1.0,
        }
    }
}

impl ClipBoxConfig {
    /// Create a box config from percentage values (0-100)
    #[allow(clippy::too_many_arguments)]
    pub fn from_percentages(
        x_min_pct: f32,
        x_max_pct: f32,
        y_min_pct: f32,
        y_max_pct: f32,
        z_min_pct: f32,
        z_max_pct: f32,
        dimensions: [usize; 3],
        inverted: bool,
    ) -> Self {
        let [depth, rows, cols] = dimensions;
        Self {
            enabled: true,
            inverted,
            x_min: (x_min_pct / 100.0) * cols as f32,
            x_max: (x_max_pct / 100.0) * cols as f32,
            y_min: (y_min_pct / 100.0) * rows as f32,
            y_max: (y_max_pct / 100.0) * rows as f32,
            z_min: (z_min_pct / 100.0) * depth as f32,
            z_max: (z_max_pct / 100.0) * depth as f32,
        }
    }
}

/// Slice plane navigation configuration (for MPR cross-section visualization)
#[derive(Debug, Clone, Copy)]
pub struct SlicePlaneConfig {
    /// Whether slice plane visualization is enabled
    pub enabled: bool,
    /// Axial (Z) slice position in voxels
    pub axial: f32,
    /// Sagittal (X) slice position in voxels
    pub sagittal: f32,
    /// Coronal (Y) slice position in voxels
    pub coronal: f32,
    /// Line thickness in voxels (default: 1.5)
    pub thickness: f32,
    /// Plane opacity (default: 0.6)
    pub opacity: f32,
}

impl Default for SlicePlaneConfig {
    fn default() -> Self {
        Self {
            enabled: false,
            axial: 0.0,
            sagittal: 0.0,
            coronal: 0.0,
            thickness: 1.5,
            opacity: 0.6,
        }
    }
}

impl SlicePlaneConfig {
    /// Create slice plane config with default visual settings
    pub fn new(axial: f32, sagittal: f32, coronal: f32) -> Self {
        Self {
            enabled: true,
            axial,
            sagittal,
            coronal,
            thickness: 1.5,
            opacity: 0.6,
        }
    }

    /// Create slice plane config from normalized positions (0.0-1.0) and volume dimensions
    pub fn from_normalized(
        axial_norm: f32,
        sagittal_norm: f32,
        coronal_norm: f32,
        dimensions: [usize; 3],
    ) -> Self {
        Self {
            enabled: true,
            axial: axial_norm * (dimensions[0] - 1) as f32,
            sagittal: sagittal_norm * (dimensions[2] - 1) as f32,
            coronal: coronal_norm * (dimensions[1] - 1) as f32,
            thickness: 1.5,
            opacity: 0.6,
        }
    }
}

/// DVR rendering options
#[derive(Debug, Clone, Copy)]
pub struct DvrOptions {
    pub clip_plane: ClipPlaneConfig,
    pub clip_box: ClipBoxConfig,
    pub opacity_multiplier: f32,
    pub light_direction: [f32; 3],
    pub slice_planes: SlicePlaneConfig,
    /// Ray marching step size (lower = higher quality, slower)
    /// Default: 0.5 (half voxel steps)
    /// Range: 0.25 (ultra) to 2.0 (draft)
    pub step_size: f32,
}

impl Default for DvrOptions {
    fn default() -> Self {
        Self {
            clip_plane: ClipPlaneConfig::default(),
            clip_box: ClipBoxConfig::default(),
            opacity_multiplier: 1.0,
            light_direction: [0.5, -0.7, -0.5],
            slice_planes: SlicePlaneConfig::default(),
            step_size: 0.5, // Default: high quality
        }
    }
}

/// Parameters for DVR rendering (must match shader DvrParams)
#[repr(C)]
#[derive(Debug, Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
struct DvrUniforms {
    // Volume dimensions
    volume_width: u32,
    volume_height: u32,
    volume_depth: u32,

    // Output dimensions
    output_width: u32,
    output_height: u32,

    // Camera position
    camera_x: f32,
    camera_y: f32,
    camera_z: f32,

    // Camera look direction
    look_x: f32,
    look_y: f32,
    look_z: f32,

    // Camera up vector
    up_x: f32,
    up_y: f32,
    up_z: f32,

    // Field of view
    fov: f32,

    // Ray marching
    step_size: f32,
    max_steps: u32,

    // Transfer function range
    tf_min: f32,
    tf_max: f32,
    tf_size: u32,

    // Spacing
    spacing_x: f32,
    spacing_y: f32,
    spacing_z: f32,

    // Lighting
    ambient: f32,
    diffuse: f32,
    specular: f32,
    shininess: f32,

    // Light direction
    light_x: f32,
    light_y: f32,
    light_z: f32,

    // Termination threshold
    opacity_threshold: f32,

    // Gradient threshold for shading
    gradient_threshold: f32,

    // Shading flag
    enable_shading: u32,

    // Clipping plane parameters
    clip_enabled: u32,
    clip_inverted: u32,
    clip_normal_x: f32,
    clip_normal_y: f32,
    clip_normal_z: f32,
    clip_distance: f32,

    // Global opacity multiplier
    opacity_multiplier: f32,

    // Segmentation mask parameters (from Auto Clean)
    mask_enabled: u32,     // 0 = disabled, 1 = enabled
    visible_labels: u32,   // Bitmask of visible labels (bit N = label N visible)

    // Sculpt mask parameters (from Lasso Sculpt) - separate from segmentation
    sculpt_mask_enabled: u32,
    sculpt_visible_labels: u32,

    // Slice plane navigation parameters
    slice_planes_enabled: u32,
    axial_slice: f32,
    sagittal_slice: f32,
    coronal_slice: f32,
    slice_plane_thickness: f32,
    slice_plane_opacity: f32,
    _padding2: u32,
    _padding3: u32,
}

/// Mask configuration for segmentation-based rendering
#[derive(Debug, Clone, Copy, Default)]
pub struct MaskConfig {
    /// Whether mask filtering is enabled
    pub enabled: bool,
    /// Bitmask of visible labels (bit N = label N is visible)
    /// Default: 0xFFFFFFFF (all labels visible)
    pub visible_labels: u32,
}

impl MaskConfig {
    /// Create mask config with all labels visible
    pub fn all_visible() -> Self {
        Self {
            enabled: true,
            visible_labels: 0xFFFFFFFF, // All 32 labels visible
        }
    }

    /// Create mask config showing only specific label
    pub fn only_label(label: u8) -> Self {
        Self {
            enabled: true,
            visible_labels: 1u32 << label,
        }
    }

    /// Create mask config hiding specific label
    pub fn hide_label(label: u8) -> Self {
        Self {
            enabled: true,
            visible_labels: !(1u32 << label),
        }
    }
}

/// Parameters for sculpt mask generation (must match shader SculptParams)
#[repr(C)]
#[derive(Debug, Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
pub struct SculptUniforms {
    // Volume dimensions
    pub volume_width: u32,
    pub volume_height: u32,
    pub volume_depth: u32,

    // Camera position
    pub cam_pos_x: f32,
    pub cam_pos_y: f32,
    pub cam_pos_z: f32,

    // Look direction (normalized)
    pub look_x: f32,
    pub look_y: f32,
    pub look_z: f32,

    // Right vector (normalized)
    pub right_x: f32,
    pub right_y: f32,
    pub right_z: f32,

    // Up vector (normalized)
    pub up_x: f32,
    pub up_y: f32,
    pub up_z: f32,

    // Projection parameters
    pub fov_half_tan: f32,

    // Aspect ratio (screen_width / screen_height) - CRITICAL for non-square viewports
    pub aspect_ratio: f32,

    // Polygon point count
    pub polygon_point_count: u32,

    // Action: 0 = remove_inside, 1 = keep_inside
    pub action: u32,

    // Polygon bounding box for early rejection
    pub poly_min_x: f32,
    pub poly_max_x: f32,
    pub poly_min_y: f32,
    pub poly_max_y: f32,

    // Voxel spacing in mm [x, y, z] — converts voxel indices to physical coordinates
    pub spacing_x: f32,
    pub spacing_y: f32,
    pub spacing_z: f32,

    // Padding to align to 16 bytes (struct total must be multiple of 16)
    pub _padding: f32,
}

/// GPU Volume Renderer
pub struct VolumeRenderer {
    device: Arc<Device>,
    queue: Arc<Queue>,

    // MIP pipeline and resources
    mip_pipeline: ComputePipeline,
    aip_pipeline: ComputePipeline,
    minip_pipeline: ComputePipeline,
    mip_bind_group_layout: BindGroupLayout,
    mip_uniform_buffer: Buffer,

    // DVR pipeline and resources
    dvr_pipeline: ComputePipeline,
    dvr_no_shading_pipeline: ComputePipeline,
    dvr_bind_group_layout: BindGroupLayout,
    dvr_uniform_buffer: Buffer,
    transfer_function_buffer: Buffer,

    // Sculpt mask pipeline and resources
    sculpt_pipeline: ComputePipeline,
    sculpt_bind_group_layout: BindGroupLayout,
    sculpt_uniform_buffer: Buffer,
    sculpt_polygon_buffer: Buffer,

    // Current transfer function
    current_transfer_function: TransferFunction,

    // Segmentation mask buffer (packed u8 labels in u32) - from Auto Clean
    mask_buffer: Option<Buffer>,
    mask_config: MaskConfig,

    // Sculpt mask buffer (separate from segmentation) - from Lasso Sculpt
    sculpt_mask_buffer: Option<Buffer>,
    sculpt_mask_config: MaskConfig,

    // Dummy mask buffer (used when no mask is available to avoid buffer conflicts)
    dummy_mask_buffer: Buffer,

    // Shared resources
    output_buffer: Buffer,
    staging_buffer: Buffer,

    // Output size
    output_width: u32,
    output_height: u32,
}

impl VolumeRenderer {
    const WORKGROUP_SIZE: u32 = 16;
    const TRANSFER_FUNCTION_SIZE: usize = 256;

    /// Create new volume renderer
    pub fn new(
        device: Arc<Device>,
        queue: Arc<Queue>,
        output_width: u32,
        output_height: u32,
    ) -> Result<Self, MprError> {
        let start = std::time::Instant::now();

        // Load MIP shader
        let mip_shader_source = include_str!("shaders/mip_raycaster.wgsl");
        let mip_shader_module = device.create_shader_module(ShaderModuleDescriptor {
            label: Some("mip_raycaster"),
            source: ShaderSource::Wgsl(mip_shader_source.into()),
        });

        // Load DVR shader
        let dvr_shader_source = include_str!("shaders/dvr_raycaster.wgsl");
        let dvr_shader_module = device.create_shader_module(ShaderModuleDescriptor {
            label: Some("dvr_raycaster"),
            source: ShaderSource::Wgsl(dvr_shader_source.into()),
        });

        // Create MIP bind group layout
        let mip_bind_group_layout = Self::create_mip_bind_group_layout(&device);

        // Create DVR bind group layout (includes transfer function)
        let dvr_bind_group_layout = Self::create_dvr_bind_group_layout(&device);

        // Create MIP pipelines
        let mip_pipeline_layout = device.create_pipeline_layout(&PipelineLayoutDescriptor {
            label: Some("mip_pipeline_layout"),
            bind_group_layouts: &[&mip_bind_group_layout],
            push_constant_ranges: &[],
        });

        let mip_pipeline = device.create_compute_pipeline(&ComputePipelineDescriptor {
            label: Some("mip_pipeline"),
            layout: Some(&mip_pipeline_layout),
            module: &mip_shader_module,
            entry_point: Some("main"),
            compilation_options: Default::default(),
            cache: None,
        });

        let aip_pipeline = device.create_compute_pipeline(&ComputePipelineDescriptor {
            label: Some("aip_pipeline"),
            layout: Some(&mip_pipeline_layout),
            module: &mip_shader_module,
            entry_point: Some("main_aip"),
            compilation_options: Default::default(),
            cache: None,
        });

        let minip_pipeline = device.create_compute_pipeline(&ComputePipelineDescriptor {
            label: Some("minip_pipeline"),
            layout: Some(&mip_pipeline_layout),
            module: &mip_shader_module,
            entry_point: Some("main_minip"),
            compilation_options: Default::default(),
            cache: None,
        });

        // Create DVR pipelines
        let dvr_pipeline_layout = device.create_pipeline_layout(&PipelineLayoutDescriptor {
            label: Some("dvr_pipeline_layout"),
            bind_group_layouts: &[&dvr_bind_group_layout],
            push_constant_ranges: &[],
        });

        let dvr_pipeline = device.create_compute_pipeline(&ComputePipelineDescriptor {
            label: Some("dvr_pipeline"),
            layout: Some(&dvr_pipeline_layout),
            module: &dvr_shader_module,
            entry_point: Some("main"),
            compilation_options: Default::default(),
            cache: None,
        });

        let dvr_no_shading_pipeline = device.create_compute_pipeline(&ComputePipelineDescriptor {
            label: Some("dvr_no_shading_pipeline"),
            layout: Some(&dvr_pipeline_layout),
            module: &dvr_shader_module,
            entry_point: Some("main_no_shading"),
            compilation_options: Default::default(),
            cache: None,
        });

        // Load Sculpt shader
        let sculpt_shader_source = include_str!("shaders/sculpt_mask.wgsl");
        let sculpt_shader_module = device.create_shader_module(ShaderModuleDescriptor {
            label: Some("sculpt_mask"),
            source: ShaderSource::Wgsl(sculpt_shader_source.into()),
        });

        // Create Sculpt bind group layout
        let sculpt_bind_group_layout = Self::create_sculpt_bind_group_layout(&device);

        // Create Sculpt pipeline
        let sculpt_pipeline_layout = device.create_pipeline_layout(&PipelineLayoutDescriptor {
            label: Some("sculpt_pipeline_layout"),
            bind_group_layouts: &[&sculpt_bind_group_layout],
            push_constant_ranges: &[],
        });

        let sculpt_pipeline = device.create_compute_pipeline(&ComputePipelineDescriptor {
            label: Some("sculpt_pipeline"),
            layout: Some(&sculpt_pipeline_layout),
            module: &sculpt_shader_module,
            entry_point: Some("main"),
            compilation_options: Default::default(),
            cache: None,
        });

        // Create MIP uniform buffer
        let mip_uniform_buffer = device.create_buffer(&BufferDescriptor {
            label: Some("mip_uniforms"),
            size: std::mem::size_of::<MipUniforms>() as u64,
            usage: BufferUsages::UNIFORM | BufferUsages::COPY_DST,
            mapped_at_creation: false,
        });

        // Create DVR uniform buffer
        let dvr_uniform_buffer = device.create_buffer(&BufferDescriptor {
            label: Some("dvr_uniforms"),
            size: std::mem::size_of::<DvrUniforms>() as u64,
            usage: BufferUsages::UNIFORM | BufferUsages::COPY_DST,
            mapped_at_creation: false,
        });

        // Create Sculpt uniform buffer
        let sculpt_uniform_buffer = device.create_buffer(&BufferDescriptor {
            label: Some("sculpt_uniforms"),
            size: std::mem::size_of::<SculptUniforms>() as u64,
            usage: BufferUsages::UNIFORM | BufferUsages::COPY_DST,
            mapped_at_creation: false,
        });

        // Create Sculpt polygon buffer (max 1024 points * 2 floats = 8KB)
        let sculpt_polygon_buffer = device.create_buffer(&BufferDescriptor {
            label: Some("sculpt_polygon"),
            size: (1024 * 2 * std::mem::size_of::<f32>()) as u64,
            usage: BufferUsages::STORAGE | BufferUsages::COPY_DST,
            mapped_at_creation: false,
        });

        // Create transfer function buffer (256 RGBA entries)
        let default_tf = TransferFunction::from_preset(TransferFunctionPreset::Bone);
        let transfer_function_buffer = device.create_buffer(&BufferDescriptor {
            label: Some("transfer_function"),
            size: (Self::TRANSFER_FUNCTION_SIZE * std::mem::size_of::<TransferFunctionEntry>()) as u64,
            usage: BufferUsages::STORAGE | BufferUsages::COPY_DST,
            mapped_at_creation: false,
        });

        // Upload default transfer function
        queue.write_buffer(
            &transfer_function_buffer,
            0,
            bytemuck::cast_slice(&default_tf.entries),
        );

        // Create output buffer
        let output_size = (output_width * output_height * 4) as u64; // RGBA u32
        let output_buffer = device.create_buffer(&BufferDescriptor {
            label: Some("volume_render_output"),
            size: output_size,
            usage: BufferUsages::STORAGE | BufferUsages::COPY_SRC,
            mapped_at_creation: false,
        });

        // Create staging buffer for readback
        let staging_buffer = device.create_buffer(&BufferDescriptor {
            label: Some("volume_render_staging"),
            size: output_size,
            usage: BufferUsages::MAP_READ | BufferUsages::COPY_DST,
            mapped_at_creation: false,
        });

        // Create dummy mask buffer (4 bytes minimum, used when no real mask)
        // This avoids buffer conflicts when mask_buffer is None
        let dummy_mask_buffer = device.create_buffer(&BufferDescriptor {
            label: Some("dummy_mask"),
            size: 4, // Minimum 1 u32
            usage: BufferUsages::STORAGE | BufferUsages::COPY_DST,
            mapped_at_creation: false,
        });

        info!(
            "Volume renderer created ({}x{}) with DVR and Sculpt support in {:.1}ms",
            output_width,
            output_height,
            start.elapsed().as_secs_f64() * 1000.0
        );

        Ok(Self {
            device,
            queue,
            mip_pipeline,
            aip_pipeline,
            minip_pipeline,
            mip_bind_group_layout,
            mip_uniform_buffer,
            dvr_pipeline,
            dvr_no_shading_pipeline,
            dvr_bind_group_layout,
            dvr_uniform_buffer,
            transfer_function_buffer,
            sculpt_pipeline,
            sculpt_bind_group_layout,
            sculpt_uniform_buffer,
            sculpt_polygon_buffer,
            current_transfer_function: default_tf,
            mask_buffer: None,
            mask_config: MaskConfig::default(),
            sculpt_mask_buffer: None,
            sculpt_mask_config: MaskConfig::default(),
            dummy_mask_buffer,
            output_buffer,
            staging_buffer,
            output_width,
            output_height,
        })
    }

    fn create_mip_bind_group_layout(device: &Device) -> BindGroupLayout {
        device.create_bind_group_layout(&BindGroupLayoutDescriptor {
            label: Some("mip_bind_group_layout"),
            entries: &[
                // binding 0: Volume data
                BindGroupLayoutEntry {
                    binding: 0,
                    visibility: ShaderStages::COMPUTE,
                    ty: BindingType::Buffer {
                        ty: BufferBindingType::Storage { read_only: true },
                        has_dynamic_offset: false,
                        min_binding_size: None,
                    },
                    count: None,
                },
                // binding 1: Uniforms
                BindGroupLayoutEntry {
                    binding: 1,
                    visibility: ShaderStages::COMPUTE,
                    ty: BindingType::Buffer {
                        ty: BufferBindingType::Uniform,
                        has_dynamic_offset: false,
                        min_binding_size: None,
                    },
                    count: None,
                },
                // binding 2: Output image
                BindGroupLayoutEntry {
                    binding: 2,
                    visibility: ShaderStages::COMPUTE,
                    ty: BindingType::Buffer {
                        ty: BufferBindingType::Storage { read_only: false },
                        has_dynamic_offset: false,
                        min_binding_size: None,
                    },
                    count: None,
                },
                // binding 3: Segmentation mask (packed u8 labels in u32) - from Auto Clean
                BindGroupLayoutEntry {
                    binding: 3,
                    visibility: ShaderStages::COMPUTE,
                    ty: BindingType::Buffer {
                        ty: BufferBindingType::Storage { read_only: true },
                        has_dynamic_offset: false,
                        min_binding_size: None,
                    },
                    count: None,
                },
                // binding 4: Sculpt mask (packed u8 labels in u32) - from Lasso Sculpt
                BindGroupLayoutEntry {
                    binding: 4,
                    visibility: ShaderStages::COMPUTE,
                    ty: BindingType::Buffer {
                        ty: BufferBindingType::Storage { read_only: true },
                        has_dynamic_offset: false,
                        min_binding_size: None,
                    },
                    count: None,
                },
            ],
        })
    }

    fn create_dvr_bind_group_layout(device: &Device) -> BindGroupLayout {
        device.create_bind_group_layout(&BindGroupLayoutDescriptor {
            label: Some("dvr_bind_group_layout"),
            entries: &[
                // binding 0: Volume data
                BindGroupLayoutEntry {
                    binding: 0,
                    visibility: ShaderStages::COMPUTE,
                    ty: BindingType::Buffer {
                        ty: BufferBindingType::Storage { read_only: true },
                        has_dynamic_offset: false,
                        min_binding_size: None,
                    },
                    count: None,
                },
                // binding 1: Uniforms
                BindGroupLayoutEntry {
                    binding: 1,
                    visibility: ShaderStages::COMPUTE,
                    ty: BindingType::Buffer {
                        ty: BufferBindingType::Uniform,
                        has_dynamic_offset: false,
                        min_binding_size: None,
                    },
                    count: None,
                },
                // binding 2: Output image
                BindGroupLayoutEntry {
                    binding: 2,
                    visibility: ShaderStages::COMPUTE,
                    ty: BindingType::Buffer {
                        ty: BufferBindingType::Storage { read_only: false },
                        has_dynamic_offset: false,
                        min_binding_size: None,
                    },
                    count: None,
                },
                // binding 3: Transfer function LUT
                BindGroupLayoutEntry {
                    binding: 3,
                    visibility: ShaderStages::COMPUTE,
                    ty: BindingType::Buffer {
                        ty: BufferBindingType::Storage { read_only: true },
                        has_dynamic_offset: false,
                        min_binding_size: None,
                    },
                    count: None,
                },
                // binding 4: Segmentation mask (packed u8 labels in u32) - from Auto Clean
                BindGroupLayoutEntry {
                    binding: 4,
                    visibility: ShaderStages::COMPUTE,
                    ty: BindingType::Buffer {
                        ty: BufferBindingType::Storage { read_only: true },
                        has_dynamic_offset: false,
                        min_binding_size: None,
                    },
                    count: None,
                },
                // binding 5: Sculpt mask (packed u8 labels in u32) - from Lasso Sculpt
                BindGroupLayoutEntry {
                    binding: 5,
                    visibility: ShaderStages::COMPUTE,
                    ty: BindingType::Buffer {
                        ty: BufferBindingType::Storage { read_only: true },
                        has_dynamic_offset: false,
                        min_binding_size: None,
                    },
                    count: None,
                },
            ],
        })
    }

    fn create_sculpt_bind_group_layout(device: &Device) -> BindGroupLayout {
        device.create_bind_group_layout(&BindGroupLayoutDescriptor {
            label: Some("sculpt_bind_group_layout"),
            entries: &[
                // binding 0: Uniforms (SculptParams)
                BindGroupLayoutEntry {
                    binding: 0,
                    visibility: ShaderStages::COMPUTE,
                    ty: BindingType::Buffer {
                        ty: BufferBindingType::Uniform,
                        has_dynamic_offset: false,
                        min_binding_size: None,
                    },
                    count: None,
                },
                // binding 1: Polygon points (array of f32)
                BindGroupLayoutEntry {
                    binding: 1,
                    visibility: ShaderStages::COMPUTE,
                    ty: BindingType::Buffer {
                        ty: BufferBindingType::Storage { read_only: true },
                        has_dynamic_offset: false,
                        min_binding_size: None,
                    },
                    count: None,
                },
                // binding 2: Mask output (packed u8 labels in atomic<u32>)
                BindGroupLayoutEntry {
                    binding: 2,
                    visibility: ShaderStages::COMPUTE,
                    ty: BindingType::Buffer {
                        ty: BufferBindingType::Storage { read_only: false },
                        has_dynamic_offset: false,
                        min_binding_size: None,
                    },
                    count: None,
                },
            ],
        })
    }

    /// Set transfer function from preset
    pub fn set_transfer_function_preset(&mut self, preset: TransferFunctionPreset) {
        self.current_transfer_function = TransferFunction::from_preset(preset);
        self.upload_transfer_function();
    }

    /// Set custom transfer function
    pub fn set_transfer_function(&mut self, tf: TransferFunction) {
        self.current_transfer_function = tf;
        self.upload_transfer_function();
    }

    /// Get current transfer function
    pub fn transfer_function(&self) -> &TransferFunction {
        &self.current_transfer_function
    }

    fn upload_transfer_function(&self) {
        // Ensure we have exactly 256 entries
        let mut entries = self.current_transfer_function.entries.clone();
        entries.resize(Self::TRANSFER_FUNCTION_SIZE, TransferFunctionEntry::transparent());

        self.queue.write_buffer(
            &self.transfer_function_buffer,
            0,
            bytemuck::cast_slice(&entries),
        );
    }

    /// Upload segmentation mask to GPU
    /// Mask data is u8 per voxel (label values 0-255)
    /// Will be packed into u32 for efficient GPU access
    pub fn upload_mask(&mut self, mask_data: &[u8], dimensions: [usize; 3]) {
        let total_voxels = dimensions[0] * dimensions[1] * dimensions[2];

        // Validate input size
        if mask_data.len() != total_voxels {
            tracing::warn!(
                "Mask size mismatch: expected {} voxels, got {}",
                total_voxels,
                mask_data.len()
            );
            return;
        }

        // Pack u8 labels into u32 (4 labels per u32)
        let packed_size = total_voxels.div_ceil(4);
        let mut packed_data: Vec<u32> = vec![0; packed_size];

        for (i, &label) in mask_data.iter().enumerate() {
            let word_index = i / 4;
            let byte_offset = (i % 4) * 8;
            packed_data[word_index] |= (label as u32) << byte_offset;
        }

        // Create or recreate buffer if needed
        let buffer_size = (packed_size * std::mem::size_of::<u32>()) as u64;

        let needs_recreate = match &self.mask_buffer {
            Some(buf) => buf.size() != buffer_size,
            None => true,
        };

        if needs_recreate {
            self.mask_buffer = Some(self.device.create_buffer(&BufferDescriptor {
                label: Some("segmentation_mask"),
                size: buffer_size,
                usage: BufferUsages::STORAGE | BufferUsages::COPY_DST,
                mapped_at_creation: false,
            }));
        }

        // Upload packed data
        if let Some(ref buffer) = self.mask_buffer {
            self.queue.write_buffer(buffer, 0, bytemuck::cast_slice(&packed_data));
        }

        debug!(
            "Uploaded mask: {}x{}x{} ({} voxels, {} packed u32s)",
            dimensions[0], dimensions[1], dimensions[2], total_voxels, packed_size
        );
    }

    /// Set mask configuration (for segmentation)
    pub fn set_mask_config(&mut self, config: MaskConfig) {
        self.mask_config = config;
    }

    /// Get current mask configuration
    pub fn mask_config(&self) -> &MaskConfig {
        &self.mask_config
    }

    /// Get effective mask buffer and config for rendering
    /// Priority: Sculpt mask > Segmentation mask > Dummy buffer
    #[allow(dead_code)]
    fn get_effective_mask(&self) -> (&Buffer, bool, u32) {
        // Sculpt mask takes priority if active
        if self.sculpt_mask_config.enabled {
            if let Some(ref buf) = self.sculpt_mask_buffer {
                return (buf, true, self.sculpt_mask_config.visible_labels);
            }
        }

        // Fall back to segmentation mask
        if self.mask_config.enabled {
            if let Some(ref buf) = self.mask_buffer {
                return (buf, true, self.mask_config.visible_labels);
            }
        }

        // No mask active - use dummy buffer
        (&self.dummy_mask_buffer, false, 0xFFFFFFFF)
    }

    /// Check if segmentation mask is available
    pub fn has_mask(&self) -> bool {
        self.mask_buffer.is_some()
    }

    /// Check if sculpt mask is available
    pub fn has_sculpt_mask(&self) -> bool {
        self.sculpt_mask_buffer.is_some()
    }

    /// Clear segmentation mask (from Auto Clean)
    pub fn clear_mask(&mut self) {
        self.mask_buffer = None;
        self.mask_config = MaskConfig::default();
    }

    /// Clear sculpt mask (from Lasso Sculpt) - does NOT affect segmentation mask
    pub fn clear_sculpt_mask(&mut self) {
        self.sculpt_mask_buffer = None;
        self.sculpt_mask_config = MaskConfig::default();
        info!("Sculpt mask cleared (segmentation mask preserved)");
    }

    /// Generate sculpt mask on GPU
    ///
    /// Projects a 2D lasso polygon into 3D space and creates a mask for
    /// voxels that fall inside (or outside) the extruded lasso region.
    ///
    /// # Parameters
    /// - `dimensions`: Volume dimensions [depth, rows, cols]
    /// - `camera`: Camera state for projection
    /// - `polygon_points`: 2D lasso points in normalized coordinates (0-1 range)
    /// - `action`: 0 = remove_inside, 1 = keep_inside
    ///
    /// # Returns
    /// Number of voxels affected (hidden by the mask)
    pub fn generate_sculpt_mask_gpu(
        &mut self,
        dimensions: [usize; 3],
        spacing: [f32; 3],
        camera: &Camera,
        polygon_points: &[[f32; 2]],
        action: u32,
        aspect_ratio: f32,
    ) -> Result<usize, MprError> {
        let start = std::time::Instant::now();

        let [depth, rows, cols] = dimensions;
        let total_voxels = depth * rows * cols;

        // Validate polygon
        if polygon_points.len() < 3 {
            return Err(MprError::GpuError("Lasso must have at least 3 points".to_string()));
        }

        if polygon_points.len() > 1024 {
            return Err(MprError::GpuError("Lasso has too many points (max 1024)".to_string()));
        }

        info!(
            "GPU sculpt mask generation: {}x{}x{} volume, {} polygon points, action={}",
            depth, rows, cols, polygon_points.len(), action
        );

        // Calculate camera basis vectors — MUST be normalized for correct projection
        let look = camera.look_dir;
        let up = camera.up;

        // Right vector = normalize(look × up)
        let rx = look[1] * up[2] - look[2] * up[1];
        let ry = look[2] * up[0] - look[0] * up[2];
        let rz = look[0] * up[1] - look[1] * up[0];
        let r_len = (rx * rx + ry * ry + rz * rz).sqrt().max(1e-8);
        let right = [rx / r_len, ry / r_len, rz / r_len];

        // Corrected up = normalize(right × look) — orthogonal to both
        let ux = right[1] * look[2] - right[2] * look[1];
        let uy = right[2] * look[0] - right[0] * look[2];
        let uz = right[0] * look[1] - right[1] * look[0];
        let u_len = (ux * ux + uy * uy + uz * uz).sqrt().max(1e-8);
        let up_corrected = [ux / u_len, uy / u_len, uz / u_len];

        // Calculate polygon bounding box
        let mut poly_min_x = f32::MAX;
        let mut poly_max_x = f32::MIN;
        let mut poly_min_y = f32::MAX;
        let mut poly_max_y = f32::MIN;
        for p in polygon_points {
            poly_min_x = poly_min_x.min(p[0]);
            poly_max_x = poly_max_x.max(p[0]);
            poly_min_y = poly_min_y.min(p[1]);
            poly_max_y = poly_max_y.max(p[1]);
        }
        // Add margin for edge cases
        poly_min_x -= 0.05;
        poly_max_x += 0.05;
        poly_min_y -= 0.05;
        poly_max_y += 0.05;

        // Create uniforms
        let uniforms = SculptUniforms {
            volume_width: cols as u32,
            volume_height: rows as u32,
            volume_depth: depth as u32,
            cam_pos_x: camera.position[0],
            cam_pos_y: camera.position[1],
            cam_pos_z: camera.position[2],
            look_x: look[0],
            look_y: look[1],
            look_z: look[2],
            right_x: right[0],
            right_y: right[1],
            right_z: right[2],
            up_x: up_corrected[0],
            up_y: up_corrected[1],
            up_z: up_corrected[2],
            fov_half_tan: (camera.fov / 2.0).tan(),
            aspect_ratio,
            polygon_point_count: polygon_points.len() as u32,
            action,
            poly_min_x,
            poly_max_x,
            poly_min_y,
            poly_max_y,
            spacing_x: spacing[2], // x = cols spacing
            spacing_y: spacing[1], // y = rows spacing
            spacing_z: spacing[0], // z = depth spacing
            _padding: 0.0,
        };

        // Upload uniforms
        self.queue.write_buffer(
            &self.sculpt_uniform_buffer,
            0,
            bytemuck::bytes_of(&uniforms),
        );

        // Flatten polygon points to f32 array
        let polygon_data: Vec<f32> = polygon_points
            .iter()
            .flat_map(|p| [p[0], p[1]])
            .collect();

        // Upload polygon points
        self.queue.write_buffer(
            &self.sculpt_polygon_buffer,
            0,
            bytemuck::cast_slice(&polygon_data),
        );

        // Calculate packed mask buffer size (4 labels per u32)
        let packed_size = total_voxels.div_ceil(4);
        let mask_buffer_size = (packed_size * std::mem::size_of::<u32>()) as u64;

        // Create/resize SCULPT mask buffer if needed (separate from segmentation mask!)
        let needs_recreate = match &self.sculpt_mask_buffer {
            Some(buf) => buf.size() != mask_buffer_size,
            None => true,
        };

        if needs_recreate {
            self.sculpt_mask_buffer = Some(self.device.create_buffer(&BufferDescriptor {
                label: Some("sculpt_mask_output"),
                size: mask_buffer_size,
                usage: BufferUsages::STORAGE | BufferUsages::COPY_SRC | BufferUsages::COPY_DST,
                mapped_at_creation: false,
            }));

            // Zero-initialize the new buffer (label 0 = visible by default)
            let zeros = vec![0u32; packed_size];
            self.queue.write_buffer(
                self.sculpt_mask_buffer.as_ref().unwrap(),
                0,
                bytemuck::cast_slice(&zeros),
            );

            info!("Created new sculpt mask buffer (separate from segmentation)");
        }
        // NOTE: Don't zero existing buffer - we want to accumulate sculpt operations!
        // Each sculpt adds more hidden voxels (label 2) without affecting previous ones.

        let sculpt_buffer = self.sculpt_mask_buffer.as_ref().unwrap();

        // Create bind group
        let bind_group = self.device.create_bind_group(&BindGroupDescriptor {
            label: Some("sculpt_bind_group"),
            layout: &self.sculpt_bind_group_layout,
            entries: &[
                BindGroupEntry {
                    binding: 0,
                    resource: self.sculpt_uniform_buffer.as_entire_binding(),
                },
                BindGroupEntry {
                    binding: 1,
                    resource: self.sculpt_polygon_buffer.as_entire_binding(),
                },
                BindGroupEntry {
                    binding: 2,
                    resource: sculpt_buffer.as_entire_binding(),
                },
            ],
        });

        // Execute compute shader
        let mut encoder = self.device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
            label: Some("sculpt_encoder"),
        });

        {
            let mut compute_pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
                label: Some("sculpt_pass"),
                timestamp_writes: None,
            });

            compute_pass.set_pipeline(&self.sculpt_pipeline);
            compute_pass.set_bind_group(0, &bind_group, &[]);

            // Workgroup size is 8x8x4, dispatch enough workgroups to cover volume
            let workgroups_x = (cols as u32).div_ceil(8);
            let workgroups_y = (rows as u32).div_ceil(8);
            let workgroups_z = (depth as u32).div_ceil(4);

            compute_pass.dispatch_workgroups(workgroups_x, workgroups_y, workgroups_z);
        }

        self.queue.submit(std::iter::once(encoder.finish()));

        // Wait for GPU to complete
        self.device.poll(wgpu::Maintain::Wait);

        let elapsed_ms = start.elapsed().as_secs_f64() * 1000.0;

        info!(
            "GPU sculpt mask generated in {:.1}ms ({} voxels, {} workgroups)",
            elapsed_ms,
            total_voxels,
            cols.div_ceil(8) * rows.div_ceil(8) * depth.div_ceil(4)
        );

        // Configure SCULPT mask for rendering:
        // - enabled: true (activate sculpt masking)
        // - visible_labels: 0b11 = labels 0 and 1 visible, label 2 hidden
        self.sculpt_mask_config = MaskConfig {
            enabled: true,
            visible_labels: 0b11,
        };

        // Count affected voxels by reading back the mask (optional, for statistics)
        // For now, estimate based on bounding box coverage
        let bbox_coverage = (poly_max_x - poly_min_x) * (poly_max_y - poly_min_y);
        let estimated_affected = (total_voxels as f32 * bbox_coverage * 0.5) as usize;

        Ok(estimated_affected)
    }

    /// Render volume using specified mode
    pub fn render(
        &self,
        volume: &GpuVolume,
        camera: &Camera,
        mode: RenderMode,
        window_center: f32,
        window_width: f32,
        spacing: [f32; 3],
    ) -> Result<RenderResult, MprError> {
        self.render_with_options(
            volume,
            camera,
            mode,
            window_center,
            window_width,
            spacing,
            DvrOptions::default(),
        )
    }

    /// Render volume with additional DVR options (clipping, opacity, lighting, quality)
    #[allow(clippy::too_many_arguments)]
    pub fn render_with_options(
        &self,
        volume: &GpuVolume,
        camera: &Camera,
        mode: RenderMode,
        window_center: f32,
        window_width: f32,
        spacing: [f32; 3],
        options: DvrOptions,
    ) -> Result<RenderResult, MprError> {
        match mode {
            RenderMode::MIP | RenderMode::AIP | RenderMode::MinIP => {
                self.render_mip(volume, camera, mode, window_center, window_width, spacing, &options)
            }
            RenderMode::DVR | RenderMode::DVRNoShading => {
                self.render_dvr(volume, camera, mode, spacing, options)
            }
        }
    }

    /// Render using MIP/AIP/MinIP modes
    #[allow(clippy::too_many_arguments)]
    fn render_mip(
        &self,
        volume: &GpuVolume,
        camera: &Camera,
        mode: RenderMode,
        window_center: f32,
        window_width: f32,
        spacing: [f32; 3],
        options: &DvrOptions,
    ) -> Result<RenderResult, MprError> {
        let start = std::time::Instant::now();

        // Check for chunked volume - not yet supported for 3D rendering
        // TODO: Implement multi-pass chunked rendering
        let volume_buffer = volume.buffer().ok_or_else(|| {
            MprError::GpuError(
                "Volume exceeds 2GB GPU buffer limit. Consider downsampling \
                 the volume or using fewer slices.".to_string()
            )
        })?;

        let dims = volume.dimensions();
        let step_size = options.step_size;
        let clip = &options.clip_plane;

        // Calculate max steps based on volume diagonal and step size
        // Smaller step_size = more steps = higher quality
        let max_diagonal = ((dims[0].pow(2) + dims[1].pow(2) + dims[2].pow(2)) as f32).sqrt();
        let max_steps = (max_diagonal / step_size * 2.0) as u32; // 2x diagonal for safety

        // Update uniforms with mask and clip parameters
        let uniforms = MipUniforms {
            volume_width: dims[2] as u32,  // cols (X)
            volume_height: dims[1] as u32, // rows (Y)
            volume_depth: dims[0] as u32,  // depth (Z)
            output_width: self.output_width,
            output_height: self.output_height,
            camera_x: camera.position[0],
            camera_y: camera.position[1],
            camera_z: camera.position[2],
            look_x: camera.look_dir[0],
            look_y: camera.look_dir[1],
            look_z: camera.look_dir[2],
            up_x: camera.up[0],
            up_y: camera.up[1],
            up_z: camera.up[2],
            fov: camera.fov,
            step_size,
            max_steps,
            window_width,
            window_center,
            spacing_x: spacing[0],
            spacing_y: spacing[1],
            spacing_z: spacing[2],
            threshold: 0.0, // No early termination
            // Segmentation mask (from Auto Clean)
            mask_enabled: if self.mask_config.enabled && self.mask_buffer.is_some() { 1 } else { 0 },
            visible_labels: self.mask_config.visible_labels,
            // Sculpt mask (from Lasso Sculpt) - both masks are checked independently
            sculpt_mask_enabled: if self.sculpt_mask_config.enabled && self.sculpt_mask_buffer.is_some() { 1 } else { 0 },
            sculpt_visible_labels: self.sculpt_mask_config.visible_labels,
            clip_enabled: if clip.enabled { 1 } else { 0 },
            clip_inverted: if clip.inverted { 1 } else { 0 },
            clip_normal_x: clip.normal[0],
            clip_normal_y: clip.normal[1],
            clip_normal_z: clip.normal[2],
            clip_distance: clip.distance,
            _pad1: 0,
            _pad2: 0,
            _pad3: 0,
        };

        self.queue
            .write_buffer(&self.mip_uniform_buffer, 0, bytemuck::bytes_of(&uniforms));

        // Get both mask buffers (use dummy if not available)
        let seg_mask_buffer = self.mask_buffer.as_ref().unwrap_or(&self.dummy_mask_buffer);
        let sculpt_mask_buffer = self.sculpt_mask_buffer.as_ref().unwrap_or(&self.dummy_mask_buffer);

        // Create bind group with BOTH masks
        let bind_group = self.device.create_bind_group(&BindGroupDescriptor {
            label: Some("mip_bind_group"),
            layout: &self.mip_bind_group_layout,
            entries: &[
                BindGroupEntry {
                    binding: 0,
                    resource: volume_buffer.as_entire_binding(),
                },
                BindGroupEntry {
                    binding: 1,
                    resource: self.mip_uniform_buffer.as_entire_binding(),
                },
                BindGroupEntry {
                    binding: 2,
                    resource: self.output_buffer.as_entire_binding(),
                },
                BindGroupEntry {
                    binding: 3,
                    resource: seg_mask_buffer.as_entire_binding(),
                },
                BindGroupEntry {
                    binding: 4,
                    resource: sculpt_mask_buffer.as_entire_binding(),
                },
            ],
        });

        // Select pipeline based on mode
        let pipeline = match mode {
            RenderMode::MIP => &self.mip_pipeline,
            RenderMode::AIP => &self.aip_pipeline,
            RenderMode::MinIP => &self.minip_pipeline,
            _ => unreachable!(),
        };

        // Execute compute and read back
        self.execute_and_readback(pipeline, &bind_group, mode, start)
    }

    /// Render using DVR mode with transfer function
    fn render_dvr(
        &self,
        volume: &GpuVolume,
        camera: &Camera,
        mode: RenderMode,
        spacing: [f32; 3],
        options: DvrOptions,
    ) -> Result<RenderResult, MprError> {
        let start = std::time::Instant::now();

        // Check for chunked volume - not yet supported for 3D rendering
        let volume_buffer = volume.buffer().ok_or_else(|| {
            MprError::GpuError(
                "Volume exceeds 2GB GPU buffer limit. Consider downsampling \
                 the volume or using fewer slices.".to_string()
            )
        })?;

        let dims = volume.dimensions();
        let tf = &self.current_transfer_function;

        // Use step size from options (smaller = higher quality, slower)
        let step_size = options.step_size;
        let max_diagonal = ((dims[0].pow(2) + dims[1].pow(2) + dims[2].pow(2)) as f32).sqrt();
        let max_steps = (max_diagonal / step_size * 2.0) as u32;

        let enable_shading = if mode == RenderMode::DVR { 1u32 } else { 0u32 };

        // Extract clipping plane config
        let clip = &options.clip_plane;

        // Update DVR uniforms with mask parameters
        let uniforms = DvrUniforms {
            volume_width: dims[2] as u32,
            volume_height: dims[1] as u32,
            volume_depth: dims[0] as u32,
            output_width: self.output_width,
            output_height: self.output_height,
            camera_x: camera.position[0],
            camera_y: camera.position[1],
            camera_z: camera.position[2],
            look_x: camera.look_dir[0],
            look_y: camera.look_dir[1],
            look_z: camera.look_dir[2],
            up_x: camera.up[0],
            up_y: camera.up[1],
            up_z: camera.up[2],
            fov: camera.fov,
            step_size,
            max_steps,
            tf_min: tf.min_hu,
            tf_max: tf.max_hu,
            tf_size: tf.entries.len() as u32,
            spacing_x: spacing[0],
            spacing_y: spacing[1],
            spacing_z: spacing[2],
            ambient: 0.2,
            diffuse: 0.7,
            specular: 0.3,
            shininess: 32.0,
            light_x: options.light_direction[0],
            light_y: options.light_direction[1],
            light_z: options.light_direction[2],
            opacity_threshold: 0.95,
            gradient_threshold: 10.0,
            enable_shading,
            clip_enabled: if clip.enabled { 1 } else { 0 },
            clip_inverted: if clip.inverted { 1 } else { 0 },
            clip_normal_x: clip.normal[0],
            clip_normal_y: clip.normal[1],
            clip_normal_z: clip.normal[2],
            clip_distance: clip.distance,
            opacity_multiplier: options.opacity_multiplier,
            // Segmentation mask (from Auto Clean)
            mask_enabled: if self.mask_config.enabled && self.mask_buffer.is_some() { 1 } else { 0 },
            visible_labels: self.mask_config.visible_labels,
            // Sculpt mask (from Lasso Sculpt) - both masks are checked independently
            sculpt_mask_enabled: if self.sculpt_mask_config.enabled && self.sculpt_mask_buffer.is_some() { 1 } else { 0 },
            sculpt_visible_labels: self.sculpt_mask_config.visible_labels,
            // Slice plane navigation
            slice_planes_enabled: if options.slice_planes.enabled { 1 } else { 0 },
            axial_slice: options.slice_planes.axial,
            sagittal_slice: options.slice_planes.sagittal,
            coronal_slice: options.slice_planes.coronal,
            slice_plane_thickness: options.slice_planes.thickness,
            slice_plane_opacity: options.slice_planes.opacity,
            _padding2: 0,
            _padding3: 0,
        };

        self.queue
            .write_buffer(&self.dvr_uniform_buffer, 0, bytemuck::bytes_of(&uniforms));

        // Get both mask buffers (use dummy if not available)
        let seg_mask_buffer = self.mask_buffer.as_ref().unwrap_or(&self.dummy_mask_buffer);
        let sculpt_mask_buffer = self.sculpt_mask_buffer.as_ref().unwrap_or(&self.dummy_mask_buffer);

        // Create DVR bind group (includes transfer function and BOTH masks)
        let bind_group = self.device.create_bind_group(&BindGroupDescriptor {
            label: Some("dvr_bind_group"),
            layout: &self.dvr_bind_group_layout,
            entries: &[
                BindGroupEntry {
                    binding: 0,
                    resource: volume_buffer.as_entire_binding(),
                },
                BindGroupEntry {
                    binding: 1,
                    resource: self.dvr_uniform_buffer.as_entire_binding(),
                },
                BindGroupEntry {
                    binding: 2,
                    resource: self.output_buffer.as_entire_binding(),
                },
                BindGroupEntry {
                    binding: 3,
                    resource: self.transfer_function_buffer.as_entire_binding(),
                },
                BindGroupEntry {
                    binding: 4,
                    resource: seg_mask_buffer.as_entire_binding(),
                },
                BindGroupEntry {
                    binding: 5,
                    resource: sculpt_mask_buffer.as_entire_binding(),
                },
            ],
        });

        // Select pipeline
        let pipeline = if mode == RenderMode::DVR {
            &self.dvr_pipeline
        } else {
            &self.dvr_no_shading_pipeline
        };

        // Execute compute and read back
        self.execute_and_readback(pipeline, &bind_group, mode, start)
    }

    /// Common execute and readback for all render modes
    fn execute_and_readback(
        &self,
        pipeline: &ComputePipeline,
        bind_group: &wgpu::BindGroup,
        mode: RenderMode,
        start: std::time::Instant,
    ) -> Result<RenderResult, MprError> {
        // Execute compute
        let mut encoder = self
            .device
            .create_command_encoder(&wgpu::CommandEncoderDescriptor {
                label: Some("volume_render_encoder"),
            });

        {
            let mut compute_pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor {
                label: Some("volume_render_pass"),
                timestamp_writes: None,
            });

            compute_pass.set_pipeline(pipeline);
            compute_pass.set_bind_group(0, bind_group, &[]);

            let workgroups_x = self.output_width.div_ceil(Self::WORKGROUP_SIZE);
            let workgroups_y = self.output_height.div_ceil(Self::WORKGROUP_SIZE);

            compute_pass.dispatch_workgroups(workgroups_x, workgroups_y, 1);
        }

        // Copy to staging for readback
        let output_size = (self.output_width * self.output_height * 4) as u64;
        encoder.copy_buffer_to_buffer(&self.output_buffer, 0, &self.staging_buffer, 0, output_size);

        self.queue.submit(std::iter::once(encoder.finish()));

        // Read back results
        let buffer_slice = self.staging_buffer.slice(..);
        let (tx, rx) = std::sync::mpsc::channel();
        buffer_slice.map_async(wgpu::MapMode::Read, move |result| {
            tx.send(result).unwrap();
        });

        self.device.poll(wgpu::Maintain::Wait);
        rx.recv()
            .map_err(|_| MprError::GpuError("Channel receive failed".to_string()))?
            .map_err(|e| MprError::GpuError(format!("Buffer map failed: {:?}", e)))?;

        let data = buffer_slice.get_mapped_range();

        // Extract RGBA data
        let rgba_data: Vec<u8> = data.to_vec();

        drop(data);
        self.staging_buffer.unmap();

        let elapsed_ms = start.elapsed().as_secs_f64() * 1000.0;

        debug!(
            "{:?} render: {}x{} in {:.1}ms",
            mode, self.output_width, self.output_height, elapsed_ms
        );

        Ok(RenderResult {
            width: self.output_width,
            height: self.output_height,
            rgba_data,
            render_time_ms: elapsed_ms,
        })
    }

    /// Resize output buffers
    pub fn resize(&mut self, width: u32, height: u32) -> Result<(), MprError> {
        if width == self.output_width && height == self.output_height {
            return Ok(());
        }

        let output_size = (width * height * 4) as u64;

        self.output_buffer = self.device.create_buffer(&BufferDescriptor {
            label: Some("volume_render_output"),
            size: output_size,
            usage: BufferUsages::STORAGE | BufferUsages::COPY_SRC,
            mapped_at_creation: false,
        });

        self.staging_buffer = self.device.create_buffer(&BufferDescriptor {
            label: Some("volume_render_staging"),
            size: output_size,
            usage: BufferUsages::MAP_READ | BufferUsages::COPY_DST,
            mapped_at_creation: false,
        });

        self.output_width = width;
        self.output_height = height;

        info!("Volume renderer resized to {}x{}", width, height);
        Ok(())
    }
}

/// Result of volume rendering
pub struct RenderResult {
    pub width: u32,
    pub height: u32,
    pub rgba_data: Vec<u8>,
    pub render_time_ms: f64,
}

impl RenderResult {
    /// Convert to grayscale (single channel)
    pub fn to_grayscale(&self) -> Vec<u8> {
        self.rgba_data
            .chunks_exact(4)
            .map(|chunk| chunk[0]) // R channel (same as G and B for grayscale)
            .collect()
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_camera_orbit() {
        let center = [100.0, 100.0, 100.0];
        let camera = Camera::orbit(center, 200.0, 0.0, 0.0);

        // Camera should be behind center on Z axis
        assert!(camera.position[2] > center[2]);

        // Look direction should point toward center (negative Z)
        assert!(camera.look_dir[2] < 0.0);
    }

    #[test]
    fn test_uniform_size() {
        // Ensure uniform struct is properly aligned
        assert_eq!(std::mem::size_of::<MipUniforms>() % 16, 0);
    }
}