Ticket #8699: blur-mix.patch

gui/themes/modern.ini

@@ -162 +162 @@
 shadow_right_width=4
 shadow_top_height=2
 shadow_bottom_height=4
-inactive_dialog_shading=kShadingDim
-shading_dim_percent=50
+shading_luminance_percent=30
+shading_dim_percent=10
+shading_blur_rad=2
 fontfile_normal="helvr12-l1.bdf"
 fontfile_fixed_normal="courr12-l1.bdf"
 cursor_hotspot_x=0
@@ -610 +611 @@
 launcher_logo.visible=true
 
 # Override extras
-inactive_dialog_shading=kShadingNone
+shading_luminance_percent=0
+shading_dim_percent=0
+shading_blur_rad=0
 
 # Override browser
 def_buttonWidth=90

gui/ThemeModern.cpp

@@ -195 +195 @@
                 _dialog->screen.create(_screen.w, _screen.h, sizeof(OverlayColor));
         }
         
-        if (_dialogShadingCallback && topDialog) {
-                OverlayColor *col = (OverlayColor*)_screen.pixels;
-                for (int y = 0; y < _screen.h; ++y) {
-                        for (int x = 0; x < _screen.w; ++x) {
-                                col[x] = (this->*(_dialogShadingCallback))(col[x]);
-                        }
-                        col += _screen.w;
-                }
-        }
+        if (_dialogShading && topDialog)
+                dialogShading();
         
         memcpy(_dialog->screen.pixels, _screen.pixels, _screen.pitch*_screen.h);
         
-        if ((_dialogShadingCallback) && topDialog)
+        if (_dialogShading && topDialog)
                 addDirtyRect(Common::Rect(0, 0, _screen.w, _screen.h), false, false);
 }
 
