OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 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 | 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/trees/draw_property_utils.h" | 5 #include "cc/trees/draw_property_utils.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 | 8 |
9 #include <vector> | 9 #include <vector> |
10 | 10 |
(...skipping 91 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
102 for_visible_rect_calculation ? clip_node->combined_clip_in_target_space | 102 for_visible_rect_calculation ? clip_node->combined_clip_in_target_space |
103 : clip_node->clip_in_target_space; | 103 : clip_node->clip_in_target_space; |
104 | 104 |
105 if (clip_node->target_transform_id > target_node_id) { | 105 if (clip_node->target_transform_id > target_node_id) { |
106 // In this case, layer has a scroll parent. We need to keep the scale | 106 // In this case, layer has a scroll parent. We need to keep the scale |
107 // at the layer's target but remove the scale at the scroll parent's | 107 // at the layer's target but remove the scale at the scroll parent's |
108 // target. | 108 // target. |
109 if (property_trees->ComputeTransformToTarget(clip_node->target_transform_id, | 109 if (property_trees->ComputeTransformToTarget(clip_node->target_transform_id, |
110 target_effect_node->id, | 110 target_effect_node->id, |
111 &clip_to_target)) { | 111 &clip_to_target)) { |
112 // We don't have to apply surface contents scale when target is root. | 112 PostConcatSurfaceContentsScale(target_effect_node, &clip_to_target); |
113 if (target_effect_node->id != EffectTree::kContentsRootNodeId) { | |
114 PostConcatSurfaceContentsScale(target_effect_node, &clip_to_target); | |
115 #if DCHECK_IS_ON() | 113 #if DCHECK_IS_ON() |
116 const TransformTree& transform_tree = property_trees->transform_tree; | 114 const TransformTree& transform_tree = property_trees->transform_tree; |
117 VerifySurfaceContentsScalesMatch(layer->effect_tree_index(), | 115 VerifySurfaceContentsScalesMatch(layer->effect_tree_index(), |
118 target_node_id, effect_tree, | 116 target_node_id, effect_tree, |
119 transform_tree); | 117 transform_tree); |
120 #endif | 118 #endif |
121 } | |
122 | 119 |
123 const EffectNode* source_node = | 120 const EffectNode* source_node = |
124 effect_tree.Node(clip_node->target_effect_id); | 121 effect_tree.Node(clip_node->target_effect_id); |
125 ConcatInverseSurfaceContentsScale(source_node, &clip_to_target); | 122 ConcatInverseSurfaceContentsScale(source_node, &clip_to_target); |
126 #if DCHECK_IS_ON() | 123 #if DCHECK_IS_ON() |
127 const TransformTree& transform_tree = property_trees->transform_tree; | |
128 VerifySurfaceContentsScalesMatch(clip_node->target_effect_id, | 124 VerifySurfaceContentsScalesMatch(clip_node->target_effect_id, |
129 clip_node->target_transform_id, | 125 clip_node->target_transform_id, |
130 effect_tree, transform_tree); | 126 effect_tree, transform_tree); |
131 #endif | 127 #endif |
132 *clip_rect_in_target_space = | 128 *clip_rect_in_target_space = |
133 MathUtil::MapClippedRect(clip_to_target, clip_from_clip_node); | 129 MathUtil::MapClippedRect(clip_to_target, clip_from_clip_node); |
134 } else { | 130 } else { |
135 return false; | 131 return false; |
136 } | 132 } |
137 } else { | 133 } else { |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
176 } | 172 } |
177 | 173 |
178 static ConditionalClip ComputeLocalRectInTargetSpace( | 174 static ConditionalClip ComputeLocalRectInTargetSpace( |
179 gfx::RectF rect, | 175 gfx::RectF rect, |
180 const PropertyTrees* property_trees, | 176 const PropertyTrees* property_trees, |
181 int current_transform_id, | 177 int current_transform_id, |
182 int target_transform_id, | 178 int target_transform_id, |
183 int target_effect_id) { | 179 int target_effect_id) { |
184 gfx::Transform current_to_target; | 180 gfx::Transform current_to_target; |
185 if (!property_trees->ComputeTransformToTarget( | 181 if (!property_trees->ComputeTransformToTarget( |
186 current_transform_id, target_effect_id, ¤t_to_target)) | 182 current_transform_id, target_effect_id, ¤t_to_target)) { |
187 // If transform is not invertible, cannot apply clip. | 183 // If transform is not invertible, cannot apply clip. |
188 return ConditionalClip{false, gfx::RectF()}; | 184 return ConditionalClip{false, gfx::RectF()}; |
189 // We don't have to apply surface contents scale when target is root. | 185 } |
190 if (target_effect_id != EffectTree::kContentsRootNodeId) { | 186 const EffectTree& effect_tree = property_trees->effect_tree; |
191 const EffectTree& effect_tree = property_trees->effect_tree; | 187 const EffectNode* target_effect_node = effect_tree.Node(target_effect_id); |
192 const EffectNode* target_effect_node = effect_tree.Node(target_effect_id); | 188 PostConcatSurfaceContentsScale(target_effect_node, ¤t_to_target); |
193 PostConcatSurfaceContentsScale(target_effect_node, ¤t_to_target); | |
194 #if DCHECK_IS_ON() | 189 #if DCHECK_IS_ON() |
195 const TransformTree& transform_tree = property_trees->transform_tree; | 190 const TransformTree& transform_tree = property_trees->transform_tree; |
196 VerifySurfaceContentsScalesMatch(target_effect_id, target_transform_id, | 191 VerifySurfaceContentsScalesMatch(target_effect_id, target_transform_id, |
197 effect_tree, transform_tree); | 192 effect_tree, transform_tree); |
198 #endif | 193 #endif |
199 } | |
200 | 194 |
201 if (current_transform_id > target_transform_id) | 195 if (current_transform_id > target_transform_id) |
202 return ConditionalClip{true, // is_clipped. | 196 return ConditionalClip{true, // is_clipped. |
203 MathUtil::MapClippedRect(current_to_target, rect)}; | 197 MathUtil::MapClippedRect(current_to_target, rect)}; |
204 | 198 |
205 return ConditionalClip{true, // is_clipped. | 199 return ConditionalClip{true, // is_clipped. |
206 MathUtil::ProjectClippedRect(current_to_target, rect)}; | 200 MathUtil::ProjectClippedRect(current_to_target, rect)}; |
207 } | 201 } |
208 | 202 |
209 static ConditionalClip ComputeCurrentClip(const ClipNode* clip_node, | 203 static ConditionalClip ComputeCurrentClip(const ClipNode* clip_node, |
210 const PropertyTrees* property_trees, | 204 const PropertyTrees* property_trees, |
211 int target_transform_id, | 205 int target_transform_id, |
212 int target_effect_id) { | 206 int target_effect_id) { |
213 if (clip_node->transform_id != target_transform_id) | 207 if (clip_node->transform_id != target_transform_id) |
214 return ComputeLocalRectInTargetSpace(clip_node->clip, property_trees, | 208 return ComputeLocalRectInTargetSpace(clip_node->clip, property_trees, |
215 clip_node->transform_id, | 209 clip_node->transform_id, |
216 target_transform_id, target_effect_id); | 210 target_transform_id, target_effect_id); |
217 | 211 |
218 const EffectTree& effect_tree = property_trees->effect_tree; | 212 const EffectTree& effect_tree = property_trees->effect_tree; |
219 gfx::RectF current_clip = clip_node->clip; | 213 gfx::RectF current_clip = clip_node->clip; |
220 gfx::Vector2dF surface_contents_scale = | 214 gfx::Vector2dF surface_contents_scale = |
221 effect_tree.Node(target_effect_id)->surface_contents_scale; | 215 effect_tree.Node(target_effect_id)->surface_contents_scale; |
222 if (surface_contents_scale.x() > 0 && surface_contents_scale.y() > 0) | 216 // The viewport clip should not be scaled |
| 217 if (surface_contents_scale.x() > 0 && surface_contents_scale.y() > 0 && |
| 218 clip_node->transform_id != TransformTree::kRootNodeId) |
223 current_clip.Scale(surface_contents_scale.x(), surface_contents_scale.y()); | 219 current_clip.Scale(surface_contents_scale.x(), surface_contents_scale.y()); |
224 return ConditionalClip{true /* is_clipped */, current_clip}; | 220 return ConditionalClip{true /* is_clipped */, current_clip}; |
225 } | 221 } |
226 | 222 |
227 static ConditionalClip ComputeAccumulatedClip( | 223 static ConditionalClip ComputeAccumulatedClip( |
228 const PropertyTrees* property_trees, | 224 const PropertyTrees* property_trees, |
229 bool include_clip_applied_by_target, | 225 bool include_clip_applied_by_target, |
230 int local_clip_id, | 226 int local_clip_id, |
231 int target_id) { | 227 int target_id) { |
232 const ClipTree& clip_tree = property_trees->clip_tree; | 228 const ClipTree& clip_tree = property_trees->clip_tree; |
(...skipping 292 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
525 ContentsTargetEffectNode(layer->effect_tree_index(), effect_tree); | 521 ContentsTargetEffectNode(layer->effect_tree_index(), effect_tree); |
526 bool success = property_trees->ComputeTransformFromTarget( | 522 bool success = property_trees->ComputeTransformFromTarget( |
527 transform_node->id, target_effect_node->id, &target_to_layer); | 523 transform_node->id, target_effect_node->id, &target_to_layer); |
528 if (!success) { | 524 if (!success) { |
529 // An animated singular transform may become non-singular during the | 525 // An animated singular transform may become non-singular during the |
530 // animation, so we still need to compute a visible rect. In this | 526 // animation, so we still need to compute a visible rect. In this |
531 // situation, we treat the entire layer as visible. | 527 // situation, we treat the entire layer as visible. |
532 layer->set_visible_layer_rect(gfx::Rect(layer_bounds)); | 528 layer->set_visible_layer_rect(gfx::Rect(layer_bounds)); |
533 continue; | 529 continue; |
534 } | 530 } |
535 if (target_effect_node->id > EffectTree::kContentsRootNodeId) { | 531 ConcatInverseSurfaceContentsScale(target_effect_node, &target_to_layer); |
536 ConcatInverseSurfaceContentsScale(target_effect_node, &target_to_layer); | |
537 #if DCHECK_IS_ON() | 532 #if DCHECK_IS_ON() |
538 VerifySurfaceContentsScalesMatch(target_effect_node->id, target_node_id, | 533 VerifySurfaceContentsScalesMatch(target_effect_node->id, target_node_id, |
539 effect_tree, transform_tree); | 534 effect_tree, transform_tree); |
540 #endif | 535 #endif |
541 } | |
542 } | 536 } |
543 gfx::Transform target_to_content; | 537 gfx::Transform target_to_content; |
544 target_to_content.Translate(-layer->offset_to_transform_parent().x(), | 538 target_to_content.Translate(-layer->offset_to_transform_parent().x(), |
545 -layer->offset_to_transform_parent().y()); | 539 -layer->offset_to_transform_parent().y()); |
546 target_to_content.PreconcatTransform(target_to_layer); | 540 target_to_content.PreconcatTransform(target_to_layer); |
547 | 541 |
548 gfx::Rect visible_rect = gfx::ToEnclosingRect(MathUtil::ProjectClippedRect( | 542 gfx::Rect visible_rect = gfx::ToEnclosingRect(MathUtil::ProjectClippedRect( |
549 target_to_content, combined_clip_rect_in_target_space)); | 543 target_to_content, combined_clip_rect_in_target_space)); |
550 visible_rect.Intersect(gfx::Rect(layer_bounds)); | 544 visible_rect.Intersect(gfx::Rect(layer_bounds)); |
551 layer->set_visible_layer_rect(visible_rect); | 545 layer->set_visible_layer_rect(visible_rect); |
(...skipping 258 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
810 gfx::RectF parent_combined_clip_in_target_space = | 804 gfx::RectF parent_combined_clip_in_target_space = |
811 parent_clip_node->combined_clip_in_target_space; | 805 parent_clip_node->combined_clip_in_target_space; |
812 gfx::RectF parent_clip_in_target_space = | 806 gfx::RectF parent_clip_in_target_space = |
813 parent_clip_node->clip_in_target_space; | 807 parent_clip_node->clip_in_target_space; |
814 if (parent_target_transform_node && | 808 if (parent_target_transform_node && |
815 parent_target_transform_node->id != clip_node->target_transform_id && | 809 parent_target_transform_node->id != clip_node->target_transform_id && |
816 non_root_surfaces_enabled) { | 810 non_root_surfaces_enabled) { |
817 success &= property_trees->ComputeTransformFromTarget( | 811 success &= property_trees->ComputeTransformFromTarget( |
818 clip_node->target_transform_id, parent_clip_node->target_effect_id, | 812 clip_node->target_transform_id, parent_clip_node->target_effect_id, |
819 &parent_to_current); | 813 &parent_to_current); |
820 // We don't have to apply surface contents scale when target is root. | 814 const EffectNode* target_effect_node = |
821 if (clip_node->target_effect_id != EffectTree::kContentsRootNodeId) { | 815 effect_tree.Node(clip_node->target_effect_id); |
822 const EffectNode* target_effect_node = | 816 PostConcatSurfaceContentsScale(target_effect_node, &parent_to_current); |
823 effect_tree.Node(clip_node->target_effect_id); | |
824 PostConcatSurfaceContentsScale(target_effect_node, &parent_to_current); | |
825 #if DCHECK_IS_ON() | 817 #if DCHECK_IS_ON() |
826 VerifySurfaceContentsScalesMatch(clip_node->target_effect_id, | 818 VerifySurfaceContentsScalesMatch(clip_node->target_effect_id, |
827 clip_node->target_transform_id, | 819 clip_node->target_transform_id, |
828 effect_tree, transform_tree); | 820 effect_tree, transform_tree); |
829 #endif | 821 #endif |
830 } | 822 const EffectNode* parent_target_effect_node = |
831 if (parent_clip_node->target_effect_id != | 823 effect_tree.Node(parent_clip_node->target_effect_id); |
832 EffectTree::kContentsRootNodeId) { | 824 ConcatInverseSurfaceContentsScale(parent_target_effect_node, |
833 const EffectNode* parent_target_effect_node = | 825 &parent_to_current); |
834 effect_tree.Node(parent_clip_node->target_effect_id); | |
835 ConcatInverseSurfaceContentsScale(parent_target_effect_node, | |
836 &parent_to_current); | |
837 #if DCHECK_IS_ON() | 826 #if DCHECK_IS_ON() |
838 VerifySurfaceContentsScalesMatch(parent_clip_node->target_effect_id, | 827 VerifySurfaceContentsScalesMatch(parent_clip_node->target_effect_id, |
839 parent_clip_node->target_transform_id, | 828 parent_clip_node->target_transform_id, |
840 effect_tree, transform_tree); | 829 effect_tree, transform_tree); |
841 #endif | 830 #endif |
842 } | |
843 // If we can't compute a transform, it's because we had to use the inverse | 831 // If we can't compute a transform, it's because we had to use the inverse |
844 // of a singular transform. We won't draw in this case, so there's no need | 832 // of a singular transform. We won't draw in this case, so there's no need |
845 // to compute clips. | 833 // to compute clips. |
846 if (!success) | 834 if (!success) |
847 continue; | 835 continue; |
848 parent_combined_clip_in_target_space = MathUtil::ProjectClippedRect( | 836 parent_combined_clip_in_target_space = MathUtil::ProjectClippedRect( |
849 parent_to_current, parent_clip_node->combined_clip_in_target_space); | 837 parent_to_current, parent_clip_node->combined_clip_in_target_space); |
850 parent_clip_in_target_space = MathUtil::ProjectClippedRect( | 838 parent_clip_in_target_space = MathUtil::ProjectClippedRect( |
851 parent_to_current, parent_clip_node->clip_in_target_space); | 839 parent_to_current, parent_clip_node->clip_in_target_space); |
852 } | 840 } |
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
894 | 882 |
895 if (!non_root_surfaces_enabled) { | 883 if (!non_root_surfaces_enabled) { |
896 source_to_target = transform_tree.ToScreen(clip_node->transform_id); | 884 source_to_target = transform_tree.ToScreen(clip_node->transform_id); |
897 } else if (transform_tree.ContentTargetId(transform_node->id) == | 885 } else if (transform_tree.ContentTargetId(transform_node->id) == |
898 clip_node->target_transform_id) { | 886 clip_node->target_transform_id) { |
899 source_to_target = transform_tree.ToTarget(clip_node->transform_id, | 887 source_to_target = transform_tree.ToTarget(clip_node->transform_id, |
900 clip_node->target_effect_id); | 888 clip_node->target_effect_id); |
901 } else { | 889 } else { |
902 success = property_trees->ComputeTransformToTarget( | 890 success = property_trees->ComputeTransformToTarget( |
903 transform_node->id, clip_node->target_effect_id, &source_to_target); | 891 transform_node->id, clip_node->target_effect_id, &source_to_target); |
904 // We don't have to apply surface contents scale when target is root. | 892 const EffectNode* target_effect_node = |
905 if (clip_node->target_effect_id != EffectTree::kContentsRootNodeId) { | 893 effect_tree.Node(clip_node->target_effect_id); |
906 const EffectNode* target_effect_node = | 894 PostConcatSurfaceContentsScale(target_effect_node, &source_to_target); |
907 effect_tree.Node(clip_node->target_effect_id); | |
908 PostConcatSurfaceContentsScale(target_effect_node, &source_to_target); | |
909 #if DCHECK_IS_ON() | 895 #if DCHECK_IS_ON() |
910 VerifySurfaceContentsScalesMatch(clip_node->target_effect_id, | 896 VerifySurfaceContentsScalesMatch(clip_node->target_effect_id, |
911 clip_node->target_transform_id, | 897 clip_node->target_transform_id, |
912 effect_tree, transform_tree); | 898 effect_tree, transform_tree); |
913 #endif | 899 #endif |
914 } | |
915 // source_to_target computation should be successful as target is an | 900 // source_to_target computation should be successful as target is an |
916 // ancestor of the transform node. | 901 // ancestor of the transform node. |
917 DCHECK(success); | 902 DCHECK(success); |
918 } | 903 } |
919 | 904 |
920 gfx::RectF source_clip_in_target_space = | 905 gfx::RectF source_clip_in_target_space = |
921 MathUtil::MapClippedRect(source_to_target, clip_node->clip); | 906 MathUtil::MapClippedRect(source_to_target, clip_node->clip); |
922 | 907 |
923 // With surfaces disabled, the only case where we use only the local clip | 908 // With surfaces disabled, the only case where we use only the local clip |
924 // for layer clipping is the case where no non-viewport ancestor node | 909 // for layer clipping is the case where no non-viewport ancestor node |
(...skipping 24 matching lines...) Expand all Loading... |
949 for (int i = 1; i < static_cast<int>(transform_tree->size()); ++i) | 934 for (int i = 1; i < static_cast<int>(transform_tree->size()); ++i) |
950 transform_tree->UpdateTransforms(i); | 935 transform_tree->UpdateTransforms(i); |
951 transform_tree->set_needs_update(false); | 936 transform_tree->set_needs_update(false); |
952 } | 937 } |
953 | 938 |
954 void UpdateRenderTarget(EffectTree* effect_tree, | 939 void UpdateRenderTarget(EffectTree* effect_tree, |
955 bool can_render_to_separate_surface) { | 940 bool can_render_to_separate_surface) { |
956 for (int i = 1; i < static_cast<int>(effect_tree->size()); ++i) { | 941 for (int i = 1; i < static_cast<int>(effect_tree->size()); ++i) { |
957 EffectNode* node = effect_tree->Node(i); | 942 EffectNode* node = effect_tree->Node(i); |
958 if (i == 1) { | 943 if (i == 1) { |
959 // Render target on the first effect node is root. | 944 // Render target on the node corresponding to root is itself. |
960 node->target_id = 0; | 945 node->target_id = 1; |
961 } else if (!can_render_to_separate_surface) { | 946 } else if (!can_render_to_separate_surface) { |
962 node->target_id = 1; | 947 node->target_id = 1; |
963 } else if (effect_tree->parent(node)->has_render_surface) { | 948 } else if (effect_tree->parent(node)->has_render_surface) { |
964 node->target_id = node->parent_id; | 949 node->target_id = node->parent_id; |
965 } else { | 950 } else { |
966 node->target_id = effect_tree->parent(node)->target_id; | 951 node->target_id = effect_tree->parent(node)->target_id; |
967 } | 952 } |
968 } | 953 } |
969 } | 954 } |
970 | 955 |
(...skipping 88 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1059 static void VerifyDrawTransformsMatch(LayerImpl* layer, | 1044 static void VerifyDrawTransformsMatch(LayerImpl* layer, |
1060 PropertyTrees* property_trees) { | 1045 PropertyTrees* property_trees) { |
1061 const int source_id = layer->transform_tree_index(); | 1046 const int source_id = layer->transform_tree_index(); |
1062 int destination_id = FindTargetTransformTreeIndexFromEffectTree( | 1047 int destination_id = FindTargetTransformTreeIndexFromEffectTree( |
1063 property_trees->effect_tree, layer->effect_tree_index()); | 1048 property_trees->effect_tree, layer->effect_tree_index()); |
1064 const EffectNode* target_effect_node = ContentsTargetEffectNode( | 1049 const EffectNode* target_effect_node = ContentsTargetEffectNode( |
1065 layer->effect_tree_index(), property_trees->effect_tree); | 1050 layer->effect_tree_index(), property_trees->effect_tree); |
1066 gfx::Transform draw_transform; | 1051 gfx::Transform draw_transform; |
1067 property_trees->ComputeTransformToTarget(source_id, target_effect_node->id, | 1052 property_trees->ComputeTransformToTarget(source_id, target_effect_node->id, |
1068 &draw_transform); | 1053 &draw_transform); |
1069 // We don't have to apply surface contents scale when target is root. | 1054 PostConcatSurfaceContentsScale(target_effect_node, &draw_transform); |
1070 if (target_effect_node->id != EffectTree::kContentsRootNodeId) { | |
1071 PostConcatSurfaceContentsScale(target_effect_node, &draw_transform); | |
1072 #if DCHECK_IS_ON() | 1055 #if DCHECK_IS_ON() |
1073 VerifySurfaceContentsScalesMatch(layer->effect_tree_index(), destination_id, | 1056 VerifySurfaceContentsScalesMatch(layer->effect_tree_index(), destination_id, |
1074 property_trees->effect_tree, | 1057 property_trees->effect_tree, |
1075 property_trees->transform_tree); | 1058 property_trees->transform_tree); |
1076 #endif | 1059 #endif |
1077 } | |
1078 if (layer->should_flatten_transform_from_property_tree()) | 1060 if (layer->should_flatten_transform_from_property_tree()) |
1079 draw_transform.FlattenTo2d(); | 1061 draw_transform.FlattenTo2d(); |
1080 draw_transform.Translate(layer->offset_to_transform_parent().x(), | 1062 draw_transform.Translate(layer->offset_to_transform_parent().x(), |
1081 layer->offset_to_transform_parent().y()); | 1063 layer->offset_to_transform_parent().y()); |
1082 DCHECK(draw_transform.ApproximatelyEqual(DrawTransform( | 1064 DCHECK(draw_transform.ApproximatelyEqual(DrawTransform( |
1083 layer, property_trees->transform_tree, property_trees->effect_tree))) | 1065 layer, property_trees->transform_tree, property_trees->effect_tree))) |
1084 << " layer: " << layer->id() << " source transform id: " << source_id | 1066 << " layer: " << layer->id() << " source transform id: " << source_id |
1085 << " destination transform id: " << destination_id | 1067 << " destination transform id: " << destination_id |
1086 << " draw transform from transform tree: " | 1068 << " draw transform from transform tree: " |
1087 << DrawTransform(layer, property_trees->transform_tree, | 1069 << DrawTransform(layer, property_trees->transform_tree, |
(...skipping 207 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1295 if (transform_node->id == 1) { | 1277 if (transform_node->id == 1) { |
1296 render_surface->SetDrawTransform(gfx::Transform()); | 1278 render_surface->SetDrawTransform(gfx::Transform()); |
1297 return; | 1279 return; |
1298 } | 1280 } |
1299 | 1281 |
1300 gfx::Transform render_surface_transform; | 1282 gfx::Transform render_surface_transform; |
1301 const EffectNode* target_effect_node = | 1283 const EffectNode* target_effect_node = |
1302 effect_tree.Node(effect_node->target_id); | 1284 effect_tree.Node(effect_node->target_id); |
1303 property_trees->ComputeTransformToTarget( | 1285 property_trees->ComputeTransformToTarget( |
1304 transform_node->id, target_effect_node->id, &render_surface_transform); | 1286 transform_node->id, target_effect_node->id, &render_surface_transform); |
1305 // We don't have to apply surface contents scale when target is root. | 1287 PostConcatSurfaceContentsScale(target_effect_node, &render_surface_transform); |
1306 if (effect_node->target_id != EffectTree::kContentsRootNodeId) { | |
1307 PostConcatSurfaceContentsScale(target_effect_node, | |
1308 &render_surface_transform); | |
1309 #if DCHECK_IS_ON() | 1288 #if DCHECK_IS_ON() |
1310 const TransformNode* target_transform_node = | 1289 const TransformNode* target_transform_node = |
1311 transform_tree.Node(transform_tree.TargetId(transform_node->id)); | 1290 transform_tree.Node(transform_tree.TargetId(transform_node->id)); |
1312 VerifySurfaceContentsScalesMatch(effect_node->target_id, | 1291 VerifySurfaceContentsScalesMatch(effect_node->target_id, |
1313 target_transform_node->id, effect_tree, | 1292 target_transform_node->id, effect_tree, |
1314 transform_tree); | 1293 transform_tree); |
1315 #endif | 1294 #endif |
1316 } | |
1317 | 1295 |
1318 ConcatInverseSurfaceContentsScale(effect_node, &render_surface_transform); | 1296 ConcatInverseSurfaceContentsScale(effect_node, &render_surface_transform); |
1319 #if DCHECK_IS_ON() | 1297 #if DCHECK_IS_ON() |
1320 VerifySurfaceContentsScalesMatch(effect_node->id, transform_node->id, | 1298 VerifySurfaceContentsScalesMatch(effect_node->id, transform_node->id, |
1321 effect_tree, transform_tree); | 1299 effect_tree, transform_tree); |
1322 #endif | 1300 #endif |
1323 render_surface->SetDrawTransform(render_surface_transform); | 1301 render_surface->SetDrawTransform(render_surface_transform); |
1324 } | 1302 } |
1325 | 1303 |
1326 static void SetSurfaceIsClipped(const ClipNode* clip_node, | 1304 static void SetSurfaceIsClipped(const ClipNode* clip_node, |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1359 int target_effect_id = effect_node->target_id; | 1337 int target_effect_id = effect_node->target_id; |
1360 const bool success = property_trees->ComputeTransformToTarget( | 1338 const bool success = property_trees->ComputeTransformToTarget( |
1361 parent_clip_node->target_transform_id, target_effect_id, | 1339 parent_clip_node->target_transform_id, target_effect_id, |
1362 &clip_parent_target_to_target); | 1340 &clip_parent_target_to_target); |
1363 | 1341 |
1364 if (!success) { | 1342 if (!success) { |
1365 render_surface->SetClipRect(gfx::Rect()); | 1343 render_surface->SetClipRect(gfx::Rect()); |
1366 return; | 1344 return; |
1367 } | 1345 } |
1368 | 1346 |
1369 // We don't have to apply surface contents scale when target is root. | 1347 PostConcatSurfaceContentsScale(effect_node, &clip_parent_target_to_target); |
1370 if (render_surface->EffectTreeIndex() != EffectTree::kContentsRootNodeId) { | |
1371 const EffectNode* effect_node = | |
1372 effect_tree.Node(render_surface->EffectTreeIndex()); | |
1373 PostConcatSurfaceContentsScale(effect_node, &clip_parent_target_to_target); | |
1374 #if DCHECK_IS_ON() | 1348 #if DCHECK_IS_ON() |
1375 VerifySurfaceContentsScalesMatch( | 1349 VerifySurfaceContentsScalesMatch(render_surface->EffectTreeIndex(), |
1376 render_surface->EffectTreeIndex(), | 1350 transform_tree.TargetId(transform_node->id), |
1377 transform_tree.TargetId(transform_node->id), effect_tree, | 1351 effect_tree, transform_tree); |
1378 transform_tree); | |
1379 #endif | 1352 #endif |
1380 } | |
1381 | 1353 |
1382 DCHECK_LT(parent_clip_node->target_transform_id, | 1354 DCHECK_LT(parent_clip_node->target_transform_id, |
1383 transform_tree.TargetId(transform_node->id)); | 1355 transform_tree.TargetId(transform_node->id)); |
1384 render_surface->SetClipRect(gfx::ToEnclosingRect(MathUtil::ProjectClippedRect( | 1356 render_surface->SetClipRect(gfx::ToEnclosingRect(MathUtil::ProjectClippedRect( |
1385 clip_parent_target_to_target, parent_clip_node->clip_in_target_space))); | 1357 clip_parent_target_to_target, parent_clip_node->clip_in_target_space))); |
1386 } | 1358 } |
1387 | 1359 |
1388 template <typename LayerType> | 1360 template <typename LayerType> |
1389 static gfx::Transform ScreenSpaceTransformInternal(LayerType* layer, | 1361 static gfx::Transform ScreenSpaceTransformInternal(LayerType* layer, |
1390 const TransformTree& tree) { | 1362 const TransformTree& tree) { |
(...skipping 211 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1602 void UpdateElasticOverscroll(PropertyTrees* property_trees, | 1574 void UpdateElasticOverscroll(PropertyTrees* property_trees, |
1603 const Layer* overscroll_elasticity_layer, | 1575 const Layer* overscroll_elasticity_layer, |
1604 const gfx::Vector2dF& elastic_overscroll) { | 1576 const gfx::Vector2dF& elastic_overscroll) { |
1605 UpdateElasticOverscrollInternal(property_trees, overscroll_elasticity_layer, | 1577 UpdateElasticOverscrollInternal(property_trees, overscroll_elasticity_layer, |
1606 elastic_overscroll); | 1578 elastic_overscroll); |
1607 } | 1579 } |
1608 | 1580 |
1609 } // namespace draw_property_utils | 1581 } // namespace draw_property_utils |
1610 | 1582 |
1611 } // namespace cc | 1583 } // namespace cc |
OLD | NEW |