| /* |
| Copyright (C) 2004, 2005, 2006 Nikolas Zimmermann <wildfox@kde.org> |
| 2004, 2005 Rob Buis <buis@kde.org> |
| 2005 Eric Seidel <eric@webkit.org> |
| 2010 Zoltan Herczeg <zherczeg@webkit.org> |
| |
| This library is free software; you can redistribute it and/or |
| modify it under the terms of the GNU Library General Public |
| License as published by the Free Software Foundation; either |
| version 2 of the License, or (at your option) any later version. |
| |
| This library is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| Library General Public License for more details. |
| |
| You should have received a copy of the GNU Library General Public License |
| aint with this library; see the file COPYING.LIB. If not, write to |
| the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, |
| Boston, MA 02110-1301, USA. |
| */ |
| |
| #ifndef FloatPoint3D_h |
| #define FloatPoint3D_h |
| |
| #include "platform/geometry/FloatPoint.h" |
| #include "third_party/skia/include/core/SkPoint3.h" |
| #include "wtf/Allocator.h" |
| |
| namespace blink { |
| |
| class PLATFORM_EXPORT FloatPoint3D { |
| DISALLOW_NEW(); |
| |
| public: |
| FloatPoint3D() : m_x(0), m_y(0), m_z(0) {} |
| |
| FloatPoint3D(float x, float y, float z) : m_x(x), m_y(y), m_z(z) {} |
| |
| FloatPoint3D(const FloatPoint& p) : m_x(p.x()), m_y(p.y()), m_z(0) {} |
| |
| FloatPoint3D(const FloatPoint3D& p) : m_x(p.x()), m_y(p.y()), m_z(p.z()) {} |
| |
| float x() const { return m_x; } |
| void setX(float x) { m_x = x; } |
| |
| float y() const { return m_y; } |
| void setY(float y) { m_y = y; } |
| |
| float z() const { return m_z; } |
| void setZ(float z) { m_z = z; } |
| void set(float x, float y, float z) { |
| m_x = x; |
| m_y = y; |
| m_z = z; |
| } |
| void move(float dx, float dy, float dz) { |
| m_x += dx; |
| m_y += dy; |
| m_z += dz; |
| } |
| void scale(float sx, float sy, float sz) { |
| m_x *= sx; |
| m_y *= sy; |
| m_z *= sz; |
| } |
| |
| bool isZero() const { return !m_x && !m_y && !m_z; } |
| |
| void normalize(); |
| |
| float dot(const FloatPoint3D& a) const { |
| return m_x * a.x() + m_y * a.y() + m_z * a.z(); |
| } |
| |
| // Compute the angle (in radians) between this and y. If either vector is the |
| // zero vector, return an angle of 0. |
| float angleBetween(const FloatPoint3D& y) const; |
| |
| // Sets this FloatPoint3D to the cross product of the passed two. |
| // It is safe for "this" to be the same as either or both of the |
| // arguments. |
| void cross(const FloatPoint3D& a, const FloatPoint3D& b) { |
| float x = a.y() * b.z() - a.z() * b.y(); |
| float y = a.z() * b.x() - a.x() * b.z(); |
| float z = a.x() * b.y() - a.y() * b.x(); |
| m_x = x; |
| m_y = y; |
| m_z = z; |
| } |
| |
| // Convenience function returning "this cross point" as a |
| // stack-allocated result. |
| FloatPoint3D cross(const FloatPoint3D& point) const { |
| FloatPoint3D result; |
| result.cross(*this, point); |
| return result; |
| } |
| |
| float lengthSquared() const { return this->dot(*this); } |
| float length() const { return sqrtf(lengthSquared()); } |
| |
| float distanceTo(const FloatPoint3D& a) const; |
| |
| operator SkPoint3() const { return SkPoint3::Make(m_x, m_y, m_z); } |
| |
| String toString() const; |
| |
| private: |
| float m_x; |
| float m_y; |
| float m_z; |
| }; |
| |
| inline FloatPoint3D& operator+=(FloatPoint3D& a, const FloatPoint3D& b) { |
| a.move(b.x(), b.y(), b.z()); |
| return a; |
| } |
| |
| inline FloatPoint3D& operator-=(FloatPoint3D& a, const FloatPoint3D& b) { |
| a.move(-b.x(), -b.y(), -b.z()); |
| return a; |
| } |
| |
| inline FloatPoint3D operator+(const FloatPoint3D& a, const FloatPoint3D& b) { |
| return FloatPoint3D(a.x() + b.x(), a.y() + b.y(), a.z() + b.z()); |
| } |
| |
| inline FloatPoint3D operator-(const FloatPoint3D& a, const FloatPoint3D& b) { |
| return FloatPoint3D(a.x() - b.x(), a.y() - b.y(), a.z() - b.z()); |
| } |
| |
| inline bool operator==(const FloatPoint3D& a, const FloatPoint3D& b) { |
| return a.x() == b.x() && a.y() == b.y() && a.z() == b.z(); |
| } |
| |
| inline bool operator!=(const FloatPoint3D& a, const FloatPoint3D& b) { |
| return a.x() != b.x() || a.y() != b.y() || a.z() != b.z(); |
| } |
| |
| inline float operator*(const FloatPoint3D& a, const FloatPoint3D& b) { |
| // dot product |
| return a.dot(b); |
| } |
| |
| inline FloatPoint3D operator*(float k, const FloatPoint3D& v) { |
| return FloatPoint3D(k * v.x(), k * v.y(), k * v.z()); |
| } |
| |
| inline FloatPoint3D operator*(const FloatPoint3D& v, float k) { |
| return FloatPoint3D(k * v.x(), k * v.y(), k * v.z()); |
| } |
| |
| inline float FloatPoint3D::distanceTo(const FloatPoint3D& a) const { |
| return (*this - a).length(); |
| } |
| |
| // Redeclared here to avoid ODR issues. |
| // See platform/testing/GeometryPrinters.h. |
| void PrintTo(const FloatPoint3D&, std::ostream*); |
| |
| } // namespace blink |
| |
| #endif // FloatPoint3D_h |