Index: cc/trees/draw_property_utils.cc |
diff --git a/cc/trees/draw_property_utils.cc b/cc/trees/draw_property_utils.cc |
index a000ec6a8e218b46c02651668eaffaf9fd891dfc..a3fa4b5b0e8ef3a87199dc75e4db29d28449cb37 100644 |
--- a/cc/trees/draw_property_utils.cc |
+++ b/cc/trees/draw_property_utils.cc |
@@ -7,8 +7,10 @@ |
#include <vector> |
#include "cc/base/math_util.h" |
+#include "cc/layers/draw_properties.h" |
#include "cc/layers/layer.h" |
#include "cc/layers/layer_impl.h" |
+#include "cc/layers/render_surface_draw_properties.h" |
#include "cc/trees/layer_tree_impl.h" |
#include "cc/trees/property_tree.h" |
#include "cc/trees/property_tree_builder.h" |
@@ -630,9 +632,7 @@ void ComputeVisibleRectsUsingPropertyTrees(LayerImpl* root_layer, |
template <typename LayerType> |
gfx::Transform DrawTransformFromPropertyTreesInternal( |
const LayerType* layer, |
- const TransformTree& tree) { |
- const TransformNode* node = tree.Node(layer->transform_tree_index()); |
- |
+ const TransformNode* node) { |
gfx::Transform xform; |
const bool owns_non_root_surface = |
layer->parent() && layer->has_render_surface(); |
@@ -653,17 +653,18 @@ gfx::Transform DrawTransformFromPropertyTreesInternal( |
gfx::Transform DrawTransformFromPropertyTrees(const Layer* layer, |
const TransformTree& tree) { |
- return DrawTransformFromPropertyTreesInternal(layer, tree); |
+ return DrawTransformFromPropertyTreesInternal( |
+ layer, tree.Node(layer->transform_tree_index())); |
} |
gfx::Transform DrawTransformFromPropertyTrees(const LayerImpl* layer, |
const TransformTree& tree) { |
- return DrawTransformFromPropertyTreesInternal(layer, tree); |
+ return DrawTransformFromPropertyTreesInternal( |
+ layer, tree.Node(layer->transform_tree_index())); |
} |
-gfx::Transform DrawTransformOfRenderSurfaceFromPropertyTrees( |
- const RenderSurfaceImpl* render_surface, |
- const TransformTree& tree) { |
+gfx::Transform SurfaceDrawTransform(const RenderSurfaceImpl* render_surface, |
+ const TransformTree& tree) { |
const TransformNode* node = tree.Node(render_surface->TransformTreeIndex()); |
gfx::Transform render_surface_transform; |
// The draw transform of root render surface is identity tranform. |
@@ -681,28 +682,24 @@ gfx::Transform DrawTransformOfRenderSurfaceFromPropertyTrees( |
return render_surface_transform; |
} |
-bool RenderSurfaceIsClippedFromPropertyTrees( |
- const RenderSurfaceImpl* render_surface, |
- const ClipTree& tree) { |
- const ClipNode* node = tree.Node(render_surface->ClipTreeIndex()); |
+bool SurfaceIsClipped(const RenderSurfaceImpl* render_surface, |
+ const ClipNode* clip_node) { |
// If the render surface's owning layer doesn't form a clip node, it is not |
// clipped. |
- if (render_surface->OwningLayerId() != node->owner_id) |
+ if (render_surface->OwningLayerId() != clip_node->owner_id) |
return false; |
- return node->data.render_surface_is_clipped; |
+ return clip_node->data.render_surface_is_clipped; |
} |
-gfx::Rect ClipRectOfRenderSurfaceFromPropertyTrees( |
- const RenderSurfaceImpl* render_surface, |
- const ClipTree& clip_tree) { |
- if (!RenderSurfaceIsClippedFromPropertyTrees(render_surface, clip_tree)) |
+gfx::Rect SurfaceClipRect(const RenderSurfaceImpl* render_surface, |
+ const ClipNode* parent_clip_node, |
+ bool is_clipped) { |
+ if (!is_clipped) |
return gfx::Rect(); |
- const ClipNode* clip_node = clip_tree.Node(render_surface->ClipTreeIndex()); |
- const ClipNode* parent_clip_node = clip_tree.parent(clip_node); |
return gfx::ToEnclosingRect(parent_clip_node->data.clip_in_target_space); |
} |
-gfx::Transform ScreenSpaceTransformOfRenderSurfaceFromPropertyTrees( |
+gfx::Transform SurfaceScreenSpaceTransform( |
const RenderSurfaceImpl* render_surface, |
const TransformTree& tree) { |
const TransformNode* node = tree.Node(render_surface->TransformTreeIndex()); |
@@ -721,74 +718,31 @@ gfx::Transform ScreenSpaceTransformOfRenderSurfaceFromPropertyTrees( |
template <typename LayerType> |
gfx::Transform ScreenSpaceTransformFromPropertyTreesInternal( |
LayerType* layer, |
- const TransformTree& tree) { |
+ const TransformNode* node) { |
gfx::Transform xform(1, 0, 0, 1, layer->offset_to_transform_parent().x(), |
layer->offset_to_transform_parent().y()); |
- if (layer->transform_tree_index() >= 0) { |
- gfx::Transform ssxform = |
- tree.Node(layer->transform_tree_index())->data.to_screen; |
- xform.ConcatTransform(ssxform); |
- if (layer->should_flatten_transform_from_property_tree()) |
- xform.FlattenTo2d(); |
- } |
+ gfx::Transform ssxform = node->data.to_screen; |
+ xform.ConcatTransform(ssxform); |
+ if (layer->should_flatten_transform_from_property_tree()) |
+ xform.FlattenTo2d(); |
return xform; |
} |
gfx::Transform ScreenSpaceTransformFromPropertyTrees( |
const Layer* layer, |
const TransformTree& tree) { |
- return ScreenSpaceTransformFromPropertyTreesInternal(layer, tree); |
+ return ScreenSpaceTransformFromPropertyTreesInternal( |
+ layer, tree.Node(layer->transform_tree_index())); |
} |
gfx::Transform ScreenSpaceTransformFromPropertyTrees( |
const LayerImpl* layer, |
const TransformTree& tree) { |
- return ScreenSpaceTransformFromPropertyTreesInternal(layer, tree); |
+ return ScreenSpaceTransformFromPropertyTreesInternal( |
+ layer, tree.Node(layer->transform_tree_index())); |
} |
-template <typename LayerType> |
-bool ScreenSpaceTransformIsAnimatingFromPropertyTreesInternal( |
- LayerType* layer, |
- const TransformTree& tree) { |
- return tree.Node(layer->transform_tree_index())->data.to_screen_is_animated; |
-} |
- |
-bool ScreenSpaceTransformIsAnimatingFromPropertyTrees( |
- const Layer* layer, |
- const TransformTree& tree) { |
- return ScreenSpaceTransformIsAnimatingFromPropertyTreesInternal(layer, tree); |
-} |
- |
-bool ScreenSpaceTransformIsAnimatingFromPropertyTrees( |
- const LayerImpl* layer, |
- const TransformTree& tree) { |
- return ScreenSpaceTransformIsAnimatingFromPropertyTreesInternal(layer, tree); |
-} |
- |
-float MaximumAnimationTargetScaleFromPropertyTrees(const LayerImpl* layer, |
- const TransformTree& tree) { |
- if (!layer->layer_tree_impl() |
- ->settings() |
- .layer_transforms_should_scale_layer_contents) |
- return 0.f; |
- |
- return tree.Node(layer->transform_tree_index()) |
- ->data.combined_maximum_animation_target_scale; |
-} |
- |
-float StartingAnimationScaleFromPropertyTrees(const LayerImpl* layer, |
- const TransformTree& tree) { |
- if (!layer->layer_tree_impl() |
- ->settings() |
- .layer_transforms_should_scale_layer_contents) |
- return 0.f; |
- |
- return tree.Node(layer->transform_tree_index()) |
- ->data.combined_starting_animation_scale; |
-} |
- |
-float DrawOpacityFromPropertyTrees(const LayerImpl* layer, |
- const EffectTree& tree) { |
+float LayerDrawOpacity(const LayerImpl* layer, const EffectTree& tree) { |
if (!layer->render_target()) |
return 0.f; |
@@ -806,9 +760,8 @@ float DrawOpacityFromPropertyTrees(const LayerImpl* layer, |
return draw_opacity; |
} |
-float DrawOpacityOfRenderSurfaceFromPropertyTrees( |
- RenderSurfaceImpl* render_surface, |
- const EffectTree& tree) { |
+float SurfaceDrawOpacity(RenderSurfaceImpl* render_surface, |
+ const EffectTree& tree) { |
const EffectNode* node = tree.Node(render_surface->EffectTreeIndex()); |
float target_opacity_tree_index = render_surface->TargetEffectTreeIndex(); |
if (target_opacity_tree_index < 0) |
@@ -822,25 +775,20 @@ float DrawOpacityOfRenderSurfaceFromPropertyTrees( |
return draw_opacity; |
} |
-bool CanUseLcdTextFromPropertyTrees(const LayerImpl* layer, |
- bool layers_always_allowed_lcd_text, |
- bool can_use_lcd_text, |
- PropertyTrees* property_trees) { |
+bool LayerCanUseLcdText(const LayerImpl* layer, |
+ bool layers_always_allowed_lcd_text, |
+ bool can_use_lcd_text, |
+ const TransformNode* transform_node, |
+ const EffectNode* effect_node) { |
if (layers_always_allowed_lcd_text) |
return true; |
if (!can_use_lcd_text) |
return false; |
if (!layer->contents_opaque()) |
return false; |
- DCHECK(!property_trees->transform_tree.needs_update()); |
- DCHECK(!property_trees->effect_tree.needs_update()); |
- const EffectNode* opacity_node = |
- property_trees->effect_tree.Node(layer->effect_tree_index()); |
- if (opacity_node->data.screen_space_opacity != 1.f) |
+ if (effect_node->data.screen_space_opacity != 1.f) |
return false; |
- const TransformNode* transform_node = |
- property_trees->transform_tree.Node(layer->transform_tree_index()); |
if (!transform_node->data.node_and_ancestors_have_only_integer_translation) |
return false; |
if (static_cast<int>(layer->offset_to_transform_parent().x()) != |
@@ -852,43 +800,14 @@ bool CanUseLcdTextFromPropertyTrees(const LayerImpl* layer, |
return true; |
} |
-gfx::Rect DrawableContentRectOfSurfaceFromPropertyTrees( |
- const RenderSurfaceImpl* render_surface, |
- const TransformTree& transform_tree) { |
- gfx::Rect drawable_content_rect = |
- gfx::ToEnclosingRect(MathUtil::MapClippedRect( |
- DrawTransformOfRenderSurfaceFromPropertyTrees(render_surface, |
- transform_tree), |
- render_surface->content_rect_from_property_trees())); |
- if (render_surface->HasReplica()) { |
- drawable_content_rect.Union(gfx::ToEnclosingRect(MathUtil::MapClippedRect( |
- DrawTransformOfRenderSurfaceReplicaFromPropertyTrees(render_surface, |
- transform_tree), |
- render_surface->content_rect_from_property_trees()))); |
- } |
- return drawable_content_rect; |
-} |
- |
-gfx::Rect DrawableContentRectFromPropertyTrees( |
+gfx::Rect LayerDrawableContentRect( |
const LayerImpl* layer, |
- const TransformTree& transform_tree) { |
- gfx::Rect drawable_content_rect = MathUtil::MapEnclosingClippedRect( |
- DrawTransformFromPropertyTrees(layer, transform_tree), |
- gfx::Rect(layer->bounds())); |
- if (layer->is_clipped()) { |
- drawable_content_rect.Intersect( |
- layer->clip_rect_in_target_space_from_property_trees()); |
- } |
- return drawable_content_rect; |
-} |
- |
-gfx::Rect ClipRectFromPropertyTrees(const LayerImpl* layer, |
- const TransformTree& transform_tree) { |
+ const gfx::Rect& layer_bounds_in_target_space, |
+ const gfx::Rect& clip_rect) { |
if (layer->is_clipped()) |
- return layer->clip_rect_in_target_space_from_property_trees(); |
- return MathUtil::MapEnclosingClippedRect( |
- DrawTransformFromPropertyTrees(layer, transform_tree), |
- gfx::Rect(layer->bounds())); |
+ return IntersectRects(layer_bounds_in_target_space, clip_rect); |
+ |
+ return layer_bounds_in_target_space; |
} |
gfx::Transform ReplicaToSurfaceTransform( |
@@ -918,23 +837,89 @@ gfx::Transform ReplicaToSurfaceTransform( |
return replica_to_surface; |
} |
-gfx::Transform DrawTransformOfRenderSurfaceReplicaFromPropertyTrees( |
- const RenderSurfaceImpl* render_surface, |
- const TransformTree& tree) { |
- if (!render_surface->HasReplica()) |
- return gfx::Transform(); |
- return DrawTransformOfRenderSurfaceFromPropertyTrees(render_surface, tree) * |
- ReplicaToSurfaceTransform(render_surface, tree); |
+gfx::Rect LayerClipRect(const LayerImpl* layer, |
+ const gfx::Rect& layer_bounds_in_target_space) { |
+ if (layer->is_clipped()) |
+ return layer->clip_rect_in_target_space_from_property_trees(); |
+ |
+ return layer_bounds_in_target_space; |
} |
-gfx::Transform ScreenSpaceTransformOfRenderSurfaceReplicaFromPropertyTrees( |
- const RenderSurfaceImpl* render_surface, |
- const TransformTree& tree) { |
- if (!render_surface->HasReplica()) |
- return gfx::Transform(); |
- return ScreenSpaceTransformOfRenderSurfaceFromPropertyTrees(render_surface, |
- tree) * |
- ReplicaToSurfaceTransform(render_surface, tree); |
+void ComputeLayerDrawPropertiesUsingPropertyTrees( |
+ const LayerImpl* layer, |
+ const PropertyTrees* property_trees, |
+ bool layers_always_allowed_lcd_text, |
+ bool can_use_lcd_text, |
+ DrawProperties* draw_properties) { |
+ draw_properties->visible_layer_rect = |
+ layer->visible_rect_from_property_trees(); |
+ |
+ const TransformNode* transform_node = |
+ property_trees->transform_tree.Node(layer->transform_tree_index()); |
+ const EffectNode* effect_node = |
+ property_trees->effect_tree.Node(layer->effect_tree_index()); |
+ |
+ draw_properties->target_space_transform = |
+ DrawTransformFromPropertyTreesInternal(layer, transform_node); |
+ draw_properties->screen_space_transform = |
+ ScreenSpaceTransformFromPropertyTreesInternal(layer, transform_node); |
+ draw_properties->screen_space_transform_is_animating = |
+ transform_node->data.to_screen_is_animated; |
+ if (layer->layer_tree_impl() |
+ ->settings() |
+ .layer_transforms_should_scale_layer_contents) { |
+ draw_properties->maximum_animation_contents_scale = |
+ transform_node->data.combined_maximum_animation_target_scale; |
+ draw_properties->starting_animation_contents_scale = |
+ transform_node->data.combined_starting_animation_scale; |
+ } else { |
+ draw_properties->maximum_animation_contents_scale = 0.f; |
+ draw_properties->starting_animation_contents_scale = 0.f; |
+ } |
+ |
+ draw_properties->opacity = |
+ LayerDrawOpacity(layer, property_trees->effect_tree); |
+ draw_properties->can_use_lcd_text = |
+ LayerCanUseLcdText(layer, layers_always_allowed_lcd_text, |
+ can_use_lcd_text, transform_node, effect_node); |
+ |
+ gfx::Rect bounds_in_target_space = MathUtil::MapEnclosingClippedRect( |
+ draw_properties->target_space_transform, gfx::Rect(layer->bounds())); |
+ draw_properties->clip_rect = LayerClipRect(layer, bounds_in_target_space); |
+ draw_properties->drawable_content_rect = LayerDrawableContentRect( |
+ layer, bounds_in_target_space, draw_properties->clip_rect); |
+} |
+ |
+void ComputeSurfaceDrawPropertiesUsingPropertyTrees( |
+ RenderSurfaceImpl* render_surface, |
+ const PropertyTrees* property_trees, |
+ RenderSurfaceDrawProperties* draw_properties) { |
+ const ClipNode* clip_node = |
+ property_trees->clip_tree.Node(render_surface->ClipTreeIndex()); |
+ |
+ draw_properties->is_clipped = SurfaceIsClipped(render_surface, clip_node); |
+ draw_properties->draw_opacity = |
+ SurfaceDrawOpacity(render_surface, property_trees->effect_tree); |
+ draw_properties->draw_transform = |
+ SurfaceDrawTransform(render_surface, property_trees->transform_tree); |
+ draw_properties->screen_space_transform = SurfaceScreenSpaceTransform( |
+ render_surface, property_trees->transform_tree); |
+ |
+ if (render_surface->HasReplica()) { |
+ gfx::Transform replica_to_surface = ReplicaToSurfaceTransform( |
+ render_surface, property_trees->transform_tree); |
+ draw_properties->replica_draw_transform = |
+ draw_properties->draw_transform * replica_to_surface; |
+ draw_properties->replica_screen_space_transform = |
+ draw_properties->screen_space_transform * replica_to_surface; |
+ } else { |
+ draw_properties->replica_draw_transform.MakeIdentity(); |
+ draw_properties->replica_screen_space_transform.MakeIdentity(); |
+ } |
+ |
+ draw_properties->clip_rect = SurfaceClipRect( |
+ render_surface, property_trees->clip_tree.parent(clip_node), |
+ draw_properties->is_clipped); |
} |
} // namespace cc |