gfx/2d/Point.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef MOZILLA_GFX_POINT_H_
   8 #define MOZILLA_GFX_POINT_H_
   9
  10 #include "mozilla/Attributes.h"
  11 #include "Types.h"
  12 #include "Coord.h"
  13 #include "BaseCoord.h"
  14 #include "BasePoint.h"
  15 #include "BasePoint3D.h"
  16 #include "BasePoint4D.h"
  17 #include "BaseSize.h"
  18 #include "mozilla/Maybe.h"
  19 #include "mozilla/gfx/NumericTools.h"
  20
  21 #include <cmath>
  22 #include <type_traits>
  23
  24 namespace mozilla {
  25
  26 template <typename>
  27 struct IsPixel;
  28
  29 template <>
  30 struct IsPixel<gfx::UnknownUnits> : std::true_type {};
  31
  32 namespace gfx {
  33
  34 /// Use this for parameters of functions to allow implicit conversions to
  35 /// integer types but not floating point types.
  36 /// We use this wrapper to prevent IntSize and IntPoint's constructors to
  37 /// take foating point values as parameters, and not require their constructors
  38 /// to have implementations for each permutation of integer types.
  39 template <typename T>
  40 struct IntParam {
  41   constexpr MOZ_IMPLICIT IntParam(char val) : value(val) {}
  42   constexpr MOZ_IMPLICIT IntParam(unsigned char val) : value(val) {}
  43   constexpr MOZ_IMPLICIT IntParam(short val) : value(val) {}
  44   constexpr MOZ_IMPLICIT IntParam(unsigned short val) : value(val) {}
  45   constexpr MOZ_IMPLICIT IntParam(int val) : value(val) {}
  46   constexpr MOZ_IMPLICIT IntParam(unsigned int val) : value(val) {}
  47   constexpr MOZ_IMPLICIT IntParam(long val) : value(val) {}
  48   constexpr MOZ_IMPLICIT IntParam(unsigned long val) : value(val) {}
  49   constexpr MOZ_IMPLICIT IntParam(long long val) : value(val) {}
  50   constexpr MOZ_IMPLICIT IntParam(unsigned long long val) : value(val) {}
  51   template <typename Unit>
  52   constexpr MOZ_IMPLICIT IntParam(IntCoordTyped<Unit> val) : value(val) {}
  53
  54   // Disable the evil ones!
  55   MOZ_IMPLICIT IntParam(float val) = delete;
  56   MOZ_IMPLICIT IntParam(double val) = delete;
  57
  58   T value;
  59 };
  60
  61 template <class Units, class>
  62 struct PointTyped;
  63 template <class Units, class>
  64 struct SizeTyped;
  65
  66 template <class Units>
  67 struct MOZ_EMPTY_BASES IntPointTyped
  68     : public BasePoint<int32_t, IntPointTyped<Units>, IntCoordTyped<Units> >,
  69       public Units {
  70   static_assert(IsPixel<Units>::value,
  71                 "'Units' must be a coordinate system tag");
  72
  73   typedef IntParam<int32_t> ToInt;
  74   typedef IntCoordTyped<Units> Coord;
  75   typedef BasePoint<int32_t, IntPointTyped<Units>, IntCoordTyped<Units> > Super;
  76
  77   constexpr IntPointTyped() : Super() {
  78     static_assert(sizeof(IntPointTyped) == sizeof(int32_t) * 2,
  79                   "Would be unfortunate otherwise!");
  80   }
  81   constexpr IntPointTyped(ToInt aX, ToInt aY)
  82       : Super(Coord(aX.value), Coord(aY.value)) {}
  83
  84   static IntPointTyped Round(float aX, float aY) {
  85     return IntPointTyped(int32_t(floorf(aX + 0.5f)),
  86                          int32_t(floorf(aY + 0.5f)));
  87   }
  88
  89   static IntPointTyped Ceil(float aX, float aY) {
  90     return IntPointTyped(int32_t(ceilf(aX)), int32_t(ceilf(aY)));
  91   }
  92
  93   static IntPointTyped Floor(float aX, float aY) {
  94     return IntPointTyped(int32_t(floorf(aX)), int32_t(floorf(aY)));
  95   }
  96
  97   static IntPointTyped Truncate(float aX, float aY) {
  98     return IntPointTyped(int32_t(aX), int32_t(aY));
  99   }
 100
 101   static IntPointTyped Round(const PointTyped<Units, float>& aPoint);
 102   static IntPointTyped Ceil(const PointTyped<Units, float>& aPoint);
 103   static IntPointTyped Floor(const PointTyped<Units, float>& aPoint);
 104   static IntPointTyped Truncate(const PointTyped<Units, float>& aPoint);
 105
 106   // XXX When all of the code is ported, the following functions to convert to
 107   // and from unknown types should be removed.
 108
 109   static IntPointTyped FromUnknownPoint(
 110       const IntPointTyped<UnknownUnits>& aPoint) {
 111     return IntPointTyped<Units>(aPoint.x, aPoint.y);
 112   }
 113
 114   IntPointTyped<UnknownUnits> ToUnknownPoint() const {
 115     return IntPointTyped<UnknownUnits>(this->x, this->y);
 116   }
 117
 118   IntPointTyped RoundedToMultiple(int32_t aMultiplier) const {
 119     return {RoundToMultiple(this->x, aMultiplier),
 120             RoundToMultiple(this->y, aMultiplier)};
 121   }
 122 };
 123 typedef IntPointTyped<UnknownUnits> IntPoint;
 124
 125 template <class Units, class F = Float>
 126 struct MOZ_EMPTY_BASES PointTyped
 127     : public BasePoint<F, PointTyped<Units, F>, CoordTyped<Units, F> >,
 128       public Units {
 129   static_assert(IsPixel<Units>::value,
 130                 "'Units' must be a coordinate system tag");
 131
 132   typedef CoordTyped<Units, F> Coord;
 133   typedef BasePoint<F, PointTyped<Units, F>, CoordTyped<Units, F> > Super;
 134
 135   constexpr PointTyped() : Super() {
 136     static_assert(sizeof(PointTyped) == sizeof(F) * 2,
 137                   "Would be unfortunate otherwise!");
 138   }
 139   constexpr PointTyped(F aX, F aY) : Super(Coord(aX), Coord(aY)) {}
 140   // The mixed-type constructors (Float, Coord) and (Coord, Float) are needed to
 141   // avoid ambiguities because Coord is implicitly convertible to Float.
 142   constexpr PointTyped(F aX, Coord aY) : Super(Coord(aX), aY) {}
 143   constexpr PointTyped(Coord aX, F aY) : Super(aX, Coord(aY)) {}
 144   constexpr PointTyped(Coord aX, Coord aY) : Super(aX.value, aY.value) {}
 145   constexpr MOZ_IMPLICIT PointTyped(const IntPointTyped<Units>& point)
 146       : Super(F(point.x), F(point.y)) {}
 147
 148   bool WithinEpsilonOf(const PointTyped<Units, F>& aPoint, F aEpsilon) const {
 149     return fabs(aPoint.x - this->x) < aEpsilon &&
 150            fabs(aPoint.y - this->y) < aEpsilon;
 151   }
 152
 153   // XXX When all of the code is ported, the following functions to convert to
 154   // and from unknown types should be removed.
 155
 156   static PointTyped<Units, F> FromUnknownPoint(
 157       const PointTyped<UnknownUnits, F>& aPoint) {
 158     return PointTyped<Units, F>(aPoint.x, aPoint.y);
 159   }
 160
 161   PointTyped<UnknownUnits, F> ToUnknownPoint() const {
 162     return PointTyped<UnknownUnits, F>(this->x, this->y);
 163   }
 164 };
 165 typedef PointTyped<UnknownUnits> Point;
 166 typedef PointTyped<UnknownUnits, double> PointDouble;
 167
 168 template <class Units>
 169 IntPointTyped<Units> RoundedToInt(const PointTyped<Units>& aPoint) {
 170   return IntPointTyped<Units>::Round(aPoint.x, aPoint.y);
 171 }
 172
 173 template <class Units>
 174 IntPointTyped<Units> TruncatedToInt(const PointTyped<Units>& aPoint) {
 175   return IntPointTyped<Units>::Truncate(aPoint.x, aPoint.y);
 176 }
 177
 178 template <class Units, class F = Float>
 179 struct Point3DTyped : public BasePoint3D<F, Point3DTyped<Units, F> > {
 180   static_assert(IsPixel<Units>::value,
 181                 "'Units' must be a coordinate system tag");
 182
 183   typedef BasePoint3D<F, Point3DTyped<Units, F> > Super;
 184
 185   Point3DTyped() : Super() {
 186     static_assert(sizeof(Point3DTyped) == sizeof(F) * 3,
 187                   "Would be unfortunate otherwise!");
 188   }
 189   Point3DTyped(F aX, F aY, F aZ) : Super(aX, aY, aZ) {}
 190
 191   // XXX When all of the code is ported, the following functions to convert to
 192   // and from unknown types should be removed.
 193
 194   static Point3DTyped<Units, F> FromUnknownPoint(
 195       const Point3DTyped<UnknownUnits, F>& aPoint) {
 196     return Point3DTyped<Units, F>(aPoint.x, aPoint.y, aPoint.z);
 197   }
 198
 199   Point3DTyped<UnknownUnits, F> ToUnknownPoint() const {
 200     return Point3DTyped<UnknownUnits, F>(this->x, this->y, this->z);
 201   }
 202 };
 203 typedef Point3DTyped<UnknownUnits> Point3D;
 204 typedef Point3DTyped<UnknownUnits, double> PointDouble3D;
 205
 206 template <typename Units>
 207 IntPointTyped<Units> IntPointTyped<Units>::Round(
 208     const PointTyped<Units, float>& aPoint) {
 209   return IntPointTyped::Round(aPoint.x, aPoint.y);
 210 }
 211
 212 template <typename Units>
 213 IntPointTyped<Units> IntPointTyped<Units>::Ceil(
 214     const PointTyped<Units, float>& aPoint) {
 215   return IntPointTyped::Ceil(aPoint.x, aPoint.y);
 216 }
 217
 218 template <typename Units>
 219 IntPointTyped<Units> IntPointTyped<Units>::Floor(
 220     const PointTyped<Units, float>& aPoint) {
 221   return IntPointTyped::Floor(aPoint.x, aPoint.y);
 222 }
 223
 224 template <typename Units>
 225 IntPointTyped<Units> IntPointTyped<Units>::Truncate(
 226     const PointTyped<Units, float>& aPoint) {
 227   return IntPointTyped::Truncate(aPoint.x, aPoint.y);
 228 }
 229
 230 template <class Units, class F = Float>
 231 struct Point4DTyped : public BasePoint4D<F, Point4DTyped<Units, F> > {
 232   static_assert(IsPixel<Units>::value,
 233                 "'Units' must be a coordinate system tag");
 234
 235   typedef BasePoint4D<F, Point4DTyped<Units, F> > Super;
 236
 237   Point4DTyped() : Super() {
 238     static_assert(sizeof(Point4DTyped) == sizeof(F) * 4,
 239                   "Would be unfortunate otherwise!");
 240   }
 241   Point4DTyped(F aX, F aY, F aZ, F aW) : Super(aX, aY, aZ, aW) {}
 242
 243   explicit Point4DTyped(const Point3DTyped<Units, F>& aPoint)
 244       : Super(aPoint.x, aPoint.y, aPoint.z, 1) {}
 245
 246   // XXX When all of the code is ported, the following functions to convert to
 247   // and from unknown types should be removed.
 248
 249   static Point4DTyped<Units, F> FromUnknownPoint(
 250       const Point4DTyped<UnknownUnits, F>& aPoint) {
 251     return Point4DTyped<Units, F>(aPoint.x, aPoint.y, aPoint.z, aPoint.w);
 252   }
 253
 254   Point4DTyped<UnknownUnits, F> ToUnknownPoint() const {
 255     return Point4DTyped<UnknownUnits, F>(this->x, this->y, this->z, this->w);
 256   }
 257
 258   PointTyped<Units, F> As2DPoint() const {
 259     return PointTyped<Units, F>(this->x / this->w, this->y / this->w);
 260   }
 261
 262   Point3DTyped<Units, F> As3DPoint() const {
 263     return Point3DTyped<Units, F>(this->x / this->w, this->y / this->w,
 264                                   this->z / this->w);
 265   }
 266 };
 267 typedef Point4DTyped<UnknownUnits> Point4D;
 268 typedef Point4DTyped<UnknownUnits, double> PointDouble4D;
 269
 270 template <class Units>
 271 struct MOZ_EMPTY_BASES IntSizeTyped
 272     : public BaseSize<int32_t, IntSizeTyped<Units>, IntCoordTyped<Units> >,
 273       public Units {
 274   static_assert(IsPixel<Units>::value,
 275                 "'Units' must be a coordinate system tag");
 276
 277   typedef IntCoordTyped<Units> Coord;
 278   typedef BaseSize<int32_t, IntSizeTyped<Units>, Coord> Super;
 279
 280   constexpr IntSizeTyped() : Super() {
 281     static_assert(sizeof(IntSizeTyped) == sizeof(int32_t) * 2,
 282                   "Would be unfortunate otherwise!");
 283   }
 284   constexpr IntSizeTyped(Coord aWidth, Coord aHeight)
 285       : Super(aWidth.value, aHeight.value) {}
 286
 287   static IntSizeTyped Round(float aWidth, float aHeight) {
 288     return IntSizeTyped(int32_t(floorf(aWidth + 0.5)),
 289                         int32_t(floorf(aHeight + 0.5)));
 290   }
 291
 292   static IntSizeTyped Truncate(float aWidth, float aHeight) {
 293     return IntSizeTyped(int32_t(aWidth), int32_t(aHeight));
 294   }
 295
 296   static IntSizeTyped Ceil(float aWidth, float aHeight) {
 297     return IntSizeTyped(int32_t(ceil(aWidth)), int32_t(ceil(aHeight)));
 298   }
 299
 300   static IntSizeTyped Floor(float aWidth, float aHeight) {
 301     return IntSizeTyped(int32_t(floorf(aWidth)), int32_t(floorf(aHeight)));
 302   }
 303
 304   static IntSizeTyped Round(const SizeTyped<Units, float>& aSize);
 305   static IntSizeTyped Ceil(const SizeTyped<Units, float>& aSize);
 306   static IntSizeTyped Floor(const SizeTyped<Units, float>& aSize);
 307   static IntSizeTyped Truncate(const SizeTyped<Units, float>& aSize);
 308
 309   IntSizeTyped TruncatedToMultiple(int32_t aMultiplier) const {
 310     if (aMultiplier == 1) {
 311       return *this;
 312     }
 313     return {RoundDownToMultiple(this->width, aMultiplier),
 314             RoundDownToMultiple(this->height, aMultiplier)};
 315   }
 316
 317   IntSizeTyped CeiledToMultiple(int32_t aMultiplier) const {
 318     if (aMultiplier == 1) {
 319       return *this;
 320     }
 321     return {RoundUpToMultiple(this->width, aMultiplier),
 322             RoundUpToMultiple(this->height, aMultiplier)};
 323   }
 324
 325   // XXX When all of the code is ported, the following functions to convert to
 326   // and from unknown types should be removed.
 327
 328   static IntSizeTyped FromUnknownSize(const IntSizeTyped<UnknownUnits>& aSize) {
 329     return IntSizeTyped(aSize.width, aSize.height);
 330   }
 331
 332   IntSizeTyped<UnknownUnits> ToUnknownSize() const {
 333     return IntSizeTyped<UnknownUnits>(this->width, this->height);
 334   }
 335 };
 336 typedef IntSizeTyped<UnknownUnits> IntSize;
 337 typedef Maybe<IntSize> MaybeIntSize;
 338
 339 template <class Units, class F = Float>
 340 struct MOZ_EMPTY_BASES SizeTyped
 341     : public BaseSize<F, SizeTyped<Units, F>, CoordTyped<Units, F> >,
 342       public Units {
 343   static_assert(IsPixel<Units>::value,
 344                 "'Units' must be a coordinate system tag");
 345
 346   typedef CoordTyped<Units, F> Coord;
 347   typedef BaseSize<F, SizeTyped<Units, F>, Coord> Super;
 348
 349   constexpr SizeTyped() : Super() {
 350     static_assert(sizeof(SizeTyped) == sizeof(F) * 2,
 351                   "Would be unfortunate otherwise!");
 352   }
 353   constexpr SizeTyped(Coord aWidth, Coord aHeight) : Super(aWidth, aHeight) {}
 354   explicit SizeTyped(const IntSizeTyped<Units>& size)
 355       : Super(F(size.width), F(size.height)) {}
 356
 357   // XXX When all of the code is ported, the following functions to convert to
 358   // and from unknown types should be removed.
 359
 360   static SizeTyped<Units, F> FromUnknownSize(
 361       const SizeTyped<UnknownUnits, F>& aSize) {
 362     return SizeTyped<Units, F>(aSize.width, aSize.height);
 363   }
 364
 365   SizeTyped<UnknownUnits, F> ToUnknownSize() const {
 366     return SizeTyped<UnknownUnits, F>(this->width, this->height);
 367   }
 368 };
 369 typedef SizeTyped<UnknownUnits> Size;
 370 typedef SizeTyped<UnknownUnits, double> SizeDouble;
 371
 372 template <class Units>
 373 IntSizeTyped<Units> RoundedToInt(const SizeTyped<Units>& aSize) {
 374   return IntSizeTyped<Units>(int32_t(floorf(aSize.width + 0.5f)),
 375                              int32_t(floorf(aSize.height + 0.5f)));
 376 }
 377
 378 template <typename Units>
 379 IntSizeTyped<Units> IntSizeTyped<Units>::Round(
 380     const SizeTyped<Units, float>& aSize) {
 381   return IntSizeTyped::Round(aSize.width, aSize.height);
 382 }
 383
 384 template <typename Units>
 385 IntSizeTyped<Units> IntSizeTyped<Units>::Ceil(
 386     const SizeTyped<Units, float>& aSize) {
 387   return IntSizeTyped::Ceil(aSize.width, aSize.height);
 388 }
 389
 390 template <typename Units>
 391 IntSizeTyped<Units> IntSizeTyped<Units>::Floor(
 392     const SizeTyped<Units, float>& aSize) {
 393   return IntSizeTyped::Floor(aSize.width, aSize.height);
 394 }
 395
 396 template <typename Units>
 397 IntSizeTyped<Units> IntSizeTyped<Units>::Truncate(
 398     const SizeTyped<Units, float>& aSize) {
 399   return IntSizeTyped::Truncate(aSize.width, aSize.height);
 400 }
 401
 402 }  // namespace gfx
 403 }  // namespace mozilla
 404
 405 #endif /* MOZILLA_GFX_POINT_H_ */