MouseEffects v1.0.28

  Release Notes

  New Features

  Simulation-Guided Correction (ColorBlindnessNG)

  - Smart pixel detection: Uses CVD simulation to identify which pixels are actually affected by color
  blindness before applying correction
  - Adjustable sensitivity: Control detection aggressiveness (0.5-5.0) - conservative to aggressive
  - Natural results: Leaves unaffected colors unchanged, only correcting pixels that need it
  - Algorithm choice: Select between Machado (RGB) or Strict (LMS) for detection

  Post-Correction Simulation ("Re-simulate for Verification")

  - Verify correction effectiveness: Apply CVD simulation AFTER correction to see how corrected colors appear
  to colorblind users
  - Non-colorblind validation: Helps sighted users confirm that previously confusing colors are now
  distinguishable
  - Independent controls: Separate algorithm, CVD type, and intensity settings per zone
  - Pipeline: Original → Correction → Simulation visualization

  Bug Fixes

  - Fixed overlay topmost issues: Dialogs and settings window now properly appear above the overlay without
  causing z-order problems when closed
  - Fixed preset persistence: Selected presets now correctly restore on app restart (was reverting to "Custom")
  - Fixed preset saving location: Custom presets now save to AppData instead of plugin directory
  - Fixed configuration key mismatch: WhiteProtection settings now properly persist between sessions
  - Fixed Zone2/Zone3 loading: All 4 zones now correctly load their settings on startup

  Improvements

  - White protection minimum: Changed minimum value from 0.0 to 0.01 for better color preservation
  - Documentation updates: README and Wiki updated with new feature documentation

Author: ltrudu

README.md

@@ -30,7 +30,7 @@ MouseEffects is a modular, plugin-based application that renders beautiful visua
 | **Laser Work** | Directional lasers shooting from cursor with collision detection |
 | **Screen Distortion** | Real-time lens/ripple distortion effect |
 | **Color Blindness** | CVD simulation & correction with 17 filter types (Machado/Strict algorithms), zone layouts, and comparison view |
-| **Color Blindness NG** | Next-gen CVD plugin with per-zone configuration, LUT-based correction, custom presets, Circle/Rectangle cursor-following modes with soft edge blending |
+| **Color Blindness NG** | Next-gen CVD plugin with per-zone configuration, LUT-based correction, custom presets, Circle/Rectangle cursor-following modes, Simulation-Guided Correction, and Post-Correction Verification |
 | **Radial Dithering** | Bayer-pattern dithering effect around cursor |
 | **Tile Vibration** | Vibrating tiles that capture and display screen content |
 | **Water Ripple** | Expanding water ripples on click with realistic wave interference |

Wiki/Features.md

@@ -196,6 +196,45 @@ Effects in MouseEffects can:
 | **Geometric Rendering** | Lines, circles, rectangles with shaders |
 | **Texture Sampling** | Use screen content as texture source |
 