@@ -1123 +1116 @@
                         blitSurface(NORMAL_OFFSET, NO_EFFECT);
                 }
         } else if (alpha < 0 && alpha >= -256) {
-                int backUp = _dimPercentValue;
-                _dimPercentValue = 256 * (100 - (-alpha)) / 100;
+                int backUp = _shadingDimPercent;
+                _shadingDimPercent = 256 * (100 - (-alpha)) / 100;
 
                 if (leftRight) {
                         blitSurface(LEFT_RIGHT_OFFSET, DARKEN_EFFECT);
@@ -1132 +1125 @@
                         blitSurface(NORMAL_OFFSET, DARKEN_EFFECT);
                 }
 
-                _dimPercentValue = backUp;
+                _shadingDimPercent = backUp;
         } else {
                 if (leftRight) {
                         blitSurface(LEFT_RIGHT_OFFSET, ALPHA_EFFECT);
@@ -1416 +1409 @@
         _cursorTargetScale = _evaluator->getVar("cursor_targetScale", 1);
         
         // inactive dialog shading stuff
-        
-        ShadingStyle shading = (ShadingStyle)_evaluator->getVar("inactive_dialog_shading", kShadingNone);
+        _shadingLuminancePercent = _evaluator->getVar("shading_luminance_percent", -1);
+        if (_shadingLuminancePercent < 0) {
+                _shadingLuminancePercent = 0;
+        } else if (_shadingLuminancePercent > 100) {
+                _shadingLuminancePercent = 100;
+        }
+        _shadingLuminancePercent = 256 * _shadingLuminancePercent / 100;
 
-        switch (shading) {
-        case kShadingNone:
-                _dialogShadingCallback = 0;
-                break;
+        _shadingDimPercent = _evaluator->getVar("shading_dim_percent", -1);
+        if (_shadingDimPercent < 0) {
+                _shadingDimPercent = 0;
+        } else if (_shadingDimPercent > 100) {
+                _shadingDimPercent = 100;
+        }
+        _shadingDimPercent = 256 * (100 - _shadingDimPercent) / 100;
 
-        case kShadingLuminance:
-                _dialogShadingCallback = &ThemeModern::calcLuminance;
-                break;
-
-        case kShadingDim:
-                _dimPercentValue = _evaluator->getVar("shading_dim_percent", -1);
-
-                if (_dimPercentValue < 0) {
-                        _dimPercentValue = 0;
-                } else if (_dimPercentValue > 100) {
-                        _dimPercentValue = 100;
-                }
-                                
-                if (_dimPercentValue != 0) {
-                        _dimPercentValue = 256 * (100 - _dimPercentValue) / 100;
-                        _dialogShadingCallback = &ThemeModern::calcDimColor;
-                }
-                break;
-
-        default:
-                        warning("no valid 'inactive_dialog_shading' specified");
+        _shadingBlurRad = _evaluator->getVar("shading_blur_rad", -1);
+        if (_shadingBlurRad < 0) {
+                _shadingBlurRad = 0;
+        } else if (_shadingBlurRad > 100) {
+                _shadingBlurRad = 100;
         }
+        _dialogShading = _shadingLuminancePercent || _shadingDimPercent < 256 || _shadingBlurRad;
 
         setupFonts();
 
@@ -1460 +1446 @@
 
 #pragma mark -
 
-OverlayColor ThemeModern::calcLuminance(OverlayColor col) {
-        uint8 r, g, b;
-        _system->colorToRGB(col, r, g, b);
-
-        // A better (but slower) formula to calculate the luminance would be:
-        //uint lum = (byte)((0.299 * r + 0.587 * g + 0.114 * b) + 0.5);
-        // Note that the approximation below will only produce values between
-        // (and including) 0 and 221.
-        uint lum = (r >> 2) + (g >> 1) + (b >> 3);
-        
-        return _system->RGBToColor(lum, lum, lum);
-}
-
 OverlayColor ThemeModern::calcDimColor(OverlayColor col) {
         uint8 r, g, b;
         _system->colorToRGB(col, r, g, b);
         
-        r = r * _dimPercentValue >> 8;
-        g = g * _dimPercentValue >> 8;
-        b = b * _dimPercentValue >> 8;
+        r = r * _shadingDimPercent >> 8;
+        g = g * _shadingDimPercent >> 8;
+        b = b * _shadingDimPercent >> 8;
 
         return _system->RGBToColor(r, g, b);
 }
 
+void ThemeModern::dialogShading() {
+        OverlayColor *col = (OverlayColor*)_screen.pixels;
+
+        // Convert the whole overlay to RGB (is there a more efficient way?)
+#define pixel(x,y) (rgb + (((x) + (y) * _screen.w) * 4))
+        uint8 *rgb = new uint8[_screen.w * _screen.h * 4];
+        for (int y = 0; y < _screen.h; y++) {
+                for (int x = 0; x < _screen.w; x++) {
+                        uint8 r, g, b;
+                        _system->colorToRGB(col[x + y * _screen.w], r, g, b);
+
+                        // Luminance
+                        if (_shadingLuminancePercent > 0) {
+                                // A better (but slower) formula to calculate the luminance would be:
+                                //uint lum = (byte)((0.299 * r + 0.587 * g + 0.114 * b) + 0.5);
+                                // Note that the approximation below will only produce values between
+                                // (and including) 0 and 221.
+                                uint lum = (r >> 2) + (g >> 1) + (b >> 3);
+                                lum *= _shadingLuminancePercent;
+                                lum >>= 8;
+                                r = lum + (r * (256 - _shadingLuminancePercent) >> 8);
+                                g = lum + (g * (256 - _shadingLuminancePercent) >> 8);
+                                b = lum + (b * (256 - _shadingLuminancePercent) >> 8);
+                        }
+
+                        // Dimming
+                        if (_shadingDimPercent < 256) {
+                                r = r * _shadingDimPercent >> 8;
+                                g = g * _shadingDimPercent >> 8;
+                                b = b * _shadingDimPercent >> 8;
+                        }
+
+                        pixel(x,y)[0] = r;
+                        pixel(x,y)[1] = g;
+                        pixel(x,y)[2] = b;
+                }
+        }
+
+
+        int32 acum_r, acum_g, acum_b;
+        int count = 0;
+
+        // If we don't want to blur, we skip the horizontal blur. The vertical one
+        // actually writes back to the overlay surface.
+        if (_shadingBlurRad) {
+                // Horizontal blur in place (using original_row for substractions)
+                uint8 *original_row = new uint8[_screen.w * 4];
+                for (int y = 0; y < _screen.h; y++) {
+                        acum_r = acum_g = acum_b = 0;
+                        count = 0;
+
+                        memcpy(original_row, rgb + y * _screen.w * 4, _screen.w * 4);
+
+                        // Blur one line
+                        for (int x = -_shadingBlurRad; x < _screen.w; x++) {
+                                // Add the new pixel in the window
+                                if (x + _shadingBlurRad < _screen.w) {
+                                        count++;
+                                        acum_r += pixel(x + _shadingBlurRad, y)[0];
+                                        acum_g += pixel(x + _shadingBlurRad, y)[1];
+                                        acum_b += pixel(x + _shadingBlurRad, y)[2];
+                                }
+                                // Calculate the central pixel
+                                if (x >= 0 && x < _screen.pitch) {
+                                        pixel(x,y)[0] = acum_r / count;
+                                        pixel(x,y)[1] = acum_g / count;
+                                        pixel(x,y)[2] = acum_b / count;
+                                }
+                                // Delete the old pixel in the window
+                                if (x - _shadingBlurRad >= 0) {
+                                        count--;
+                                        // We take it from the original row (current row is half blurred)
+                                        acum_r -= original_row[(x - _shadingBlurRad) * 4 + 0];
+                                        acum_g -= original_row[(x - _shadingBlurRad) * 4 + 1];
+                                        acum_b -= original_row[(x - _shadingBlurRad) * 4 + 2];
+                                }
+                        }
+                }
+                delete [] original_row;
+        }
+
+        // Vertical blur with result to the overlay
+        for (int x = 0; x < _screen.w; x++) {
+                acum_r = acum_g = acum_b = 0;
+                count = 0;
+
+                // Blur one column
+                for (int y = -_shadingBlurRad; y <= _screen.h + _shadingBlurRad; y++) {
+                        // Add the new pixel in the window
+                        if (y + _shadingBlurRad < _screen.h) {
+                                count++;
+                                acum_r += pixel(x, y + _shadingBlurRad)[0];
+                                acum_g += pixel(x, y + _shadingBlurRad)[1];
+                                acum_b += pixel(x, y + _shadingBlurRad)[2];
+                        }
+                        // Calculate the central pixel (and draw it back to the overlay)
+                        if (y >= 0 && y < _screen.h) {
+                                col[x + y * _screen.w] = _system->RGBToColor(acum_r / count, acum_g / count, acum_b / count);
+                        }
+                                // Delete the old pixel in the window
+                        if (y - _shadingBlurRad >= 0) {
+                                count--;
+                                acum_r -= pixel(x, y - _shadingBlurRad)[0];
+                                acum_g -= pixel(x, y - _shadingBlurRad)[1];
+                                acum_b -= pixel(x, y - _shadingBlurRad)[2];
+                        }
+                }
+        }
+
+        delete [] rgb;
+
+#undef pixel
+}
+
 #pragma mark -
 
 void ThemeModern::setUpCursor() {

gui/theme.h

@@ -117 +117 @@
                 kFontStyleMax
         };
 
-        enum ShadingStyle {
-                kShadingNone,
-                kShadingDim,
-                kShadingLuminance
-        };
-
         virtual bool init() = 0;
         virtual void deinit() = 0;
 

gui/eval.cpp

@@ -279 +279 @@
         {"kFontStyleFixedNormal", Theme::kFontStyleFixedNormal},
         {"kFontStyleFixedItalic", Theme::kFontStyleFixedItalic},
 
-        {"kShadingNone", Theme::kShadingNone},
-        {"kShadingDim", Theme::kShadingDim},
-        {"kShadingLuminance", Theme::kShadingLuminance},
-
         {"false", 0},
         {"true", 1},
         {NULL, 0}

gui/ThemeModern.h

@@ -210 +210 @@
         };
 
 private:
-        int _dimPercentValue;
-        typedef OverlayColor (ThemeModern::*InactiveDialogCallback)(OverlayColor col);  
-        InactiveDialogCallback _dialogShadingCallback;
+        int _shadingLuminancePercent;
+        int _shadingDimPercent;
+        int _shadingBlurRad;
+        bool _dialogShading;
         
-        OverlayColor calcLuminance(OverlayColor col);
+        void dialogShading();
+
         OverlayColor calcDimColor(OverlayColor col);
 
         bool _useCursor;