gfx/2d/Point.h

   1 /* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  * This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #ifndef MOZILLA_GFX_POINT_H_
   7 #define MOZILLA_GFX_POINT_H_
   8
   9 #include "mozilla/Attributes.h"
  10 #include "Types.h"
  11 #include "Coord.h"
  12 #include "BaseCoord.h"
  13 #include "BasePoint.h"
  14 #include "BasePoint3D.h"
  15 #include "BasePoint4D.h"
  16 #include "BaseSize.h"
  17 #include "mozilla/TypeTraits.h"
  18
  19 #include <cmath>
  20
  21 namespace mozilla {
  22
  23 template <typename> struct IsPixel;
  24
  25 namespace gfx {
  26
  27 // This should only be used by the typedefs below.
  28 struct UnknownUnits {};
  29
  30 }  // close namespace 'gfx' because IsPixel specialization must be in 'mozilla'
  31
  32 template<> struct IsPixel<gfx::UnknownUnits> : TrueType {};
  33
  34 namespace gfx {
  35
  36 template<class units>
  37 struct IntPointTyped :
  38   public BasePoint< int32_t, IntPointTyped<units>, IntCoordTyped<units> >,
  39   public units {
  40   static_assert(IsPixel<units>::value,
  41                 "'units' must be a coordinate system tag");
  42
  43   typedef IntCoordTyped<units> Coord;
  44   typedef BasePoint< int32_t, IntPointTyped<units>, IntCoordTyped<units> > Super;
  45
  46   MOZ_CONSTEXPR IntPointTyped() : Super() {}
  47   MOZ_CONSTEXPR IntPointTyped(int32_t aX, int32_t aY) : Super(Coord(aX), Coord(aY)) {}
  48   // The mixed-type constructors (int, Coord) and (Coord, int) are needed to
  49   // avoid ambiguities because Coord is implicitly convertible to int.
  50   MOZ_CONSTEXPR IntPointTyped(int32_t aX, Coord aY) : Super(Coord(aX), aY) {}
  51   MOZ_CONSTEXPR IntPointTyped(Coord aX, int32_t aY) : Super(aX, Coord(aY)) {}
  52   MOZ_CONSTEXPR IntPointTyped(Coord aX, Coord aY) : Super(aX, aY) {}
  53
  54   // XXX When all of the code is ported, the following functions to convert to and from
  55   // unknown types should be removed.
  56
  57   static IntPointTyped<units> FromUnknownPoint(const IntPointTyped<UnknownUnits>& aPoint) {
  58     return IntPointTyped<units>(aPoint.x, aPoint.y);
  59   }
  60
  61   IntPointTyped<UnknownUnits> ToUnknownPoint() const {
  62     return IntPointTyped<UnknownUnits>(this->x, this->y);
  63   }
  64 };
  65 typedef IntPointTyped<UnknownUnits> IntPoint;
  66
  67 template<class units>
  68 struct PointTyped :
  69   public BasePoint< Float, PointTyped<units>, CoordTyped<units> >,
  70   public units {
  71   static_assert(IsPixel<units>::value,
  72                 "'units' must be a coordinate system tag");
  73
  74   typedef CoordTyped<units> Coord;
  75   typedef BasePoint< Float, PointTyped<units>, CoordTyped<units> > Super;
  76
  77   MOZ_CONSTEXPR PointTyped() : Super() {}
  78   MOZ_CONSTEXPR PointTyped(Float aX, Float aY) : Super(Coord(aX), Coord(aY)) {}
  79   // The mixed-type constructors (Float, Coord) and (Coord, Float) are needed to
  80   // avoid ambiguities because Coord is implicitly convertible to Float.
  81   MOZ_CONSTEXPR PointTyped(Float aX, Coord aY) : Super(Coord(aX), aY) {}
  82   MOZ_CONSTEXPR PointTyped(Coord aX, Float aY) : Super(aX, Coord(aY)) {}
  83   MOZ_CONSTEXPR PointTyped(Coord aX, Coord aY) : Super(aX.value, aY.value) {}
  84   MOZ_CONSTEXPR MOZ_IMPLICIT PointTyped(const IntPointTyped<units>& point) : Super(float(point.x), float(point.y)) {}
  85
  86   // XXX When all of the code is ported, the following functions to convert to and from
  87   // unknown types should be removed.
  88
  89   static PointTyped<units> FromUnknownPoint(const PointTyped<UnknownUnits>& aPoint) {
  90     return PointTyped<units>(aPoint.x, aPoint.y);
  91   }
  92
  93   PointTyped<UnknownUnits> ToUnknownPoint() const {
  94     return PointTyped<UnknownUnits>(this->x, this->y);
  95   }
  96 };
  97 typedef PointTyped<UnknownUnits> Point;
  98
  99 template<class units>
 100 IntPointTyped<units> RoundedToInt(const PointTyped<units>& aPoint) {
 101   return IntPointTyped<units>(int32_t(floorf(aPoint.x + 0.5f)),
 102                               int32_t(floorf(aPoint.y + 0.5f)));
 103 }
 104
 105 template<class units>
 106 IntPointTyped<units> TruncatedToInt(const PointTyped<units>& aPoint) {
 107   return IntPointTyped<units>(int32_t(aPoint.x),
 108                               int32_t(aPoint.y));
 109 }
 110
 111 template<class units>
 112 struct Point3DTyped :
 113   public BasePoint3D< Float, Point3DTyped<units> > {
 114   static_assert(IsPixel<units>::value,
 115                 "'units' must be a coordinate system tag");
 116
 117   typedef BasePoint3D< Float, Point3DTyped<units> > Super;
 118
 119   Point3DTyped() : Super() {}
 120   Point3DTyped(Float aX, Float aY, Float aZ) : Super(aX, aY, aZ) {}
 121
 122   // XXX When all of the code is ported, the following functions to convert to and from
 123   // unknown types should be removed.
 124
 125   static Point3DTyped<units> FromUnknownPoint(const Point3DTyped<UnknownUnits>& aPoint) {
 126     return Point3DTyped<units>(aPoint.x, aPoint.y, aPoint.z);
 127   }
 128
 129   Point3DTyped<UnknownUnits> ToUnknownPoint() const {
 130     return Point3DTyped<UnknownUnits>(this->x, this->y, this->z);
 131   }
 132 };
 133 typedef Point3DTyped<UnknownUnits> Point3D;
 134
 135 template<class units>
 136 struct Point4DTyped :
 137   public BasePoint4D< Float, Point4DTyped<units> > {
 138   static_assert(IsPixel<units>::value,
 139                 "'units' must be a coordinate system tag");
 140
 141   typedef BasePoint4D< Float, Point4DTyped<units> > Super;
 142
 143   Point4DTyped() : Super() {}
 144   Point4DTyped(Float aX, Float aY, Float aZ, Float aW) : Super(aX, aY, aZ, aW) {}
 145
 146   // XXX When all of the code is ported, the following functions to convert to and from
 147   // unknown types should be removed.
 148
 149   static Point4DTyped<units> FromUnknownPoint(const Point4DTyped<UnknownUnits>& aPoint) {
 150     return Point4DTyped<units>(aPoint.x, aPoint.y, aPoint.z, aPoint.w);
 151   }
 152
 153   Point4DTyped<UnknownUnits> ToUnknownPoint() const {
 154     return Point4DTyped<UnknownUnits>(this->x, this->y, this->z, this->w);
 155   }
 156
 157   PointTyped<units> As2DPoint() {
 158     return PointTyped<units>(this->x / this->w, this->y / this->w);
 159   }
 160 };
 161 typedef Point4DTyped<UnknownUnits> Point4D;
 162
 163 template<class units>
 164 struct IntSizeTyped :
 165   public BaseSize< int32_t, IntSizeTyped<units> >,
 166   public units {
 167   static_assert(IsPixel<units>::value,
 168                 "'units' must be a coordinate system tag");
 169
 170   typedef BaseSize< int32_t, IntSizeTyped<units> > Super;
 171
 172   MOZ_CONSTEXPR IntSizeTyped() : Super() {}
 173   MOZ_CONSTEXPR IntSizeTyped(int32_t aWidth, int32_t aHeight) : Super(aWidth, aHeight) {}
 174
 175   // XXX When all of the code is ported, the following functions to convert to and from
 176   // unknown types should be removed.
 177
 178   static IntSizeTyped<units> FromUnknownSize(const IntSizeTyped<UnknownUnits>& aSize) {
 179     return IntSizeTyped<units>(aSize.width, aSize.height);
 180   }
 181
 182   IntSizeTyped<UnknownUnits> ToUnknownSize() const {
 183     return IntSizeTyped<UnknownUnits>(this->width, this->height);
 184   }
 185 };
 186 typedef IntSizeTyped<UnknownUnits> IntSize;
 187
 188 template<class units>
 189 struct SizeTyped :
 190   public BaseSize< Float, SizeTyped<units> >,
 191   public units {
 192   static_assert(IsPixel<units>::value,
 193                 "'units' must be a coordinate system tag");
 194
 195   typedef BaseSize< Float, SizeTyped<units> > Super;
 196
 197   MOZ_CONSTEXPR SizeTyped() : Super() {}
 198   MOZ_CONSTEXPR SizeTyped(Float aWidth, Float aHeight) : Super(aWidth, aHeight) {}
 199   explicit SizeTyped(const IntSizeTyped<units>& size) :
 200     Super(float(size.width), float(size.height)) {}
 201
 202   // XXX When all of the code is ported, the following functions to convert to and from
 203   // unknown types should be removed.
 204
 205   static SizeTyped<units> FromUnknownSize(const SizeTyped<UnknownUnits>& aSize) {
 206     return SizeTyped<units>(aSize.width, aSize.height);
 207   }
 208
 209   SizeTyped<UnknownUnits> ToUnknownSize() const {
 210     return SizeTyped<UnknownUnits>(this->width, this->height);
 211   }
 212 };
 213 typedef SizeTyped<UnknownUnits> Size;
 214
 215 template<class units>
 216 IntSizeTyped<units> RoundedToInt(const SizeTyped<units>& aSize) {
 217   return IntSizeTyped<units>(int32_t(floorf(aSize.width + 0.5f)),
 218                              int32_t(floorf(aSize.height + 0.5f)));
 219 }
 220
 221 }
 222 }
 223
 224 #endif /* MOZILLA_GFX_POINT_H_ */