Merge lp:~afrantzis/mir/fix-1340078-occlusion into lp:mir

[Alexandros Frantzis]

compositor: Properly occlude partially on-screen surfaces (LP: #1340078)

compositor: Properly occlude partially on-screen surfaces

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:1760
http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-ci/2123/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-utopic-i386-build/899
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-utopic-amd64-build/905
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-utopic-touch/898
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-amd64-ci/644
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-amd64-ci/644/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-armhf-ci/642
        deb: http://jenkins.qa.ubuntu.com/job/mir-team-mir-development-branch-utopic-armhf-ci/642/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/2866
        deb: http://jenkins.qa.ubuntu.com/job/generic-mediumtests-builder-utopic-armhf/2866/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/2041
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/9604

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/mir-team-mir-development-branch-ci/2123/rebuild

review: Approve (continuous-integration)

[Alberto Aguirre (albaguirre)]

LGTM

review: Approve

[Alan Griffiths (alan-griffiths)]

23 + Rectangle intersection_with(Rectangle const& r) const;

Hmm, I would (slightly) prefer a free function for a symmetric operation. Vis:

Rectangle intersection_of(Rectangle const& l, Rectangle const& r);

PS
I thought briefly about operator&() but that gives an asymmetry with operator|().

review: Approve

[Kevin DuBois (kdub)]

okay

review: Approve

=== modified file 'include/shared/mir/geometry/rectangle.h'
--- include/shared/mir/geometry/rectangle.h	2014-04-23 18:51:37 +0000
+++ include/shared/mir/geometry/rectangle.h	2014-07-10 09:06:31 +0000
@@ -32,6 +32,13 @@
 
 struct Rectangle
 {
+    Rectangle() = default;
+
+    Rectangle(Point const& top_left, Size const& size)
+        : top_left{top_left}, size{size}
+    {
+    }
+
     Point top_left;
     Size size;
 
@@ -55,6 +62,8 @@
     bool contains(Rectangle const& r) const;
 
     bool overlaps(Rectangle const& r) const;
+
+    Rectangle intersection_with(Rectangle const& r) const;
 };
 
 inline bool operator == (Rectangle const& lhs, Rectangle const& rhs)

=== modified file 'src/server/compositor/occlusion.cpp'
--- src/server/compositor/occlusion.cpp	2014-06-23 17:19:22 +0000
+++ src/server/compositor/occlusion.cpp	2014-07-10 09:06:31 +0000
@@ -34,7 +34,9 @@
     Rectangle const& area,
     std::vector<Rectangle>& coverage)
 {
-    static const glm::mat4 identity;
+    static glm::mat4 const identity;
+    static Rectangle const empty{};
+
     if (renderable.transformation() != identity)
         return false;  // Weirdly transformed. Assume never occluded.
 
@@ -44,15 +46,16 @@
     if (!renderable.visible())
         return true;  //invisible; definitely occluded.
 
-    // Not weirdly transformed but also not on this monitor? Don't care...
-    if (!area.overlaps(renderable.screen_position()))
-        return true;  // Not on the display; definitely occluded.
+    auto const& window = renderable.screen_position();
+    auto const& clipped_window = window.intersection_with(area);
+
+    if (clipped_window == empty)
+        return true;  // Not in the area; definitely occluded.
 
     bool occluded = false;
-    Rectangle const& window = renderable.screen_position();
-    for (const auto &r : coverage)
+    for (auto const& r : coverage)
     {
-        if (r.contains(window))
+        if (r.contains(clipped_window))
         {
             occluded = true;
             break;
@@ -60,7 +63,7 @@
     }
 
     if (!occluded && renderable.alpha() == 1.0f && !renderable.shaped())
-        coverage.push_back(window);
+        coverage.push_back(clipped_window);
 
     return occluded;
 }

=== modified file 'src/shared/geometry/rectangle.cpp'
--- src/shared/geometry/rectangle.cpp	2014-04-21 17:18:14 +0000
+++ src/shared/geometry/rectangle.cpp	2014-07-10 09:06:31 +0000
@@ -18,7 +18,7 @@
 
 #include "mir/geometry/rectangle.h"
 
-#include <cassert>
+#include <algorithm>
 
 namespace geom = mir::geometry;
 
@@ -76,3 +76,16 @@
         return false;
     }
 }