+## Color Vision Accessibility (ColorBlindnessNG)
+
+The ColorBlindnessNG plugin provides advanced accessibility features for color vision deficiency (CVD):
+
+### Simulation Mode
+Simulates how people with various types of color blindness perceive colors:
+- **Machado Algorithm**: RGB-space matrices from Machado et al. (2009) research
+- **Strict LMS Algorithm**: Physiologically-accurate LMS colorspace processing
+- **8 CVD Types**: Protanopia, Protanomaly, Deuteranopia, Deuteranomaly, Tritanopia, Tritanomaly, Achromatopsia, Achromatomaly
+
+### Correction Mode
+Helps colorblind users distinguish colors using LUT-based remapping:
+- **Per-Channel Control**: Independent red, green, blue correction with customizable gradients
+- **Multiple Presets**: Built-in presets for common CVD types plus custom preset support
+- **Application Modes**: Full Channel, Dominant Only, or Threshold-based correction
+- **Gradient Interpolation**: Linear RGB, Perceptual LAB, or HSL color space blending
+
+### Advanced Features (v1.0.28+)
+
+#### Simulation-Guided Correction
+Uses CVD simulation to detect which pixels are affected before applying correction:
+- Only corrects pixels that would actually be impacted by the CVD type
+- Configurable sensitivity (0.5-5.0) controls detection aggressiveness
+- Leaves unaffected colors unchanged for more natural results
+
+#### Post-Correction Simulation (Re-simulate for Verification)
+Applies CVD simulation AFTER correction to verify effectiveness:
+- Non-colorblind users can see how corrected colors appear to CVD users
+- Helps validate that previously confusing colors are now distinguishable
+- Independent algorithm and intensity controls per zone
+
+### Display Modes
+- **Fullscreen**: Apply effect to entire screen
+- **Split Modes**: Vertical, Horizontal, or Quadrant splits for comparison
+- **Circle/Rectangle**: Cursor-following shapes with configurable size and soft edges
+- **Comparison Mode**: Duplicate screen in each zone with virtual cursor projection
+
+See [Plugins Reference](Plugins.md#color-blindness-ng) for complete settings documentation
+
 ## Extensibility
 
 ### Custom Effects

Wiki/Plugins.md

@@ -358,6 +358,9 @@ Next-generation color vision deficiency (CVD) simulation and correction plugin w
 - **Per-zone architecture**: Up to 4 independent zones, each configurable as Original, Simulation, or Correction
 - **14 CVD simulation types** across Machado (RGB) and Strict (LMS) algorithms
 - **LUT-based correction**: Per-channel color remapping with customizable gradients
+- **Simulation-Guided Correction** (v1.0.28+): Uses CVD simulation to detect affected pixels before applying correction
+- **Post-Correction Simulation** (v1.0.28+): Re-simulate CVD after correction to verify effectiveness
+- **Sensitivity control** (v1.0.28+): Adjustable detection sensitivity for simulation-guided correction
 - **Real comparison mode**: Full screen duplicated in each zone with virtual cursor projection
 - **Custom preset system**: Save, load, export, and import correction presets
 - **Multiple split modes**: Fullscreen, Split Vertical/Horizontal, Quadrants, Circle, Rectangle
@@ -459,7 +462,53 @@ Each zone has three channel LUTs (Red, Green, Blue) with these settings:
 | `zone{n}_{color}Strength` | float | 0-1 | 1.0 | Channel correction strength |
 | `zone{n}_{color}StartColor` | string | hex | varies | LUT gradient start color |
 | `zone{n}_{color}EndColor` | string | hex | varies | LUT gradient end color |
-| `zone{n}_{color}WhiteProtection` | float | 0-1 | 0.0 | Protect whites from correction |
+| `zone{n}_{color}WhiteProtection` | float | 0.01-1 | 0.01 | Protect whites from correction |
+
+### Simulation-Guided Correction (v1.0.28+)
+
+An optional mode that uses CVD simulation to detect which pixels are affected before applying LUT correction. This ensures only pixels that would actually be affected by CVD receive correction, leaving unaffected colors unchanged.
+
+**How It Works:**
+1. Simulates the selected CVD type on the original pixel
+2. Calculates the error between original and simulated colors
+3. Uses the error magnitude to determine a blend weight (0-1)
+4. Applies LUT correction proportionally to the detected error
+
+| Setting | Type | Range | Default | Description |
+|---------|------|-------|---------|-------------|
+| `zone{n}_simGuidedEnabled` | bool | - | false | Enable simulation-guided detection |
+| `zone{n}_simGuidedAlgorithm` | int | 0-1 | 0 | 0=Machado, 1=Strict |
+| `zone{n}_simGuidedFilterType` | int | 1-14 | 3 | CVD type to detect |
+| `zone{n}_simGuidedSensitivity` | float | 0.5-5.0 | 2.0 | Detection sensitivity (higher = more aggressive) |
+
+**Sensitivity Guide:**
+- **0.5-1.0**: Conservative - only strong color differences trigger correction
+- **2.0**: Balanced default - moderate detection threshold
+- **3.0-5.0**: Aggressive - even subtle color differences trigger correction
+
+### Post-Correction Simulation (Re-simulate for Verification) (v1.0.28+)
+
+Applies CVD simulation AFTER correction to visualize how corrected colors appear to colorblind users. This helps non-colorblind users verify that corrections are effective.
+
+**Use Case:**
+1. Apply color correction for deuteranopia
+2. Enable "Re-simulate for Verification" with deuteranopia
+3. Screen shows: Original → Correction → Simulation
+4. See what a deuteranope would perceive after correction is applied
+5. Verify that previously confusing colors are now distinguishable
+
+| Setting | Type | Range | Default | Description |
+|---------|------|-------|---------|-------------|
+| `zone{n}_postSimEnabled` | bool | - | false | Enable post-correction simulation |
+| `zone{n}_postSimAlgorithm` | int | 0-1 | 0 | 0=Machado, 1=Strict |
+| `zone{n}_postSimFilterType` | int | 1-14 | 3 | CVD type to simulate |
+| `zone{n}_postSimIntensity` | float | 0-1 | 1.0 | Simulation blend intensity |
+
+**Key Distinction:**
+- **Simulation-Guided Correction**: Uses simulation to DETECT which pixels need correction
+- **Post-Correction Simulation**: Uses simulation AFTER correction for VISUALIZATION
+
+Both features can be enabled independently on the same zone
 
 #### Application Modes
 

plugins/MouseEffects.Effects.ColorBlindnessNG/ColorBlindnessNGEffect.cs

@@ -391,6 +391,16 @@ private void LoadZoneConfiguration(int zoneIndex)
         if (Configuration.TryGet($"{prefix}simGuidedSensitivity", out float simGuidedSensitivity))
             z.SimulationGuidedSensitivity = simGuidedSensitivity;
 
+        // Post-correction simulation settings
+        if (Configuration.TryGet($"{prefix}postSimEnabled", out bool postSimEnabled))
+            z.PostCorrectionSimEnabled = postSimEnabled;
+        if (Configuration.TryGet($"{prefix}postSimAlgorithm", out int postSimAlgorithm))
+            z.PostCorrectionSimAlgorithm = (SimulationAlgorithm)postSimAlgorithm;
+        if (Configuration.TryGet($"{prefix}postSimFilterType", out int postSimFilterType))
+            z.PostCorrectionSimFilterType = postSimFilterType;
+        if (Configuration.TryGet($"{prefix}postSimIntensity", out float postSimIntensity))
+            z.PostCorrectionSimIntensity = postSimIntensity;
+
         // Red channel
         bool needsUpdate = z.LutsNeedUpdate;
         LoadChannelConfiguration(z.RedChannel, $"{prefix}red", ref needsUpdate);
@@ -555,6 +565,14 @@ private ColorBlindnessNGParams BuildConstantBuffer(Vector2 viewportSize)
                 effectiveSimGuidedFilterType = z.SimulationGuidedFilterType + 6;
             }
 
