Mozart: Compute hits using 4x4 matrix.

services/gfx/compositor/graph/node_def.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "services/gfx/compositor/graph/node_def.h"
 
 #include <ostream>
 
 #include "base/logging.h"
 #include "mojo/services/gfx/composition/cpp/formatting.h"
 #include "mojo/skia/type_converters.h"
 #include "services/gfx/compositor/graph/scene_content.h"
 #include "services/gfx/compositor/graph/scene_def.h"
 #include "services/gfx/compositor/graph/snapshot.h"
+#include "services/gfx/compositor/graph/transform_pair.h"
 #include "services/gfx/compositor/render/render_image.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkMatrix.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/core/SkPoint.h"
 #include "third_party/skia/include/core/SkRect.h"
+#include "third_party/skia/include/utils/SkMatrix44.h"
 
 namespace compositor {
 namespace {
 SkColor MakeSkColor(const mojo::gfx::composition::Color& color) {
   return SkColorSetARGBInline(color.alpha, color.red, color.green, color.blue);
 }
 
 void SetPaintForBlend(SkPaint* paint, mojo::gfx::composition::Blend* blend) {
   DCHECK(paint);
   if (blend)
     paint->setAlpha(blend->alpha);
 }
 
 bool Contains(const SkRect& bounds, const SkPoint& point) {
   return point.x() >= bounds.left() && point.x() < bounds.right() &&
          point.y() >= bounds.top() && point.y() < bounds.bottom();
 }
 }  // namespace
 
 NodeDef::NodeDef(uint32_t node_id,
-                 mojo::TransformPtr content_transform,
+                 std::unique_ptr<TransformPair> content_transform,
                  mojo::RectFPtr content_clip,
                  mojo::gfx::composition::HitTestBehaviorPtr hit_test_behavior,
                  Combinator combinator,
                  const std::vector<uint32_t>& child_node_ids)
     : node_id_(node_id),
-      content_transform_(content_transform.Pass()),
+      content_transform_(std::move(content_transform)),
       content_clip_(content_clip.Pass()),
       hit_test_behavior_(hit_test_behavior.Pass()),
       combinator_(combinator),
       child_node_ids_(child_node_ids) {}
 
 NodeDef::~NodeDef() {}
 
 std::string NodeDef::FormattedLabel(const SceneContent* content) const {
   return content->FormattedLabelForNode(node_id_);
 }
@@ skipping 139 matching lines @@
                             const Snapshot* snapshot,
                             SkCanvas* canvas) const {
   DCHECK(content);
   DCHECK(snapshot);
   DCHECK(canvas);
 
   const bool must_save = content_transform_ || content_clip_;
   if (must_save) {
     canvas->save();
     if (content_transform_)
-      canvas->concat(content_transform_.To<SkMatrix>());
+      canvas->concat(content_transform_->forward());
     if (content_clip_)
       canvas->clipRect(content_clip_->To<SkRect>());
   }
 
   RecordPictureInner(content, snapshot, canvas);
 
   if (must_save)
     canvas->restore();
 }
 
 void NodeDef::RecordPictureInner(const SceneContent* content,
                                  const Snapshot* snapshot,
                                  SkCanvas* canvas) const {
   DCHECK(content);
   DCHECK(snapshot);
   DCHECK(canvas);
 
   TraverseSnapshottedChildren(
       content, snapshot,
       [this, content, snapshot, canvas](const NodeDef* child_node) -> bool {
         child_node->RecordPicture(content, snapshot, canvas);
         return true;
       });
 }
 
 bool NodeDef::HitTest(const SceneContent* content,
                       const Snapshot* snapshot,
                       const SkPoint& parent_point,
-                      const SkMatrix& global_to_parent_transform,
+                      const SkMatrix44& global_to_parent_transform,
                       mojo::Array<mojo::gfx::composition::HitPtr>* hits) const {
   DCHECK(content);
   DCHECK(snapshot);
   DCHECK(hits);
 
   // TODO(jeffbrown): These calculations should probably be happening using
   // a 4x4 matrix instead.
-  SkPoint local_point = parent_point;
-  SkMatrix global_to_local_transform = global_to_parent_transform;
+  SkPoint local_point(parent_point);
+  SkMatrix global_to_local_transform(global_to_parent_transform);
   if (content_transform_) {
-    // TODO(jeffbrown): Cache the inverse transform.
-    // Defer matrix multiplications using a matrix stack.
-    SkMatrix inverse_transform;
-    if (!content_transform_.To<SkMatrix>().invert(&inverse_transform)) {
-      // Matrix is singular!
-      // Return [0,0,0][0,0,0][0,0,1] (all zeroes except last component).
-      // This causes all points to be mapped to (0,0) when transformed.
-      inverse_transform.setScale(0.f, 0.f);
-    }
-    inverse_transform.mapXY(parent_point.x(), parent_point.y(), &local_point);
-    global_to_local_transform.preConcat(inverse_transform);
+    // TODO(jeffbrown): Defer matrix multiplications using a matrix stack.
+    local_point = content_transform_->InverseMapPoint(parent_point);
+    global_to_local_transform.preConcat(content_transform_->GetInverse());
   }
 
   if (content_clip_ && !Contains(content_clip_->To<SkRect>(), local_point))
     return false;
 
   bool opaque_children = false;
   if (!hit_test_behavior_ || !hit_test_behavior_->prune) {
     opaque_children = HitTestInner(content, snapshot, local_point,
                                    global_to_local_transform, hits);
   }
 
   return HitTestSelf(content, snapshot, local_point, global_to_local_transform,
                      hits) ||
          opaque_children;
 }
 
 bool NodeDef::HitTestInner(
     const SceneContent* content,
     const Snapshot* snapshot,
     const SkPoint& local_point,
-    const SkMatrix& global_to_local_transform,
+    const SkMatrix44& global_to_local_transform,
     mojo::Array<mojo::gfx::composition::HitPtr>* hits) const {
   DCHECK(content);
   DCHECK(snapshot);
   DCHECK(hits);
 
   // TODO(jeffbrown): Implement a more efficient way to traverse children in
   // reverse order.
   std::vector<const NodeDef*> children;
   TraverseSnapshottedChildren(
       content, snapshot, [this, &children](const NodeDef* child_node) -> bool {
         children.push_back(child_node);
         return true;
       });
 
   for (auto it = children.crbegin(); it != children.crend(); ++it) {
     if ((*it)->HitTest(content, snapshot, local_point,
                        global_to_local_transform, hits))
       return true;  // opaque child covering siblings
   }
   return false;
 }
 
 bool NodeDef::HitTestSelf(
     const SceneContent* content,
     const Snapshot* snapshot,
     const SkPoint& local_point,
-    const SkMatrix& global_to_local_transform,
+    const SkMatrix44& global_to_local_transform,
     mojo::Array<mojo::gfx::composition::HitPtr>* hits) const {
   DCHECK(content);
   DCHECK(snapshot);
   DCHECK(hits);
 
   if (!hit_test_behavior_ ||
       hit_test_behavior_->visibility ==
           mojo::gfx::composition::HitTestBehavior::Visibility::INVISIBLE)
     return false;
 
   if (hit_test_behavior_->hit_rect &&
       !Contains(hit_test_behavior_->hit_rect->To<SkRect>(), local_point))
     return false;
 
   auto hit = mojo::gfx::composition::Hit::New();
   hit->set_node(mojo::gfx::composition::NodeHit::New());
   hit->get_node()->node_id = node_id_;
   hit->get_node()->transform =
       mojo::ConvertTo<mojo::TransformPtr>(global_to_local_transform);
   hits->push_back(hit.Pass());
   return hit_test_behavior_->visibility ==
          mojo::gfx::composition::HitTestBehavior::Visibility::OPAQUE;
 }
 
 RectNodeDef::RectNodeDef(
     uint32_t node_id,
-    mojo::TransformPtr content_transform,
+    std::unique_ptr<TransformPair> content_transform,
     mojo::RectFPtr content_clip,
     mojo::gfx::composition::HitTestBehaviorPtr hit_test_behavior,
     Combinator combinator,
     const std::vector<uint32_t>& child_node_ids,
     const mojo::RectF& content_rect,
     const mojo::gfx::composition::Color& color)
     : NodeDef(node_id,
-              content_transform.Pass(),
+              std::move(content_transform),
               content_clip.Pass(),
               hit_test_behavior.Pass(),
               combinator,
               child_node_ids),
       content_rect_(content_rect),
       color_(color) {}
 
 RectNodeDef::~RectNodeDef() {}
 
 void RectNodeDef::RecordPictureInner(const SceneContent* content,
                                      const Snapshot* snapshot,
                                      SkCanvas* canvas) const {
   DCHECK(content);
   DCHECK(snapshot);
   DCHECK(canvas);
 
   SkPaint paint;
   paint.setColor(MakeSkColor(color_));
   canvas->drawRect(content_rect_.To<SkRect>(), paint);
 
   NodeDef::RecordPictureInner(content, snapshot, canvas);
 }
 
 ImageNodeDef::ImageNodeDef(
     uint32_t node_id,
-    mojo::TransformPtr content_transform,
+    std::unique_ptr<TransformPair> content_transform,
     mojo::RectFPtr content_clip,
     mojo::gfx::composition::HitTestBehaviorPtr hit_test_behavior,
     Combinator combinator,
     const std::vector<uint32_t>& child_node_ids,
     const mojo::RectF& content_rect,
     mojo::RectFPtr image_rect,
     uint32 image_resource_id,
     mojo::gfx::composition::BlendPtr blend)
     : NodeDef(node_id,
-              content_transform.Pass(),
+              std::move(content_transform),
               content_clip.Pass(),
               hit_test_behavior.Pass(),
               combinator,
               child_node_ids),
       content_rect_(content_rect),
       image_rect_(image_rect.Pass()),
       image_resource_id_(image_resource_id),
       blend_(blend.Pass()) {}
 
 ImageNodeDef::~ImageNodeDef() {}