+
+geom::Rectangle geom::Rectangle::intersection_with(Rectangle const& r) const
+{
+    int const a = std::max(top_left.x.as_int(), r.top_left.x.as_int());
+    int const b = std::min(bottom_right().x.as_int(), r.bottom_right().x.as_int());
+    int const c = std::max(top_left.y.as_int(), r.top_left.y.as_int());
+    int const d = std::min(bottom_right().y.as_int(), r.bottom_right().y.as_int());
+
+    if (a < b && c < d)
+        return {{a, c}, {b - a, d - c}};
+    else
+        return geom::Rectangle();
+}

=== modified file 'tests/unit-tests/compositor/test_occlusion.cpp'
--- tests/unit-tests/compositor/test_occlusion.cpp	2014-06-24 14:02:25 +0000
+++ tests/unit-tests/compositor/test_occlusion.cpp	2014-07-10 09:06:31 +0000
@@ -209,3 +209,19 @@
     EXPECT_THAT(renderables_from(occlusions), ElementsAre(window3, window2, window1));
     EXPECT_THAT(renderables_from(elements), ElementsAre(window5, window4, window0));
 }
+
+TEST_F(OcclusionFilterTest,
+       occludes_partially_onscreen_window_when_onscreen_part_is_covered_by_another_window)
+{
+    auto const partially_onscreen = std::make_shared<mtd::FakeRenderable>(-50, 100, 150, 100);
+    auto const covering = std::make_shared<mtd::FakeRenderable>(0, 100, 100, 100);
+    auto elements = scene_elements_from({
+        partially_onscreen,
+        covering
+    });
+
+    auto const& occlusions = filter_occlusions_from(elements, monitor_rect);
+
+    EXPECT_THAT(renderables_from(occlusions), ElementsAre(partially_onscreen));
+    EXPECT_THAT(renderables_from(elements), ElementsAre(covering));
+}

=== modified file 'tests/unit-tests/geometry/test-rectangle.cpp'
--- tests/unit-tests/geometry/test-rectangle.cpp	2013-10-15 08:53:10 +0000
+++ tests/unit-tests/geometry/test-rectangle.cpp	2014-07-10 09:06:31 +0000
@@ -21,6 +21,8 @@
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
+#include <vector>
+
 namespace geom = mir::geometry;
 
 TEST(geometry, rectangle)
@@ -195,3 +197,39 @@
     EXPECT_TRUE(rect4.overlaps(rect3));
     EXPECT_TRUE(rect3.overlaps(rect3));
 }
+
+TEST(geometry, rectangle_intersection)
+{
+    using namespace testing;
+    using namespace geom;
+
+    Rectangle const rect_base{{5,5}, {5,5}};
+
+    struct TestData
+    {
+        Rectangle const rect;
+        Rectangle const intersection;
+    };
+
+    std::vector<TestData> const test_data
+    {
+        { rect_base, rect_base },
+        { Rectangle(), Rectangle() },
+        { {{4,4}, {2,2}}, {{5,5}, {1,1}} },
+        { {{5,4}, {5,2}}, {{5,5}, {5,1}} },
+        { {{6,6}, {3,3}}, {{6,6}, {3,3}} },
+        { {{9,9}, {1,1}}, {{9,9}, {1,1}} },
+        { {{4,6}, {8,2}}, {{5,6}, {5,2}} }
+    };
+
+    for (auto const& test_case : test_data)
+    {
+        EXPECT_THAT(rect_base.intersection_with(test_case.rect),
+                    Eq(test_case.intersection))
+            << "test_case.rect = " << test_case.rect;
+
+        EXPECT_THAT(test_case.rect.intersection_with(rect_base),
+                    Eq(test_case.intersection))
+            << "test_case.rect = " << test_case.rect;
+    }
+}