+            // Calculate effective filter type for post-correction simulation
+            int effectivePostSimFilterType = z.PostCorrectionSimFilterType;
+            if (z.PostCorrectionSimAlgorithm == SimulationAlgorithm.Strict &&
+                z.PostCorrectionSimFilterType > 0 && z.PostCorrectionSimFilterType <= 6)
+            {
+                effectivePostSimFilterType = z.PostCorrectionSimFilterType + 6;
+            }
+
             var zoneParams = new ZoneParams
             {
                 Mode = (float)z.Mode,
@@ -573,7 +591,10 @@ private ColorBlindnessNGParams BuildConstantBuffer(Vector2 viewportSize)
                 BlueWhiteProtection = z.BlueChannel.WhiteProtection,
                 SimulationGuidedEnabled = z.SimulationGuidedEnabled ? 1.0f : 0.0f,
                 SimulationGuidedFilterType = effectiveSimGuidedFilterType,
-                SimulationGuidedSensitivity = z.SimulationGuidedSensitivity
+                SimulationGuidedSensitivity = z.SimulationGuidedSensitivity,
+                PostCorrectionSimEnabled = z.PostCorrectionSimEnabled ? 1.0f : 0.0f,
+                PostCorrectionSimFilterType = effectivePostSimFilterType,
+                PostCorrectionSimIntensity = z.PostCorrectionSimIntensity
             };
 
             switch (i)
@@ -627,7 +648,7 @@ private static string LoadEmbeddedShader(string name)
 
     /// <summary>
     /// Per-zone parameters packed for shader.
-    /// Size: 80 bytes (20 floats)
+    /// Size: 96 bytes (24 floats)
     /// </summary>
     [StructLayout(LayoutKind.Sequential)]
     private struct ZoneParams
@@ -653,16 +674,21 @@ private struct ZoneParams
         public float SimulationGuidedFilterType; // CVD type for detection
 
         public float SimulationGuidedSensitivity; // Sensitivity multiplier for detection
