Add custom mask component, combine many components into one

src-tauri/src/adjustment_utils.rs

@@ -38,8 +38,12 @@
                             params.insert(key.to_string(), cached_data.clone());
                         }
                     }
                 }
             }
+
+            if let Some(nested_sub_masks) = params.get_mut("subMasks").and_then(|v| v.as_array_mut()) {
+                hydrate_sub_masks(nested_sub_masks, cache);
+            }
         }
     }
 }

src-tauri/src/mask_generation.rs

@@ -59,9 +59,7 @@ pub struct MaskDefinition {
 
 impl MaskDefinition {
     pub fn requires_warped_image(&self) -> bool {
-        self.sub_masks
-            .iter()
-            .any(|sm| sm.mask_type == "color" || sm.mask_type == "luminance")
+        self.sub_masks.iter().any(SubMask::requires_warped_image)
     }
 }
 
@@ -98,6 +96,27 @@ struct GrowFeatherParameters {
     feather: f32,
 }
 
+#[derive(Serialize, Deserialize, Debug, Clone, Default)]
+#[serde(rename_all = "camelCase")]
+struct CustomComponentParameters {
+    #[serde(default)]
+    sub_masks: Vec<SubMask>,
+}
+
+impl SubMask {
+    fn requires_warped_image(&self) -> bool {
+        match self.mask_type.as_str() {
+            "color" | "luminance" => true,
+            "custom-component" => {
+                let params: CustomComponentParameters =
+                    CustomComponentParameters::deserialize(&self.parameters).unwrap_or_default();
+                params.sub_masks.iter().any(SubMask::requires_warped_image)
+            }
+            _ => false,
+        }
+    }
+}
+
 #[derive(Serialize, Deserialize, Debug, Clone, Default)]
 #[serde(rename_all = "camelCase")]
 struct RadialMaskParameters {
@@ -1198,6 +1217,31 @@ fn generate_all_bitmap(width: u32, height: u32) -> GrayImage {
     GrayImage::from_pixel(width, height, Luma([255]))
 }
 
+fn generate_custom_component_bitmap(
+    params_value: &Value,
+    width: u32,
+    height: u32,
+    scale: f32,
+    crop_offset: (f32, f32),
+    warped_image: Option<&DynamicImage>,
+) -> Option<GrayImage> {
+    let params: CustomComponentParameters =
+        CustomComponentParameters::deserialize(params_value).unwrap_or_default();
+
+    if params.sub_masks.is_empty() {
+        return None;
+    }
+
+    Some(compose_sub_masks(
+        &params.sub_masks,
+        width,
+        height,
+        scale,
+        crop_offset,
+        warped_image,
+    ))
+}
+
 fn generate_sub_mask_bitmap(
     sub_mask: &SubMask,
     width: u32,
@@ -1269,25 +1313,29 @@ fn generate_sub_mask_bitmap(
             generate_ai_subject_bitmap(&sub_mask.parameters, width, height, scale, crop_offset)
         }
         "all" => Some(generate_all_bitmap(width, height)),
+        "custom-component" => generate_custom_component_bitmap(
+            &sub_mask.parameters,
+            width,
+            height,
+            scale,
+            crop_offset,
+            warped_image,
+        ),
         _ => None,
     }
 }
 
-pub fn generate_mask_bitmap(
-    mask_def: &MaskDefinition,
+fn compose_sub_masks(
+    sub_masks: &[SubMask],
     width: u32,
     height: u32,
     scale: f32,
     crop_offset: (f32, f32),
     warped_image: Option<&DynamicImage>,
-) -> Option<GrayImage> {
-    if !mask_def.visible || mask_def.sub_masks.is_empty() {
-        return None;
-    }
-
+) -> GrayImage {
     let mut final_mask = GrayImage::new(width, height);
 
-    for sub_mask in &mask_def.sub_masks {
+    for sub_mask in sub_masks {
         if let Some(mut sub_bitmap) =
             generate_sub_mask_bitmap(sub_mask, width, height, scale, crop_offset, warped_image)
         {
@@ -1327,6 +1375,30 @@ pub fn generate_mask_bitmap(
         }
     }
 
+    final_mask
+}
+
+pub fn generate_mask_bitmap(
+    mask_def: &MaskDefinition,
+    width: u32,
+    height: u32,
+    scale: f32,
+    crop_offset: (f32, f32),
+    warped_image: Option<&DynamicImage>,
+) -> Option<GrayImage> {
+    if !mask_def.visible || mask_def.sub_masks.is_empty() {
+        return None;
+    }
+
+    let mut final_mask = compose_sub_masks(
+        &mask_def.sub_masks,
+        width,
+        height,
+        scale,
+        crop_offset,
+        warped_image,
+    );
+
     if mask_def.invert {
         for pixel in final_mask.pixels_mut() {
             pixel[0] = 255 - pixel[0];

src/components/panel/Editor.tsx

@@ -58,6 +58,19 @@ const checkCropValid = (pixelCrop: Partial<Crop>, imageW: number, imageH: number
   return true;
 };
 
+const cleanSubMasksForOverlayHash = (subMasks: Array<SubMask> = []): Array<SubMask> =>
+  subMasks.map((subMask) => {
+    const cleanParams: Record<string, unknown> = { ...(subMask.parameters || {}) };
+    delete cleanParams.mask_data_base64;
+    delete cleanParams.maskDataBase64;
+
+    if (Array.isArray(cleanParams.subMasks)) {
+      cleanParams.subMasks = cleanSubMasksForOverlayHash(cleanParams.subMasks as Array<SubMask>);
+    }
+
+    return { ...subMask, parameters: cleanParams };
+  });
+
 interface WgpuRenderState {
   useWgpuRenderer: boolean | undefined;
   isReady: boolean;
@@ -1266,13 +1279,7 @@ export default function Editor({ onBackToLibrary, onContextMenu, transformWrappe
       geometry[k] = (adjustments as any)[k];
     });
 
-    const subMasks = activeMaskDef.subMasks?.map((sm: any) => {
-      const { parameters, ...rest } = sm;
-      const cleanParams = { ...parameters };
-      delete cleanParams.mask_data_base64;
-      delete cleanParams.maskDataBase64;
-      return { ...rest, parameters: cleanParams };
-    });
+    const subMasks = cleanSubMasksForOverlayHash(activeMaskDef.subMasks);
 
     return JSON.stringify({
       id: activeMaskDef.id,

src/components/panel/right/Masks.tsx

@@ -3,6 +3,7 @@ import {
   BringToFront,
   Circle,
   Cloud,
+  Component,
   Droplet,
   Droplets,
   Eraser,
@@ -23,6 +24,7 @@ export enum Mask {
   Brush = 'brush',
   Flow = 'flow',
   Color = 'color',
+  CustomComponent = 'custom-component',
   Linear = 'linear',
   Luminance = 'luminance',
   QuickEraser = 'quick-eraser',
@@ -48,7 +50,7 @@ export interface MaskType {
   icon: any;
   id?: string;
   name: string;
-  type: Mask;
+  type: Mask | null;
 }
 
 export interface SubMask {
@@ -68,6 +70,7 @@ export function formatMaskTypeName(type: string) {
   if (type === Mask.AiForeground) return 'Foreground';
   if (type === Mask.AiSky) return 'Sky';
   if (type === Mask.All) return 'Whole Image';
+  if (type === Mask.CustomComponent) return 'Custom Component';
   if (type === Mask.QuickEraser) return 'Quick Eraser';
   return type.charAt(0).toUpperCase() + type.slice(1);
 }
@@ -85,6 +88,7 @@ export const MASK_ICON_MAP: Record<Mask, any> = {
   [Mask.Brush]: Brush,
   [Mask.Flow]: Droplets,
   [Mask.Color]: Droplet,
+  [Mask.CustomComponent]: Component,
   [Mask.Linear]: TriangleRight,
   [Mask.Luminance]: Sparkles,
   [Mask.QuickEraser]: Eraser,