// Copyright 2011 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 "cc/output/layer_quad.h"

#include <stddef.h>

#include "base/logging.h"
#include "ui/gfx/geometry/quad_f.h"

namespace cc {

LayerQuad::Edge::Edge(const gfx::PointF& p, const gfx::PointF& q) {
  if (p == q) {
    degenerate_ = true;
    return;
  }
  degenerate_ = false;
  gfx::Vector2dF tangent(p.y() - q.y(), q.x() - p.x());
  float cross2 = p.x() * q.y() - q.x() * p.y();

  set(tangent.x(), tangent.y(), cross2);
  scale(1.0f / tangent.Length());
}

gfx::PointF LayerQuad::Edge::Intersect(const LayerQuad::Edge& e) const {
  DCHECK(!degenerate());
  DCHECK(!e.degenerate());

  return gfx::PointF((y() * e.z() - e.y() * z()) / (x() * e.y() - e.x() * y()),
                     (x() * e.z() - e.x() * z()) / (e.x() * y() - x() * e.y()));
}

LayerQuad::LayerQuad(const gfx::QuadF& quad) {
  // Create edges.
  left_ = Edge(quad.p4(), quad.p1());
  right_ = Edge(quad.p2(), quad.p3());
  top_ = Edge(quad.p1(), quad.p2());
  bottom_ = Edge(quad.p3(), quad.p4());

  float sign = quad.IsCounterClockwise() ? -1 : 1;
  left_.scale(sign);
  right_.scale(sign);
  top_.scale(sign);
  bottom_.scale(sign);
}

LayerQuad::LayerQuad(const Edge& left,
                     const Edge& top,
                     const Edge& right,
                     const Edge& bottom)
    : left_(left),
      top_(top),
      right_(right),
      bottom_(bottom) {}

gfx::QuadF LayerQuad::ToQuadF() const {
  size_t num_degenerate_edges = left_.degenerate() + right_.degenerate() +
                                top_.degenerate() + bottom_.degenerate();
  if (num_degenerate_edges > 1) {
    return gfx::QuadF();
  }

  if (left_.degenerate()) {
    return gfx::QuadF(top_.Intersect(bottom_), top_.Intersect(right_),
                      right_.Intersect(bottom_), bottom_.Intersect(top_));
  }
  if (right_.degenerate()) {
    return gfx::QuadF(left_.Intersect(top_), top_.Intersect(bottom_),
                      bottom_.Intersect(top_), bottom_.Intersect(left_));
  }
  if (top_.degenerate()) {
    return gfx::QuadF(left_.Intersect(right_), right_.Intersect(left_),
                      right_.Intersect(bottom_), bottom_.Intersect(left_));
  }
  if (bottom_.degenerate()) {
    return gfx::QuadF(left_.Intersect(top_), top_.Intersect(right_),
                      right_.Intersect(left_), left_.Intersect(right_));
  }
  return gfx::QuadF(left_.Intersect(top_),
                    top_.Intersect(right_),
                    right_.Intersect(bottom_),
                    bottom_.Intersect(left_));
}

void LayerQuad::ToFloatArray(float flattened[12]) const {
  if (left_.degenerate()) {
    flattened[0] = bottom_.x();
    flattened[1] = bottom_.y();
    flattened[2] = bottom_.z();
  } else {
    flattened[0] = left_.x();
    flattened[1] = left_.y();
    flattened[2] = left_.z();
  }
  if (top_.degenerate()) {
    flattened[3] = left_.x();
    flattened[4] = left_.y();
    flattened[5] = left_.z();
  } else {
    flattened[3] = top_.x();
    flattened[4] = top_.y();
    flattened[5] = top_.z();
  }
  if (right_.degenerate()) {
    flattened[6] = top_.x();
    flattened[7] = top_.y();
    flattened[8] = top_.z();
  } else {
    flattened[6] = right_.x();
    flattened[7] = right_.y();
    flattened[8] = right_.z();
  }
  if (bottom_.degenerate()) {
    flattened[9] = right_.x();
    flattened[10] = right_.y();
    flattened[11] = right_.z();
  } else {
    flattened[9] = bottom_.x();
    flattened[10] = bottom_.y();
    flattened[11] = bottom_.z();
  }
}

}  // namespace cc