-        public float _padding1;
+        public float PostCorrectionSimEnabled;    // 1.0 = apply CVD simulation AFTER correction
+        public float PostCorrectionSimFilterType; // CVD type for post-correction simulation
+        public float PostCorrectionSimIntensity;  // Intensity of post-correction simulation
+
+        public float _padding1;            // Padding for 16-byte alignment
         public float _padding2;
         public float _padding3;
+        public float _padding4;
     }
 
     /// <summary>
     /// Full constant buffer for shader.
-    /// Size: 48 (global) + 4 * 80 (zones) = 368 bytes
+    /// Size: 48 (global) + 4 * 96 (zones) = 432 bytes
     /// </summary>
-    [StructLayout(LayoutKind.Sequential, Size = 368)]
+    [StructLayout(LayoutKind.Sequential, Size = 432)]
     private struct ColorBlindnessNGParams
     {
         // Global parameters (48 bytes)

plugins/MouseEffects.Effects.ColorBlindnessNG/Shaders/ColorBlindnessNG.hlsl

@@ -13,7 +13,7 @@ struct PSInput
 };
 
 // ============================================================================
-// Per-Zone Parameters Structure (80 bytes each = 20 floats, 16-byte aligned)
+// Per-Zone Parameters Structure (96 bytes each = 24 floats, 16-byte aligned)
 // ============================================================================
 
 struct ZoneParams
@@ -39,13 +39,18 @@ struct ZoneParams
     float SimulationGuidedFilterType; // CVD type for detection (0=None, 1-6=Machado, 7-12=Strict)
 
     float SimulationGuidedSensitivity; // Sensitivity multiplier (0.5 = conservative, 5.0 = aggressive)
-    float _padding1;
+    float PostCorrectionSimEnabled;    // 1.0 = apply CVD simulation AFTER correction (for verification)
+    float PostCorrectionSimFilterType; // CVD type for post-correction simulation (1-14)
+    float PostCorrectionSimIntensity;  // Intensity of post-correction simulation (0-1)
+
+    float _padding1;            // Padding for 16-byte alignment
     float _padding2;
     float _padding3;
+    float _padding4;
 };
 
 // ============================================================================
-// Constant Buffer (48 + 80*4 = 368 bytes total)
+// Constant Buffer (48 + 96*4 = 432 bytes total)
 // ============================================================================
 
 cbuffer ColorBlindnessNGParams : register(b0)
@@ -695,23 +700,33 @@ float3 ProcessZone(float3 color, ZoneParams zone, int zoneIndex)
     if (zone.Mode < 1.5)
     {
         processedColor = ApplySimulation(color, zone.SimulationFilterType);
+        // Apply intensity blend for simulation mode
+        return lerp(color, processedColor, zone.Intensity);
     }
+
     // Mode 2 = Correction
+    // Call zone-specific LUT function
+    if (zoneIndex == 0)
+        processedColor = ApplyLUTCorrectionZone0(color, zone);
+    else if (zoneIndex == 1)
+        processedColor = ApplyLUTCorrectionZone1(color, zone);
+    else if (zoneIndex == 2)
+        processedColor = ApplyLUTCorrectionZone2(color, zone);
     else
+        processedColor = ApplyLUTCorrectionZone3(color, zone);
+
+    // Apply intensity blend for correction
+    processedColor = lerp(color, processedColor, zone.Intensity);
+
+    // Post-correction simulation: Apply CVD simulation AFTER correction
+    // This allows non-colorblind users to verify how corrected colors appear to CVD users
+    if (zone.PostCorrectionSimEnabled > 0.5)
     {
-        // Call zone-specific LUT function
-        if (zoneIndex == 0)
-            processedColor = ApplyLUTCorrectionZone0(color, zone);
-        else if (zoneIndex == 1)
-            processedColor = ApplyLUTCorrectionZone1(color, zone);
-        else if (zoneIndex == 2)
-            processedColor = ApplyLUTCorrectionZone2(color, zone);
-        else
-            processedColor = ApplyLUTCorrectionZone3(color, zone);
+        float3 simulated = ApplySimulation(processedColor, zone.PostCorrectionSimFilterType);
+        processedColor = lerp(processedColor, simulated, zone.PostCorrectionSimIntensity);
     }
 
-    // Apply intensity blend
-    return lerp(color, processedColor, zone.Intensity);
+    return processedColor;
 }
 
 // ============================================================================