src/math/rectf.hpp

   1 //  SuperTux
   2 //  Copyright (C) 2006 Matthias Braun <matze@braunis.de>
   3 //
   4 //  This program is free software: you can redistribute it and/or modify
   5 //  it under the terms of the GNU General Public License as published by
   6 //  the Free Software Foundation, either version 3 of the License, or
   7 //  (at your option) any later version.
   8 //
   9 //  This program is distributed in the hope that it will be useful,
  10 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 //  GNU General Public License for more details.
  13 //
  14 //  You should have received a copy of the GNU General Public License
  15 //  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 #ifndef HEADER_SUPERTUX_MATH_RECTF_HPP
  18 #define HEADER_SUPERTUX_MATH_RECTF_HPP
  19
  20 #include <assert.h>
  21
  22 #include "math/vector.hpp"
  23 #include "object/anchor_point.hpp"
  24
  25 class Sizef;
  26
  27 /** This class represents a rectangle.
  28  * (Implementation Note) We're using upper left and lower right point instead of
  29  * upper left and width/height here, because that makes the collision detection
  30  * a little bit more efficient.
  31  */
  32 class Rectf
  33 {
  34 public:
  35   Rectf() :
  36     p1(),
  37     p2()
  38   { }
  39
  40   Rectf(const Vector& np1, const Vector& np2) :
  41     p1(np1), p2(np2)
  42   {
  43   }
  44
  45   Rectf(float x1, float y1, float x2, float y2) :
  46     p1(x1, y1), p2(x2, y2)
  47   {
  48     assert(p1.x <= p2.x && p1.y <= p2.y);
  49   }
  50
  51   Rectf(const Vector& p1_, const Sizef& size);
  52
  53   float get_left() const
  54   { return p1.x; }
  55
  56   float get_right() const
  57   { return p2.x; }
  58
  59   float get_top() const
  60   { return p1.y; }
  61
  62   float get_bottom() const
  63   { return p2.y; }
  64
  65   float get_width() const
  66   { return p2.x - p1.x; }
  67
  68   float get_height() const
  69   { return p2.y - p1.y; }
  70
  71   Vector get_middle() const
  72   { return Vector((p1.x+p2.x)/2, (p1.y+p2.y)/2); }
  73
  74   void set_pos(const Vector& v)
  75   {
  76     move(v-p1);
  77   }
  78
  79   void set_height(float height)
  80   {
  81     p2.y = p1.y + height;
  82   }
  83   void set_width(float width)
  84   {
  85     p2.x = p1.x + width;
  86   }
  87   void set_size(float width, float height)
  88   {
  89     set_width(width);
  90     set_height(height);
  91   }
  92   Vector get_size()
  93   {
  94     return Vector(get_width(), get_height());
  95   }
  96
  97   void move(const Vector& v)
  98   {
  99     p1 += v;
 100     p2 += v;
 101   }
 102
 103   bool contains(const Vector& v) const
 104   {
 105     return v.x >= p1.x && v.y >= p1.y && v.x < p2.x && v.y < p2.y;
 106   }
 107   bool contains(const Rectf& other) const
 108   {
 109     if(p1.x >= other.p2.x || other.p1.x >= p2.x)
 110       return false;
 111     if(p1.y >= other.p2.y || other.p1.y >= p2.y)
 112       return false;
 113
 114     return true;
 115   }
 116
 117   float distance (const Vector& other, AnchorPoint ap = ANCHOR_MIDDLE) const
 118   {
 119     Vector v = get_anchor_pos (*this, ap);
 120     return ((v - other).norm ());
 121   }
 122
 123   float distance (const Rectf& other, AnchorPoint ap = ANCHOR_MIDDLE) const
 124   {
 125     Vector v1 = get_anchor_pos (*this, ap);
 126     Vector v2 = get_anchor_pos (other, ap);
 127
 128     return ((v1 - v2).norm ());
 129   }
 130
 131   // leave these two public to save the headaches of set/get functions for such
 132   // simple things :)
 133
 134   /// upper left edge
 135   Vector p1;
 136   /// lower right edge
 137   Vector p2;
 138 };
 139
 140 #endif
 141
 142 /* EOF */