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 <vector> | 7 #include <vector> |
8 | 8 |
9 #include "cc/base/math_util.h" | 9 #include "cc/base/math_util.h" |
| 10 #include "cc/layers/draw_properties.h" |
10 #include "cc/layers/layer.h" | 11 #include "cc/layers/layer.h" |
11 #include "cc/layers/layer_impl.h" | 12 #include "cc/layers/layer_impl.h" |
| 13 #include "cc/layers/render_surface_draw_properties.h" |
12 #include "cc/trees/layer_tree_impl.h" | 14 #include "cc/trees/layer_tree_impl.h" |
13 #include "cc/trees/property_tree.h" | 15 #include "cc/trees/property_tree.h" |
14 #include "cc/trees/property_tree_builder.h" | 16 #include "cc/trees/property_tree_builder.h" |
15 #include "ui/gfx/geometry/rect_conversions.h" | 17 #include "ui/gfx/geometry/rect_conversions.h" |
16 | 18 |
17 namespace cc { | 19 namespace cc { |
18 | 20 |
19 namespace { | 21 namespace { |
20 | 22 |
21 template <typename LayerType> | 23 template <typename LayerType> |
(...skipping 601 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
623 void ComputeVisibleRectsUsingPropertyTrees(LayerImpl* root_layer, | 625 void ComputeVisibleRectsUsingPropertyTrees(LayerImpl* root_layer, |
624 PropertyTrees* property_trees, | 626 PropertyTrees* property_trees, |
625 LayerImplList* update_layer_list) { | 627 LayerImplList* update_layer_list) { |
626 ComputeVisibleRectsUsingPropertyTreesInternal(root_layer, property_trees, | 628 ComputeVisibleRectsUsingPropertyTreesInternal(root_layer, property_trees, |
627 update_layer_list); | 629 update_layer_list); |
628 } | 630 } |
629 | 631 |
630 template <typename LayerType> | 632 template <typename LayerType> |
631 gfx::Transform DrawTransformFromPropertyTreesInternal( | 633 gfx::Transform DrawTransformFromPropertyTreesInternal( |
632 const LayerType* layer, | 634 const LayerType* layer, |
633 const TransformTree& tree) { | 635 const TransformNode* node) { |
634 const TransformNode* node = tree.Node(layer->transform_tree_index()); | |
635 | |
636 gfx::Transform xform; | 636 gfx::Transform xform; |
637 const bool owns_non_root_surface = | 637 const bool owns_non_root_surface = |
638 layer->parent() && layer->has_render_surface(); | 638 layer->parent() && layer->has_render_surface(); |
639 if (!owns_non_root_surface) { | 639 if (!owns_non_root_surface) { |
640 // If you're not the root, or you don't own a surface, you need to apply | 640 // If you're not the root, or you don't own a surface, you need to apply |
641 // your local offset. | 641 // your local offset. |
642 xform = node->data.to_target; | 642 xform = node->data.to_target; |
643 if (layer->should_flatten_transform_from_property_tree()) | 643 if (layer->should_flatten_transform_from_property_tree()) |
644 xform.FlattenTo2d(); | 644 xform.FlattenTo2d(); |
645 xform.Translate(layer->offset_to_transform_parent().x(), | 645 xform.Translate(layer->offset_to_transform_parent().x(), |
646 layer->offset_to_transform_parent().y()); | 646 layer->offset_to_transform_parent().y()); |
647 } else { | 647 } else { |
648 // Surfaces need to apply their sublayer scale. | 648 // Surfaces need to apply their sublayer scale. |
649 xform.Scale(node->data.sublayer_scale.x(), node->data.sublayer_scale.y()); | 649 xform.Scale(node->data.sublayer_scale.x(), node->data.sublayer_scale.y()); |
650 } | 650 } |
651 return xform; | 651 return xform; |
652 } | 652 } |
653 | 653 |
654 gfx::Transform DrawTransformFromPropertyTrees(const Layer* layer, | 654 gfx::Transform DrawTransformFromPropertyTrees(const Layer* layer, |
655 const TransformTree& tree) { | 655 const TransformTree& tree) { |
656 return DrawTransformFromPropertyTreesInternal(layer, tree); | 656 return DrawTransformFromPropertyTreesInternal( |
| 657 layer, tree.Node(layer->transform_tree_index())); |
657 } | 658 } |
658 | 659 |
659 gfx::Transform DrawTransformFromPropertyTrees(const LayerImpl* layer, | 660 gfx::Transform DrawTransformFromPropertyTrees(const LayerImpl* layer, |
660 const TransformTree& tree) { | 661 const TransformTree& tree) { |
661 return DrawTransformFromPropertyTreesInternal(layer, tree); | 662 return DrawTransformFromPropertyTreesInternal( |
| 663 layer, tree.Node(layer->transform_tree_index())); |
662 } | 664 } |
663 | 665 |
664 gfx::Transform DrawTransformOfRenderSurfaceFromPropertyTrees( | 666 gfx::Transform SurfaceDrawTransform(const RenderSurfaceImpl* render_surface, |
665 const RenderSurfaceImpl* render_surface, | 667 const TransformTree& tree) { |
666 const TransformTree& tree) { | |
667 const TransformNode* node = tree.Node(render_surface->TransformTreeIndex()); | 668 const TransformNode* node = tree.Node(render_surface->TransformTreeIndex()); |
668 gfx::Transform render_surface_transform; | 669 gfx::Transform render_surface_transform; |
669 // The draw transform of root render surface is identity tranform. | 670 // The draw transform of root render surface is identity tranform. |
670 if (node->id == 1) | 671 if (node->id == 1) |
671 return render_surface_transform; | 672 return render_surface_transform; |
672 const TransformNode* target_node = tree.Node(node->data.target_id); | 673 const TransformNode* target_node = tree.Node(node->data.target_id); |
673 if (target_node->id == 1) | 674 if (target_node->id == 1) |
674 target_node = tree.Node(0); | 675 target_node = tree.Node(0); |
675 tree.ComputeTransformWithDestinationSublayerScale(node->id, target_node->id, | 676 tree.ComputeTransformWithDestinationSublayerScale(node->id, target_node->id, |
676 &render_surface_transform); | 677 &render_surface_transform); |
677 if (node->data.sublayer_scale.x() != 0.0 && | 678 if (node->data.sublayer_scale.x() != 0.0 && |
678 node->data.sublayer_scale.y() != 0.0) | 679 node->data.sublayer_scale.y() != 0.0) |
679 render_surface_transform.Scale(1.0 / node->data.sublayer_scale.x(), | 680 render_surface_transform.Scale(1.0 / node->data.sublayer_scale.x(), |
680 1.0 / node->data.sublayer_scale.y()); | 681 1.0 / node->data.sublayer_scale.y()); |
681 return render_surface_transform; | 682 return render_surface_transform; |
682 } | 683 } |
683 | 684 |
684 bool RenderSurfaceIsClippedFromPropertyTrees( | 685 bool SurfaceIsClipped(const RenderSurfaceImpl* render_surface, |
685 const RenderSurfaceImpl* render_surface, | 686 const ClipNode* clip_node) { |
686 const ClipTree& tree) { | |
687 const ClipNode* node = tree.Node(render_surface->ClipTreeIndex()); | |
688 // If the render surface's owning layer doesn't form a clip node, it is not | 687 // If the render surface's owning layer doesn't form a clip node, it is not |
689 // clipped. | 688 // clipped. |
690 if (render_surface->OwningLayerId() != node->owner_id) | 689 if (render_surface->OwningLayerId() != clip_node->owner_id) |
691 return false; | 690 return false; |
692 return node->data.render_surface_is_clipped; | 691 return clip_node->data.render_surface_is_clipped; |
693 } | 692 } |
694 | 693 |
695 gfx::Rect ClipRectOfRenderSurfaceFromPropertyTrees( | 694 gfx::Rect SurfaceClipRect(const RenderSurfaceImpl* render_surface, |
696 const RenderSurfaceImpl* render_surface, | 695 const ClipNode* parent_clip_node, |
697 const ClipTree& clip_tree) { | 696 bool is_clipped) { |
698 if (!RenderSurfaceIsClippedFromPropertyTrees(render_surface, clip_tree)) | 697 if (!is_clipped) |
699 return gfx::Rect(); | 698 return gfx::Rect(); |
700 const ClipNode* clip_node = clip_tree.Node(render_surface->ClipTreeIndex()); | |
701 const ClipNode* parent_clip_node = clip_tree.parent(clip_node); | |
702 return gfx::ToEnclosingRect(parent_clip_node->data.clip_in_target_space); | 699 return gfx::ToEnclosingRect(parent_clip_node->data.clip_in_target_space); |
703 } | 700 } |
704 | 701 |
705 gfx::Transform ScreenSpaceTransformOfRenderSurfaceFromPropertyTrees( | 702 gfx::Transform SurfaceScreenSpaceTransform( |
706 const RenderSurfaceImpl* render_surface, | 703 const RenderSurfaceImpl* render_surface, |
707 const TransformTree& tree) { | 704 const TransformTree& tree) { |
708 const TransformNode* node = tree.Node(render_surface->TransformTreeIndex()); | 705 const TransformNode* node = tree.Node(render_surface->TransformTreeIndex()); |
709 gfx::Transform screen_space_transform; | 706 gfx::Transform screen_space_transform; |
710 // The screen space transform of root render surface is identity tranform. | 707 // The screen space transform of root render surface is identity tranform. |
711 if (node->id == 1) | 708 if (node->id == 1) |
712 return screen_space_transform; | 709 return screen_space_transform; |
713 screen_space_transform = node->data.to_screen; | 710 screen_space_transform = node->data.to_screen; |
714 if (node->data.sublayer_scale.x() != 0.0 && | 711 if (node->data.sublayer_scale.x() != 0.0 && |
715 node->data.sublayer_scale.y() != 0.0) | 712 node->data.sublayer_scale.y() != 0.0) |
716 screen_space_transform.Scale(1.0 / node->data.sublayer_scale.x(), | 713 screen_space_transform.Scale(1.0 / node->data.sublayer_scale.x(), |
717 1.0 / node->data.sublayer_scale.y()); | 714 1.0 / node->data.sublayer_scale.y()); |
718 return screen_space_transform; | 715 return screen_space_transform; |
719 } | 716 } |
720 | 717 |
721 template <typename LayerType> | 718 template <typename LayerType> |
722 gfx::Transform ScreenSpaceTransformFromPropertyTreesInternal( | 719 gfx::Transform ScreenSpaceTransformFromPropertyTreesInternal( |
723 LayerType* layer, | 720 LayerType* layer, |
724 const TransformTree& tree) { | 721 const TransformNode* node) { |
725 gfx::Transform xform(1, 0, 0, 1, layer->offset_to_transform_parent().x(), | 722 gfx::Transform xform(1, 0, 0, 1, layer->offset_to_transform_parent().x(), |
726 layer->offset_to_transform_parent().y()); | 723 layer->offset_to_transform_parent().y()); |
727 if (layer->transform_tree_index() >= 0) { | 724 gfx::Transform ssxform = node->data.to_screen; |
728 gfx::Transform ssxform = | 725 xform.ConcatTransform(ssxform); |
729 tree.Node(layer->transform_tree_index())->data.to_screen; | 726 if (layer->should_flatten_transform_from_property_tree()) |
730 xform.ConcatTransform(ssxform); | 727 xform.FlattenTo2d(); |
731 if (layer->should_flatten_transform_from_property_tree()) | |
732 xform.FlattenTo2d(); | |
733 } | |
734 return xform; | 728 return xform; |
735 } | 729 } |
736 | 730 |
737 gfx::Transform ScreenSpaceTransformFromPropertyTrees( | 731 gfx::Transform ScreenSpaceTransformFromPropertyTrees( |
738 const Layer* layer, | 732 const Layer* layer, |
739 const TransformTree& tree) { | 733 const TransformTree& tree) { |
740 return ScreenSpaceTransformFromPropertyTreesInternal(layer, tree); | 734 return ScreenSpaceTransformFromPropertyTreesInternal( |
| 735 layer, tree.Node(layer->transform_tree_index())); |
741 } | 736 } |
742 | 737 |
743 gfx::Transform ScreenSpaceTransformFromPropertyTrees( | 738 gfx::Transform ScreenSpaceTransformFromPropertyTrees( |
744 const LayerImpl* layer, | 739 const LayerImpl* layer, |
745 const TransformTree& tree) { | 740 const TransformTree& tree) { |
746 return ScreenSpaceTransformFromPropertyTreesInternal(layer, tree); | 741 return ScreenSpaceTransformFromPropertyTreesInternal( |
| 742 layer, tree.Node(layer->transform_tree_index())); |
747 } | 743 } |
748 | 744 |
749 template <typename LayerType> | 745 float LayerDrawOpacity(const LayerImpl* layer, const EffectTree& tree) { |
750 bool ScreenSpaceTransformIsAnimatingFromPropertyTreesInternal( | |
751 LayerType* layer, | |
752 const TransformTree& tree) { | |
753 return tree.Node(layer->transform_tree_index())->data.to_screen_is_animated; | |
754 } | |
755 | |
756 bool ScreenSpaceTransformIsAnimatingFromPropertyTrees( | |
757 const Layer* layer, | |
758 const TransformTree& tree) { | |
759 return ScreenSpaceTransformIsAnimatingFromPropertyTreesInternal(layer, tree); | |
760 } | |
761 | |
762 bool ScreenSpaceTransformIsAnimatingFromPropertyTrees( | |
763 const LayerImpl* layer, | |
764 const TransformTree& tree) { | |
765 return ScreenSpaceTransformIsAnimatingFromPropertyTreesInternal(layer, tree); | |
766 } | |
767 | |
768 float MaximumAnimationTargetScaleFromPropertyTrees(const LayerImpl* layer, | |
769 const TransformTree& tree) { | |
770 if (!layer->layer_tree_impl() | |
771 ->settings() | |
772 .layer_transforms_should_scale_layer_contents) | |
773 return 0.f; | |
774 | |
775 return tree.Node(layer->transform_tree_index()) | |
776 ->data.combined_maximum_animation_target_scale; | |
777 } | |
778 | |
779 float StartingAnimationScaleFromPropertyTrees(const LayerImpl* layer, | |
780 const TransformTree& tree) { | |
781 if (!layer->layer_tree_impl() | |
782 ->settings() | |
783 .layer_transforms_should_scale_layer_contents) | |
784 return 0.f; | |
785 | |
786 return tree.Node(layer->transform_tree_index()) | |
787 ->data.combined_starting_animation_scale; | |
788 } | |
789 | |
790 float DrawOpacityFromPropertyTrees(const LayerImpl* layer, | |
791 const EffectTree& tree) { | |
792 if (!layer->render_target()) | 746 if (!layer->render_target()) |
793 return 0.f; | 747 return 0.f; |
794 | 748 |
795 const EffectNode* target_node = | 749 const EffectNode* target_node = |
796 tree.Node(layer->render_target()->effect_tree_index()); | 750 tree.Node(layer->render_target()->effect_tree_index()); |
797 const EffectNode* node = tree.Node(layer->effect_tree_index()); | 751 const EffectNode* node = tree.Node(layer->effect_tree_index()); |
798 if (node == target_node) | 752 if (node == target_node) |
799 return 1.f; | 753 return 1.f; |
800 | 754 |
801 float draw_opacity = 1.f; | 755 float draw_opacity = 1.f; |
802 while (node != target_node) { | 756 while (node != target_node) { |
803 draw_opacity *= node->data.opacity; | 757 draw_opacity *= node->data.opacity; |
804 node = tree.parent(node); | 758 node = tree.parent(node); |
805 } | 759 } |
806 return draw_opacity; | 760 return draw_opacity; |
807 } | 761 } |
808 | 762 |
809 float DrawOpacityOfRenderSurfaceFromPropertyTrees( | 763 float SurfaceDrawOpacity(RenderSurfaceImpl* render_surface, |
810 RenderSurfaceImpl* render_surface, | 764 const EffectTree& tree) { |
811 const EffectTree& tree) { | |
812 const EffectNode* node = tree.Node(render_surface->EffectTreeIndex()); | 765 const EffectNode* node = tree.Node(render_surface->EffectTreeIndex()); |
813 float target_opacity_tree_index = render_surface->TargetEffectTreeIndex(); | 766 float target_opacity_tree_index = render_surface->TargetEffectTreeIndex(); |
814 if (target_opacity_tree_index < 0) | 767 if (target_opacity_tree_index < 0) |
815 return node->data.screen_space_opacity; | 768 return node->data.screen_space_opacity; |
816 const EffectNode* target_node = tree.Node(target_opacity_tree_index); | 769 const EffectNode* target_node = tree.Node(target_opacity_tree_index); |
817 float draw_opacity = 1.f; | 770 float draw_opacity = 1.f; |
818 while (node != target_node) { | 771 while (node != target_node) { |
819 draw_opacity *= node->data.opacity; | 772 draw_opacity *= node->data.opacity; |
820 node = tree.parent(node); | 773 node = tree.parent(node); |
821 } | 774 } |
822 return draw_opacity; | 775 return draw_opacity; |
823 } | 776 } |
824 | 777 |
825 bool CanUseLcdTextFromPropertyTrees(const LayerImpl* layer, | 778 bool LayerCanUseLcdText(const LayerImpl* layer, |
826 bool layers_always_allowed_lcd_text, | 779 bool layers_always_allowed_lcd_text, |
827 bool can_use_lcd_text, | 780 bool can_use_lcd_text, |
828 PropertyTrees* property_trees) { | 781 const TransformNode* transform_node, |
| 782 const EffectNode* effect_node) { |
829 if (layers_always_allowed_lcd_text) | 783 if (layers_always_allowed_lcd_text) |
830 return true; | 784 return true; |
831 if (!can_use_lcd_text) | 785 if (!can_use_lcd_text) |
832 return false; | 786 return false; |
833 if (!layer->contents_opaque()) | 787 if (!layer->contents_opaque()) |
834 return false; | 788 return false; |
835 DCHECK(!property_trees->transform_tree.needs_update()); | |
836 DCHECK(!property_trees->effect_tree.needs_update()); | |
837 | 789 |
838 const EffectNode* opacity_node = | 790 if (effect_node->data.screen_space_opacity != 1.f) |
839 property_trees->effect_tree.Node(layer->effect_tree_index()); | |
840 if (opacity_node->data.screen_space_opacity != 1.f) | |
841 return false; | 791 return false; |
842 const TransformNode* transform_node = | |
843 property_trees->transform_tree.Node(layer->transform_tree_index()); | |
844 if (!transform_node->data.node_and_ancestors_have_only_integer_translation) | 792 if (!transform_node->data.node_and_ancestors_have_only_integer_translation) |
845 return false; | 793 return false; |
846 if (static_cast<int>(layer->offset_to_transform_parent().x()) != | 794 if (static_cast<int>(layer->offset_to_transform_parent().x()) != |
847 layer->offset_to_transform_parent().x()) | 795 layer->offset_to_transform_parent().x()) |
848 return false; | 796 return false; |
849 if (static_cast<int>(layer->offset_to_transform_parent().y()) != | 797 if (static_cast<int>(layer->offset_to_transform_parent().y()) != |
850 layer->offset_to_transform_parent().y()) | 798 layer->offset_to_transform_parent().y()) |
851 return false; | 799 return false; |
852 return true; | 800 return true; |
853 } | 801 } |
854 | 802 |
855 gfx::Rect DrawableContentRectOfSurfaceFromPropertyTrees( | 803 gfx::Rect LayerDrawableContentRect( |
856 const RenderSurfaceImpl* render_surface, | 804 const LayerImpl* layer, |
857 const TransformTree& transform_tree) { | 805 const gfx::Rect& layer_bounds_in_target_space, |
858 gfx::Rect drawable_content_rect = | 806 const gfx::Rect& clip_rect) { |
859 gfx::ToEnclosingRect(MathUtil::MapClippedRect( | 807 if (layer->is_clipped()) |
860 DrawTransformOfRenderSurfaceFromPropertyTrees(render_surface, | 808 return IntersectRects(layer_bounds_in_target_space, clip_rect); |
861 transform_tree), | |
862 render_surface->content_rect_from_property_trees())); | |
863 if (render_surface->HasReplica()) { | |
864 drawable_content_rect.Union(gfx::ToEnclosingRect(MathUtil::MapClippedRect( | |
865 DrawTransformOfRenderSurfaceReplicaFromPropertyTrees(render_surface, | |
866 transform_tree), | |
867 render_surface->content_rect_from_property_trees()))); | |
868 } | |
869 return drawable_content_rect; | |
870 } | |
871 | 809 |
872 gfx::Rect DrawableContentRectFromPropertyTrees( | 810 return layer_bounds_in_target_space; |
873 const LayerImpl* layer, | |
874 const TransformTree& transform_tree) { | |
875 gfx::Rect drawable_content_rect = MathUtil::MapEnclosingClippedRect( | |
876 DrawTransformFromPropertyTrees(layer, transform_tree), | |
877 gfx::Rect(layer->bounds())); | |
878 if (layer->is_clipped()) { | |
879 drawable_content_rect.Intersect( | |
880 layer->clip_rect_in_target_space_from_property_trees()); | |
881 } | |
882 return drawable_content_rect; | |
883 } | |
884 | |
885 gfx::Rect ClipRectFromPropertyTrees(const LayerImpl* layer, | |
886 const TransformTree& transform_tree) { | |
887 if (layer->is_clipped()) | |
888 return layer->clip_rect_in_target_space_from_property_trees(); | |
889 return MathUtil::MapEnclosingClippedRect( | |
890 DrawTransformFromPropertyTrees(layer, transform_tree), | |
891 gfx::Rect(layer->bounds())); | |
892 } | 811 } |
893 | 812 |
894 gfx::Transform ReplicaToSurfaceTransform( | 813 gfx::Transform ReplicaToSurfaceTransform( |
895 const RenderSurfaceImpl* render_surface, | 814 const RenderSurfaceImpl* render_surface, |
896 const TransformTree& tree) { | 815 const TransformTree& tree) { |
897 gfx::Transform replica_to_surface; | 816 gfx::Transform replica_to_surface; |
898 if (!render_surface->HasReplica()) | 817 if (!render_surface->HasReplica()) |
899 return replica_to_surface; | 818 return replica_to_surface; |
900 const LayerImpl* replica_layer = render_surface->ReplicaLayer(); | 819 const LayerImpl* replica_layer = render_surface->ReplicaLayer(); |
901 const TransformNode* surface_transform_node = | 820 const TransformNode* surface_transform_node = |
902 tree.Node(render_surface->TransformTreeIndex()); | 821 tree.Node(render_surface->TransformTreeIndex()); |
903 replica_to_surface.Scale(surface_transform_node->data.sublayer_scale.x(), | 822 replica_to_surface.Scale(surface_transform_node->data.sublayer_scale.x(), |
904 surface_transform_node->data.sublayer_scale.y()); | 823 surface_transform_node->data.sublayer_scale.y()); |
905 replica_to_surface.Translate(replica_layer->offset_to_transform_parent().x(), | 824 replica_to_surface.Translate(replica_layer->offset_to_transform_parent().x(), |
906 replica_layer->offset_to_transform_parent().y()); | 825 replica_layer->offset_to_transform_parent().y()); |
907 gfx::Transform replica_transform_node_to_surface; | 826 gfx::Transform replica_transform_node_to_surface; |
908 tree.ComputeTransform(replica_layer->transform_tree_index(), | 827 tree.ComputeTransform(replica_layer->transform_tree_index(), |
909 render_surface->TransformTreeIndex(), | 828 render_surface->TransformTreeIndex(), |
910 &replica_transform_node_to_surface); | 829 &replica_transform_node_to_surface); |
911 replica_to_surface.PreconcatTransform(replica_transform_node_to_surface); | 830 replica_to_surface.PreconcatTransform(replica_transform_node_to_surface); |
912 if (surface_transform_node->data.sublayer_scale.x() != 0 && | 831 if (surface_transform_node->data.sublayer_scale.x() != 0 && |
913 surface_transform_node->data.sublayer_scale.y() != 0) { | 832 surface_transform_node->data.sublayer_scale.y() != 0) { |
914 replica_to_surface.Scale( | 833 replica_to_surface.Scale( |
915 1.0 / surface_transform_node->data.sublayer_scale.x(), | 834 1.0 / surface_transform_node->data.sublayer_scale.x(), |
916 1.0 / surface_transform_node->data.sublayer_scale.y()); | 835 1.0 / surface_transform_node->data.sublayer_scale.y()); |
917 } | 836 } |
918 return replica_to_surface; | 837 return replica_to_surface; |
919 } | 838 } |
920 | 839 |
921 gfx::Transform DrawTransformOfRenderSurfaceReplicaFromPropertyTrees( | 840 gfx::Rect LayerClipRect(const LayerImpl* layer, |
922 const RenderSurfaceImpl* render_surface, | 841 const gfx::Rect& layer_bounds_in_target_space) { |
923 const TransformTree& tree) { | 842 if (layer->is_clipped()) |
924 if (!render_surface->HasReplica()) | 843 return layer->clip_rect_in_target_space_from_property_trees(); |
925 return gfx::Transform(); | 844 |
926 return DrawTransformOfRenderSurfaceFromPropertyTrees(render_surface, tree) * | 845 return layer_bounds_in_target_space; |
927 ReplicaToSurfaceTransform(render_surface, tree); | |
928 } | 846 } |
929 | 847 |
930 gfx::Transform ScreenSpaceTransformOfRenderSurfaceReplicaFromPropertyTrees( | 848 void ComputeLayerDrawPropertiesUsingPropertyTrees( |
931 const RenderSurfaceImpl* render_surface, | 849 const LayerImpl* layer, |
932 const TransformTree& tree) { | 850 const PropertyTrees* property_trees, |
933 if (!render_surface->HasReplica()) | 851 bool layers_always_allowed_lcd_text, |
934 return gfx::Transform(); | 852 bool can_use_lcd_text, |
935 return ScreenSpaceTransformOfRenderSurfaceFromPropertyTrees(render_surface, | 853 DrawProperties* draw_properties) { |
936 tree) * | 854 draw_properties->visible_layer_rect = |
937 ReplicaToSurfaceTransform(render_surface, tree); | 855 layer->visible_rect_from_property_trees(); |
| 856 |
| 857 const TransformNode* transform_node = |
| 858 property_trees->transform_tree.Node(layer->transform_tree_index()); |
| 859 const EffectNode* effect_node = |
| 860 property_trees->effect_tree.Node(layer->effect_tree_index()); |
| 861 |
| 862 draw_properties->target_space_transform = |
| 863 DrawTransformFromPropertyTreesInternal(layer, transform_node); |
| 864 draw_properties->screen_space_transform = |
| 865 ScreenSpaceTransformFromPropertyTreesInternal(layer, transform_node); |
| 866 draw_properties->screen_space_transform_is_animating = |
| 867 transform_node->data.to_screen_is_animated; |
| 868 if (layer->layer_tree_impl() |
| 869 ->settings() |
| 870 .layer_transforms_should_scale_layer_contents) { |
| 871 draw_properties->maximum_animation_contents_scale = |
| 872 transform_node->data.combined_maximum_animation_target_scale; |
| 873 draw_properties->starting_animation_contents_scale = |
| 874 transform_node->data.combined_starting_animation_scale; |
| 875 } else { |
| 876 draw_properties->maximum_animation_contents_scale = 0.f; |
| 877 draw_properties->starting_animation_contents_scale = 0.f; |
| 878 } |
| 879 |
| 880 draw_properties->opacity = |
| 881 LayerDrawOpacity(layer, property_trees->effect_tree); |
| 882 draw_properties->can_use_lcd_text = |
| 883 LayerCanUseLcdText(layer, layers_always_allowed_lcd_text, |
| 884 can_use_lcd_text, transform_node, effect_node); |
| 885 |
| 886 gfx::Rect bounds_in_target_space = MathUtil::MapEnclosingClippedRect( |
| 887 draw_properties->target_space_transform, gfx::Rect(layer->bounds())); |
| 888 draw_properties->clip_rect = LayerClipRect(layer, bounds_in_target_space); |
| 889 draw_properties->drawable_content_rect = LayerDrawableContentRect( |
| 890 layer, bounds_in_target_space, draw_properties->clip_rect); |
| 891 } |
| 892 |
| 893 void ComputeSurfaceDrawPropertiesUsingPropertyTrees( |
| 894 RenderSurfaceImpl* render_surface, |
| 895 const PropertyTrees* property_trees, |
| 896 RenderSurfaceDrawProperties* draw_properties) { |
| 897 const ClipNode* clip_node = |
| 898 property_trees->clip_tree.Node(render_surface->ClipTreeIndex()); |
| 899 |
| 900 draw_properties->is_clipped = SurfaceIsClipped(render_surface, clip_node); |
| 901 draw_properties->draw_opacity = |
| 902 SurfaceDrawOpacity(render_surface, property_trees->effect_tree); |
| 903 draw_properties->draw_transform = |
| 904 SurfaceDrawTransform(render_surface, property_trees->transform_tree); |
| 905 draw_properties->screen_space_transform = SurfaceScreenSpaceTransform( |
| 906 render_surface, property_trees->transform_tree); |
| 907 |
| 908 if (render_surface->HasReplica()) { |
| 909 gfx::Transform replica_to_surface = ReplicaToSurfaceTransform( |
| 910 render_surface, property_trees->transform_tree); |
| 911 draw_properties->replica_draw_transform = |
| 912 draw_properties->draw_transform * replica_to_surface; |
| 913 draw_properties->replica_screen_space_transform = |
| 914 draw_properties->screen_space_transform * replica_to_surface; |
| 915 } else { |
| 916 draw_properties->replica_draw_transform.MakeIdentity(); |
| 917 draw_properties->replica_screen_space_transform.MakeIdentity(); |
| 918 } |
| 919 |
| 920 draw_properties->clip_rect = SurfaceClipRect( |
| 921 render_surface, property_trees->clip_tree.parent(clip_node), |
| 922 draw_properties->is_clipped); |
938 } | 923 } |
939 | 924 |
940 } // namespace cc | 925 } // namespace cc |
OLD | NEW |