@@ skipping 25 matching lines @@
                             ? image_rect_->To<SkRect>()
                             : SkRect::MakeWH(image_resource->image()->width(),
                                              image_resource->image()->height()),
                         content_rect_.To<SkRect>(), &paint);
 
   NodeDef::RecordPictureInner(content, snapshot, canvas);
 }
 
 SceneNodeDef::SceneNodeDef(
     uint32_t node_id,
-    mojo::TransformPtr content_transform,
+    std::unique_ptr<TransformPair> content_transform,
     mojo::RectFPtr content_clip,
     mojo::gfx::composition::HitTestBehaviorPtr hit_test_behavior,
     Combinator combinator,
     const std::vector<uint32_t>& child_node_ids,
     uint32_t scene_resource_id,
     uint32_t scene_version)
     : NodeDef(node_id,
-              content_transform.Pass(),
+              std::move(content_transform),
               content_clip.Pass(),
               hit_test_behavior.Pass(),
               combinator,
               child_node_ids),
       scene_resource_id_(scene_resource_id),
       scene_version_(scene_version) {}
 
 SceneNodeDef::~SceneNodeDef() {}
 
 bool SceneNodeDef::RecordContent(SceneContentBuilder* builder) const {
@@ skipping 43 matching lines @@
   DCHECK(resolved_content);
   resolved_content->RecordPicture(snapshot, canvas);
 
   NodeDef::RecordPictureInner(content, snapshot, canvas);
 }
 
 bool SceneNodeDef::HitTestInner(
     const SceneContent* content,
     const Snapshot* snapshot,
     const SkPoint& local_point,
-    const SkMatrix& global_to_local_transform,
+    const SkMatrix44& global_to_local_transform,
     mojo::Array<mojo::gfx::composition::HitPtr>* hits) const {
   DCHECK(content);
   DCHECK(snapshot);
   DCHECK(hits);
 
   if (NodeDef::HitTestInner(content, snapshot, local_point,
                             global_to_local_transform, hits))
     return true;  // opaque child covering referenced scene
 
   const SceneContent* resolved_content =
       snapshot->GetResolvedSceneContent(this);
   DCHECK(resolved_content);
 
   mojo::gfx::composition::SceneHitPtr scene_hit;
   bool opaque = resolved_content->HitTest(
       snapshot, local_point, global_to_local_transform, &scene_hit);
   if (scene_hit) {
     auto hit = mojo::gfx::composition::Hit::New();
     hit->set_scene(scene_hit.Pass());
     hits->push_back(hit.Pass());
   }
   return opaque;
 }
 
 LayerNodeDef::LayerNodeDef(
     uint32_t node_id,
-    mojo::TransformPtr content_transform,
+    std::unique_ptr<TransformPair> content_transform,
     mojo::RectFPtr content_clip,
     mojo::gfx::composition::HitTestBehaviorPtr hit_test_behavior,
     Combinator combinator,
     const std::vector<uint32_t>& child_node_ids,
     const mojo::RectF& layer_rect,
     mojo::gfx::composition::BlendPtr blend)
     : NodeDef(node_id,
-              content_transform.Pass(),
+              std::move(content_transform),
               content_clip.Pass(),
               hit_test_behavior.Pass(),
               combinator,
               child_node_ids),
       layer_rect_(layer_rect),
       blend_(blend.Pass()) {}
 
 LayerNodeDef::~LayerNodeDef() {}
 
 void LayerNodeDef::RecordPictureInner(const SceneContent* content,
                                       const Snapshot* snapshot,
                                       SkCanvas* canvas) const {
   DCHECK(content);
   DCHECK(snapshot);
   DCHECK(canvas);
 
   SkPaint paint;
   SetPaintForBlend(&paint, blend_.get());
 
   canvas->saveLayer(layer_rect_.To<SkRect>(), &paint);
   NodeDef::RecordPictureInner(content, snapshot, canvas);
   canvas->restore();
 }
 
 }  // namespace compositor