| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2014 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "cc/trees/draw_property_utils.h" | |
| 6 | |
| 7 #include <vector> | |
| 8 | |
| 9 #include "cc/base/math_util.h" | |
| 10 #include "cc/layers/layer.h" | |
| 11 #include "cc/trees/property_tree.h" | |
| 12 #include "cc/trees/property_tree_builder.h" | |
| 13 #include "ui/gfx/geometry/rect_conversions.h" | |
| 14 | |
| 15 namespace cc { | |
| 16 | |
| 17 namespace { | |
| 18 | |
| 19 void CalculateVisibleRects( | |
| 20 const std::vector<Layer*>& layers_that_need_visible_rects, | |
| 21 const ClipTree& clip_tree, | |
| 22 const TransformTree& transform_tree) { | |
| 23 for (size_t i = 0; i < layers_that_need_visible_rects.size(); ++i) { | |
| 24 Layer* layer = layers_that_need_visible_rects[i]; | |
| 25 | |
| 26 // TODO(ajuma): Compute content_scale rather than using it. Note that for | |
| 27 // PictureLayer and PictureImageLayers, content_bounds == bounds and | |
| 28 // content_scale_x == content_scale_y == 1.0, so once impl painting is on | |
| 29 // everywhere, this code will be unnecessary. | |
| 30 gfx::Size layer_content_bounds = layer->content_bounds(); | |
| 31 float contents_scale_x = layer->contents_scale_x(); | |
| 32 float contents_scale_y = layer->contents_scale_y(); | |
| 33 const bool has_clip = layer->clip_tree_index() > 0; | |
| 34 const TransformNode* transform_node = | |
| 35 transform_tree.Node(layer->transform_tree_index()); | |
| 36 if (has_clip) { | |
| 37 const ClipNode* clip_node = clip_tree.Node(layer->clip_tree_index()); | |
| 38 const TransformNode* clip_transform_node = | |
| 39 transform_tree.Node(clip_node->data.transform_id); | |
| 40 const TransformNode* target_node = | |
| 41 transform_tree.Node(transform_node->data.content_target_id); | |
| 42 | |
| 43 gfx::Transform clip_to_target; | |
| 44 gfx::Transform content_to_target; | |
| 45 gfx::Transform target_to_content; | |
| 46 gfx::Transform target_to_layer; | |
| 47 | |
| 48 bool success = | |
| 49 transform_tree.ComputeTransform(clip_transform_node->id, | |
| 50 target_node->id, &clip_to_target) && | |
| 51 transform_tree.ComputeTransform(transform_node->id, target_node->id, | |
| 52 &content_to_target) && | |
| 53 transform_tree.ComputeTransform(target_node->id, transform_node->id, | |
| 54 &target_to_layer); | |
| 55 | |
| 56 // This should only fail if we somehow got here with a singular ancestor. | |
| 57 DCHECK(success); | |
| 58 | |
| 59 target_to_content.Scale(contents_scale_x, contents_scale_y); | |
| 60 target_to_content.Translate(-layer->offset_to_transform_parent().x(), | |
| 61 -layer->offset_to_transform_parent().y()); | |
| 62 target_to_content.PreconcatTransform(target_to_layer); | |
| 63 | |
| 64 content_to_target.Translate(layer->offset_to_transform_parent().x(), | |
| 65 layer->offset_to_transform_parent().y()); | |
| 66 content_to_target.Scale(1.0 / contents_scale_x, 1.0 / contents_scale_y); | |
| 67 | |
| 68 gfx::Rect layer_content_rect = gfx::Rect(layer_content_bounds); | |
| 69 gfx::RectF layer_content_bounds_in_target_space = | |
| 70 MathUtil::MapClippedRect(content_to_target, layer_content_rect); | |
| 71 gfx::RectF clip_rect_in_target_space; | |
| 72 if (target_node->id > clip_node->id) { | |
| 73 clip_rect_in_target_space = MathUtil::ProjectClippedRect( | |
| 74 clip_to_target, clip_node->data.combined_clip); | |
| 75 } else { | |
| 76 clip_rect_in_target_space = MathUtil::MapClippedRect( | |
| 77 clip_to_target, clip_node->data.combined_clip); | |
| 78 } | |
| 79 | |
| 80 clip_rect_in_target_space.Intersect(layer_content_bounds_in_target_space); | |
| 81 | |
| 82 gfx::Rect visible_rect = | |
| 83 gfx::ToEnclosingRect(MathUtil::ProjectClippedRect( | |
| 84 target_to_content, clip_rect_in_target_space)); | |
| 85 | |
| 86 visible_rect.Intersect(gfx::Rect(layer_content_bounds)); | |
| 87 | |
| 88 layer->set_visible_rect_from_property_trees(visible_rect); | |
| 89 } else { | |
| 90 layer->set_visible_rect_from_property_trees( | |
| 91 gfx::Rect(layer_content_bounds)); | |
| 92 } | |
| 93 } | |
| 94 } | |
| 95 | |
| 96 static bool IsRootLayerOfNewRenderingContext(Layer* layer) { | |
| 97 if (layer->parent()) | |
| 98 return !layer->parent()->Is3dSorted() && layer->Is3dSorted(); | |
| 99 return layer->Is3dSorted(); | |
| 100 } | |
| 101 | |
| 102 static inline bool LayerIsInExisting3DRenderingContext(Layer* layer) { | |
| 103 return layer->Is3dSorted() && layer->parent() && | |
| 104 layer->parent()->Is3dSorted(); | |
| 105 } | |
| 106 | |
| 107 static bool TransformToScreenIsKnown(Layer* layer, const TransformTree& tree) { | |
| 108 const TransformNode* node = tree.Node(layer->transform_tree_index()); | |
| 109 return !node->data.to_screen_is_animated; | |
| 110 } | |
| 111 | |
| 112 static bool IsLayerBackFaceExposed(Layer* layer, const TransformTree& tree) { | |
| 113 if (!TransformToScreenIsKnown(layer, tree)) | |
| 114 return false; | |
| 115 if (LayerIsInExisting3DRenderingContext(layer)) | |
| 116 return layer->draw_transform_from_property_trees(tree).IsBackFaceVisible(); | |
| 117 return layer->transform().IsBackFaceVisible(); | |
| 118 } | |
| 119 | |
| 120 static bool IsSurfaceBackFaceExposed(Layer* layer, | |
| 121 const TransformTree& tree) { | |
| 122 if (!TransformToScreenIsKnown(layer, tree)) | |
| 123 return false; | |
| 124 if (LayerIsInExisting3DRenderingContext(layer)) | |
| 125 return layer->draw_transform_from_property_trees(tree).IsBackFaceVisible(); | |
| 126 | |
| 127 if (IsRootLayerOfNewRenderingContext(layer)) | |
| 128 return layer->transform().IsBackFaceVisible(); | |
| 129 | |
| 130 // If the render_surface is not part of a new or existing rendering context, | |
| 131 // then the layers that contribute to this surface will decide back-face | |
| 132 // visibility for themselves. | |
| 133 return false; | |
| 134 } | |
| 135 | |
| 136 static bool HasSingularTransform(Layer* layer, const TransformTree& tree) { | |
| 137 const TransformNode* node = tree.Node(layer->transform_tree_index()); | |
| 138 return !node->data.is_invertible || !node->data.ancestors_are_invertible; | |
| 139 } | |
| 140 | |
| 141 static bool IsBackFaceInvisible(Layer* layer, const TransformTree& tree) { | |
| 142 Layer* backface_test_layer = layer; | |
| 143 if (layer->use_parent_backface_visibility()) { | |
| 144 DCHECK(layer->parent()); | |
| 145 DCHECK(!layer->parent()->use_parent_backface_visibility()); | |
| 146 backface_test_layer = layer->parent(); | |
| 147 } | |
| 148 return !backface_test_layer->double_sided() && | |
| 149 IsLayerBackFaceExposed(backface_test_layer, tree); | |
| 150 } | |
| 151 | |
| 152 static bool IsInvisibleDueToTransform(Layer* layer, const TransformTree& tree) { | |
| 153 return HasSingularTransform(layer, tree) || IsBackFaceInvisible(layer, tree); | |
| 154 } | |
| 155 | |
| 156 void FindLayersThatNeedVisibleRects(Layer* layer, | |
| 157 const TransformTree& tree, | |
| 158 bool subtree_is_visible_from_ancestor, | |
| 159 std::vector<Layer*>* layers_to_update) { | |
| 160 const bool layer_is_invisible = | |
| 161 (!layer->opacity() && !layer->OpacityIsAnimating() && | |
| 162 !layer->OpacityCanAnimateOnImplThread()); | |
| 163 const bool layer_is_backfacing = | |
| 164 (layer->has_render_surface() && !layer->double_sided() && | |
| 165 IsSurfaceBackFaceExposed(layer, tree)); | |
| 166 | |
| 167 const bool subtree_is_invisble = layer_is_invisible || layer_is_backfacing; | |
| 168 if (subtree_is_invisble) | |
| 169 return; | |
| 170 | |
| 171 bool layer_is_drawn = | |
| 172 layer->HasCopyRequest() || | |
| 173 (subtree_is_visible_from_ancestor && !layer->hide_layer_and_subtree()); | |
| 174 | |
| 175 if (layer_is_drawn && layer->DrawsContent()) { | |
| 176 const bool visible = !IsInvisibleDueToTransform(layer, tree); | |
| 177 if (visible) | |
| 178 layers_to_update->push_back(layer); | |
| 179 } | |
| 180 | |
| 181 for (size_t i = 0; i < layer->children().size(); ++i) { | |
| 182 FindLayersThatNeedVisibleRects(layer->children()[i].get(), | |
| 183 tree, | |
| 184 layer_is_drawn, | |
| 185 layers_to_update); | |
| 186 } | |
| 187 } | |
| 188 | |
| 189 } // namespace | |
| 190 | |
| 191 void ComputeClips(ClipTree* clip_tree, const TransformTree& transform_tree) { | |
| 192 for (int i = 0; i < static_cast<int>(clip_tree->size()); ++i) { | |
| 193 ClipNode* clip_node = clip_tree->Node(i); | |
| 194 | |
| 195 // Only descendants of a real clipping layer (i.e., not 0) may have their | |
| 196 // clip adjusted due to intersecting with an ancestor clip. | |
| 197 const bool is_clipped = clip_node->parent_id > 0; | |
| 198 if (!is_clipped) { | |
| 199 clip_node->data.combined_clip = clip_node->data.clip; | |
| 200 continue; | |
| 201 } | |
| 202 | |
| 203 ClipNode* parent_clip_node = clip_tree->parent(clip_node); | |
| 204 const TransformNode* parent_transform_node = | |
| 205 transform_tree.Node(parent_clip_node->data.transform_id); | |
| 206 const TransformNode* transform_node = | |
| 207 transform_tree.Node(clip_node->data.transform_id); | |
| 208 | |
| 209 // Clips must be combined in target space. We cannot, for example, combine | |
| 210 // clips in the space of the child clip. The reason is non-affine | |
| 211 // transforms. Say we have the following tree T->A->B->C, and B clips C, but | |
| 212 // draw into target T. It may be the case that A applies a perspective | |
| 213 // transform, and B and C are at different z positions. When projected into | |
| 214 // target space, the relative sizes and positions of B and C can shift. | |
| 215 // Since it's the relationship in target space that matters, that's where we | |
| 216 // must combine clips. | |
| 217 gfx::Transform parent_to_target; | |
| 218 gfx::Transform clip_to_target; | |
| 219 gfx::Transform target_to_clip; | |
| 220 | |
| 221 bool success = | |
| 222 transform_tree.ComputeTransform(parent_transform_node->id, | |
| 223 clip_node->data.target_id, | |
| 224 &parent_to_target) && | |
| 225 transform_tree.ComputeTransform( | |
| 226 transform_node->id, clip_node->data.target_id, &clip_to_target) && | |
| 227 transform_tree.ComputeTransform(clip_node->data.target_id, | |
| 228 transform_node->id, &target_to_clip); | |
| 229 | |
| 230 // If we can't compute a transform, it's because we had to use the inverse | |
| 231 // of a singular transform. We won't draw in this case, so there's no need | |
| 232 // to compute clips. | |
| 233 if (!success) | |
| 234 continue; | |
| 235 | |
| 236 // In order to intersect with as small a rect as possible, we do a | |
| 237 // preliminary clip in target space so that when we project back, there's | |
| 238 // less likelihood of intersecting the view plane. | |
| 239 gfx::RectF inherited_clip_in_target_space = MathUtil::MapClippedRect( | |
| 240 parent_to_target, parent_clip_node->data.combined_clip); | |
| 241 | |
| 242 gfx::RectF clip_in_target_space = | |
| 243 MathUtil::MapClippedRect(clip_to_target, clip_node->data.clip); | |
| 244 | |
| 245 gfx::RectF intersected_in_target_space = gfx::IntersectRects( | |
| 246 inherited_clip_in_target_space, clip_in_target_space); | |
| 247 | |
| 248 clip_node->data.combined_clip = MathUtil::ProjectClippedRect( | |
| 249 target_to_clip, intersected_in_target_space); | |
| 250 | |
| 251 clip_node->data.combined_clip.Intersect(clip_node->data.clip); | |
| 252 } | |
| 253 } | |
| 254 | |
| 255 void ComputeTransforms(TransformTree* transform_tree) { | |
| 256 for (int i = 1; i < static_cast<int>(transform_tree->size()); ++i) | |
| 257 transform_tree->UpdateTransforms(i); | |
| 258 } | |
| 259 | |
| 260 void ComputeVisibleRectsUsingPropertyTrees( | |
| 261 Layer* root_layer, | |
| 262 const Layer* page_scale_layer, | |
| 263 float page_scale_factor, | |
| 264 float device_scale_factor, | |
| 265 const gfx::Rect& viewport, | |
| 266 const gfx::Transform& device_transform, | |
| 267 TransformTree* transform_tree, | |
| 268 ClipTree* clip_tree, | |
| 269 OpacityTree* opacity_tree) { | |
| 270 PropertyTreeBuilder::BuildPropertyTrees( | |
| 271 root_layer, page_scale_layer, page_scale_factor, device_scale_factor, | |
| 272 viewport, device_transform, transform_tree, clip_tree, opacity_tree); | |
| 273 ComputeTransforms(transform_tree); | |
| 274 ComputeClips(clip_tree, *transform_tree); | |
| 275 | |
| 276 std::vector<Layer*> layers_to_update; | |
| 277 const bool subtree_is_visible_from_ancestor = true; | |
| 278 FindLayersThatNeedVisibleRects(root_layer, *transform_tree, | |
| 279 subtree_is_visible_from_ancestor, | |
| 280 &layers_to_update); | |
| 281 CalculateVisibleRects(layers_to_update, *clip_tree, *transform_tree); | |
| 282 } | |
| 283 | |
| 284 } // namespace cc | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1057283003:
Remove parts of //cc we aren't using (Closed)
Base URL: git@github.com:domokit/mojo.git@master