OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "cc/output/overlay_strategy_sandwich.h" | 5 #include "cc/output/overlay_strategy_sandwich.h" |
6 | 6 |
| 7 #include "cc/base/math_util.h" |
7 #include "cc/base/region.h" | 8 #include "cc/base/region.h" |
8 #include "cc/output/overlay_candidate_validator.h" | 9 #include "cc/output/overlay_candidate_validator.h" |
9 #include "cc/quads/draw_quad.h" | 10 #include "cc/quads/draw_quad.h" |
10 #include "cc/quads/solid_color_draw_quad.h" | 11 #include "cc/quads/solid_color_draw_quad.h" |
11 #include "ui/gfx/geometry/dip_util.h" | 12 #include "ui/gfx/geometry/dip_util.h" |
12 #include "ui/gfx/geometry/rect_conversions.h" | 13 #include "ui/gfx/geometry/rect_conversions.h" |
13 | 14 |
14 namespace { | 15 namespace { |
15 | 16 |
16 gfx::Rect AlignPixelRectToDIP(float scale_factor, const gfx::Rect& pixel_rect) { | 17 gfx::Rect AlignPixelRectToDIP(float scale_factor, const gfx::Rect& pixel_rect) { |
17 gfx::Rect dip_rect = | 18 gfx::Rect dip_rect = |
18 gfx::ToEnclosingRect(gfx::ScaleRect(pixel_rect, 1.0f / scale_factor)); | 19 gfx::ScaleToEnclosingRect(pixel_rect, 1.0f / scale_factor); |
19 gfx::Rect new_pixel_rect = | 20 gfx::Rect new_pixel_rect = gfx::ScaleToEnclosingRect(dip_rect, scale_factor); |
20 gfx::ToEnclosingRect(gfx::ScaleRect(dip_rect, scale_factor)); | |
21 return new_pixel_rect; | 21 return new_pixel_rect; |
22 } | 22 } |
23 | 23 |
24 bool IsPixelRectAlignedToDIP(float scale_factor, const gfx::Rect& pixel_rect) { | 24 bool IsPixelRectAlignedToDIP(float scale_factor, const gfx::Rect& pixel_rect) { |
25 return (pixel_rect == AlignPixelRectToDIP(scale_factor, pixel_rect)); | 25 return (pixel_rect == AlignPixelRectToDIP(scale_factor, pixel_rect)); |
26 } | 26 } |
27 | 27 |
28 } // namespace | 28 } // namespace |
29 | 29 |
30 namespace cc { | 30 namespace cc { |
(...skipping 13 matching lines...) Expand all Loading... |
44 | 44 |
45 const DrawQuad* candidate_quad = *candidate_iter_in_quad_list; | 45 const DrawQuad* candidate_quad = *candidate_iter_in_quad_list; |
46 const gfx::Transform& candidate_transform = | 46 const gfx::Transform& candidate_transform = |
47 candidate_quad->shared_quad_state->quad_to_target_transform; | 47 candidate_quad->shared_quad_state->quad_to_target_transform; |
48 gfx::Transform candidate_inverse_transform; | 48 gfx::Transform candidate_inverse_transform; |
49 if (!candidate_transform.GetInverse(&candidate_inverse_transform)) | 49 if (!candidate_transform.GetInverse(&candidate_inverse_transform)) |
50 return false; | 50 return false; |
51 | 51 |
52 // Compute the candidate's rect in display space (pixels on the screen). The | 52 // Compute the candidate's rect in display space (pixels on the screen). The |
53 // rect needs to be DIP-aligned, or we cannot use it. | 53 // rect needs to be DIP-aligned, or we cannot use it. |
54 gfx::RectF candidate_pixel_rect_float = candidate_quad->rect; | 54 gfx::RectF candidate_pixel_rect_float = MathUtil::MapClippedRect( |
55 candidate_transform.TransformRect(&candidate_pixel_rect_float); | 55 candidate_transform, gfx::RectF(candidate_quad->rect)); |
56 gfx::Rect candidate_pixel_rect; | 56 if (!candidate_pixel_rect_float.IsExpressibleAsRect()) |
57 candidate_pixel_rect = gfx::ToEnclosingRect(candidate_pixel_rect_float); | |
58 if (candidate_pixel_rect != candidate_pixel_rect_float) | |
59 return false; | 57 return false; |
| 58 gfx::Rect candidate_pixel_rect = |
| 59 gfx::ToNearestRect(candidate_pixel_rect_float); |
60 if (!IsPixelRectAlignedToDIP(device_scale_factor, candidate_pixel_rect)) | 60 if (!IsPixelRectAlignedToDIP(device_scale_factor, candidate_pixel_rect)) |
61 return false; | 61 return false; |
62 | 62 |
63 // Iterate through the quads in front of |potential_candidate|, and compute | 63 // Iterate through the quads in front of |potential_candidate|, and compute |
64 // the region of |potential_candidate| that is covered. | 64 // the region of |potential_candidate| that is covered. |
65 Region pixel_covered_region; | 65 Region pixel_covered_region; |
66 for (auto overlap_iter = quad_list.cbegin(); | 66 for (auto overlap_iter = quad_list.cbegin(); |
67 overlap_iter != candidate_iter_in_quad_list; ++overlap_iter) { | 67 overlap_iter != candidate_iter_in_quad_list; ++overlap_iter) { |
68 if (OverlayStrategyCommon::IsInvisibleQuad(*overlap_iter)) | 68 if (OverlayStrategyCommon::IsInvisibleQuad(*overlap_iter)) |
69 continue; | 69 continue; |
70 // Compute the quad's bounds in display space, and ensure that it is rounded | 70 // Compute the quad's bounds in display space, and ensure that it is rounded |
71 // up to be DIP-aligned. | 71 // up to be DIP-aligned. |
72 gfx::RectF pixel_covered_rect_float = overlap_iter->rect; | 72 gfx::Rect unaligned_pixel_covered_rect = MathUtil::MapEnclosingClippedRect( |
73 overlap_iter->shared_quad_state->quad_to_target_transform.TransformRect( | 73 overlap_iter->shared_quad_state->quad_to_target_transform, |
74 &pixel_covered_rect_float); | 74 overlap_iter->rect); |
75 gfx::Rect pixel_covered_rect = AlignPixelRectToDIP( | 75 gfx::Rect pixel_covered_rect = |
76 device_scale_factor, gfx::ToEnclosingRect(pixel_covered_rect_float)); | 76 AlignPixelRectToDIP(device_scale_factor, unaligned_pixel_covered_rect); |
77 | 77 |
78 // Include the intersection of that quad with the candidate's quad in the | 78 // Include the intersection of that quad with the candidate's quad in the |
79 // covered region. | 79 // covered region. |
80 pixel_covered_rect.Intersect(candidate_pixel_rect); | 80 pixel_covered_rect.Intersect(candidate_pixel_rect); |
81 pixel_covered_region.Union(pixel_covered_rect); | 81 pixel_covered_region.Union(pixel_covered_rect); |
82 } | 82 } |
83 | 83 |
84 // Add our primary surface. | 84 // Add our primary surface. |
85 OverlayCandidateList new_candidate_list; | 85 OverlayCandidateList new_candidate_list; |
86 OverlayCandidate main_image; | 86 OverlayCandidate main_image; |
87 main_image.display_rect = pixel_bounds; | 87 main_image.display_rect = gfx::RectF(pixel_bounds); |
88 new_candidate_list.push_back(main_image); | 88 new_candidate_list.push_back(main_image); |
89 | 89 |
90 // Add the candidate's overlay. | 90 // Add the candidate's overlay. |
91 DCHECK(candidate.resource_id); | 91 DCHECK(candidate.resource_id); |
92 new_candidate_list.push_back(candidate); | 92 new_candidate_list.push_back(candidate); |
93 new_candidate_list.back().plane_z_order = 1; | 93 new_candidate_list.back().plane_z_order = 1; |
94 | 94 |
95 // Add an overlay of the primary surface for any part of the candidate's | 95 // Add an overlay of the primary surface for any part of the candidate's |
96 // quad that was covered. | 96 // quad that was covered. |
97 std::vector<gfx::Rect> pixel_covered_rects; | 97 std::vector<gfx::Rect> pixel_covered_rects; |
98 for (Region::Iterator it(pixel_covered_region); it.has_rect(); it.next()) { | 98 for (Region::Iterator it(pixel_covered_region); it.has_rect(); it.next()) { |
99 DCHECK(IsPixelRectAlignedToDIP(device_scale_factor, it.rect())); | 99 DCHECK(IsPixelRectAlignedToDIP(device_scale_factor, it.rect())); |
100 pixel_covered_rects.push_back(it.rect()); | 100 pixel_covered_rects.push_back(it.rect()); |
101 } | 101 } |
102 for (const gfx::Rect& pixel_covered_rect : pixel_covered_rects) { | 102 for (const gfx::Rect& pixel_covered_rect : pixel_covered_rects) { |
103 OverlayCandidate main_image_on_top; | 103 OverlayCandidate main_image_on_top; |
104 main_image_on_top.display_rect = pixel_covered_rect; | 104 main_image_on_top.display_rect = gfx::RectF(pixel_covered_rect); |
105 main_image_on_top.uv_rect = pixel_covered_rect; | 105 main_image_on_top.uv_rect = gfx::RectF(pixel_covered_rect); |
106 main_image_on_top.uv_rect.Scale(1.f / pixel_bounds.width(), | 106 main_image_on_top.uv_rect.Scale(1.f / pixel_bounds.width(), |
107 1.f / pixel_bounds.height()); | 107 1.f / pixel_bounds.height()); |
108 main_image_on_top.plane_z_order = 2; | 108 main_image_on_top.plane_z_order = 2; |
109 main_image_on_top.transform = gfx::OVERLAY_TRANSFORM_NONE; | 109 main_image_on_top.transform = gfx::OVERLAY_TRANSFORM_NONE; |
110 main_image_on_top.use_output_surface_for_resource = true; | 110 main_image_on_top.use_output_surface_for_resource = true; |
111 new_candidate_list.push_back(main_image_on_top); | 111 new_candidate_list.push_back(main_image_on_top); |
112 } | 112 } |
113 | 113 |
114 // Check for support. | 114 // Check for support. |
115 capability_checker->CheckOverlaySupport(&new_candidate_list); | 115 capability_checker->CheckOverlaySupport(&new_candidate_list); |
(...skipping 15 matching lines...) Expand all Loading... |
131 | 131 |
132 // Reserve space in the quad list for the transparent quads. | 132 // Reserve space in the quad list for the transparent quads. |
133 quad_list.ReplaceExistingElement<SolidColorDrawQuad>( | 133 quad_list.ReplaceExistingElement<SolidColorDrawQuad>( |
134 candidate_iter_in_quad_list); | 134 candidate_iter_in_quad_list); |
135 candidate_iter_in_quad_list = | 135 candidate_iter_in_quad_list = |
136 quad_list.InsertBeforeAndInvalidateAllPointers<SolidColorDrawQuad>( | 136 quad_list.InsertBeforeAndInvalidateAllPointers<SolidColorDrawQuad>( |
137 candidate_iter_in_quad_list, pixel_covered_rects.size() - 1); | 137 candidate_iter_in_quad_list, pixel_covered_rects.size() - 1); |
138 | 138 |
139 // Cover the region with transparent quads. | 139 // Cover the region with transparent quads. |
140 for (const gfx::Rect& pixel_covered_rect : pixel_covered_rects) { | 140 for (const gfx::Rect& pixel_covered_rect : pixel_covered_rects) { |
141 gfx::RectF quad_space_covered_rect_float = pixel_covered_rect; | 141 gfx::Rect quad_space_covered_rect = MathUtil::MapEnclosingClippedRect( |
142 candidate_inverse_transform.TransformRect(&quad_space_covered_rect_float); | 142 candidate_inverse_transform, pixel_covered_rect); |
143 gfx::Rect quad_space_covered_rect = | |
144 gfx::ToEnclosingRect(quad_space_covered_rect_float); | |
145 quad_space_covered_rect.Intersect(candidate_rect); | 143 quad_space_covered_rect.Intersect(candidate_rect); |
146 | 144 |
147 SolidColorDrawQuad* transparent_quad = | 145 SolidColorDrawQuad* transparent_quad = |
148 static_cast<SolidColorDrawQuad*>(*candidate_iter_in_quad_list); | 146 static_cast<SolidColorDrawQuad*>(*candidate_iter_in_quad_list); |
149 transparent_quad->SetAll(candidate_shared_quad_state, | 147 transparent_quad->SetAll(candidate_shared_quad_state, |
150 quad_space_covered_rect, quad_space_covered_rect, | 148 quad_space_covered_rect, quad_space_covered_rect, |
151 quad_space_covered_rect, false, | 149 quad_space_covered_rect, false, |
152 SK_ColorTRANSPARENT, true); | 150 SK_ColorTRANSPARENT, true); |
153 ++candidate_iter_in_quad_list; | 151 ++candidate_iter_in_quad_list; |
154 } | 152 } |
155 } | 153 } |
156 | 154 |
157 output_candidate_list->swap(new_candidate_list); | 155 output_candidate_list->swap(new_candidate_list); |
158 return true; | 156 return true; |
159 } | 157 } |
160 | 158 |
161 } // namespace cc | 159 } // namespace cc |
OLD | NEW |