Public API Reference

csgeom/csrect.h

Go to the documentation of this file.

/*
    Crystal Space Engine: rectangle class interface
    Copyright (C) 2001 by Jorrit Tyberghein
    Copyright (C) 1998,1999 by Andrew Zabolotny <[email protected]>

    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 along with this library; if not, write to the Free
    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#ifndef __CS_RECT_H__
#define __CS_RECT_H__

#include "csextern.h"

class CS_CRYSTALSPACE_EXPORT csRect
{
public:
  int xmin, ymin, xmax, ymax;

  csRect ();

  csRect (int ixmin, int iymin, int ixmax, int iymax);

  csRect (const csRect &copy);

  virtual ~csRect ();

  void Intersect (int ixmin, int iymin, int ixmax, int iymax);

  inline void Intersect (const csRect &other)
  { Intersect (other.xmin, other.ymin, other.xmax, other.ymax); }

  bool Intersects (const csRect &target) const;

  void Union (int ixmin, int iymin, int ixmax, int iymax);

  inline void Union (const csRect &other)
  { Union (other.xmin, other.ymin, other.xmax, other.ymax); }

  void Exclude (int ixmin, int iymin, int ixmax, int iymax);

  inline void Exclude (const csRect &other)
  { Exclude (other.xmin, other.ymin, other.xmax, other.ymax); }

  void Subtract (const csRect &rect);

  inline bool IsEmpty () const
  { return (xmin >= xmax) || (ymin >= ymax); }

  inline void MakeEmpty ()
  { xmin = xmax = 0; }

  inline void Set (int ixmin, int iymin, int ixmax, int iymax)
  {
    xmin = ixmin; xmax = ixmax;
    ymin = iymin; ymax = iymax;
  }

  inline void Set (const csRect &target)
  {
    xmin = target.xmin; xmax = target.xmax;
    ymin = target.ymin; ymax = target.ymax;
  }

  inline void SetPos (int x, int y)
  { 
        int w = Width(), h=Height(); 
    
        xmin = x; ymin = y; 
        xmax = xmin+w;
        ymax = ymin+h;
   }

  inline void SetSize (int w, int h)
  { xmax = xmin + w; ymax = ymin + h; }

  inline void Move (int dX, int dY)
  { xmin += dX; xmax += dX; ymin += dY; ymax += dY; }

  inline int Width () const { return xmax - xmin; }

  inline int Height () const { return ymax - ymin; }

  inline bool Contains (int x, int y) const
  { return (x >= xmin) && (x < xmax) && (y >= ymin) && (y < ymax); }

  inline bool ContainsRel (int x, int y) const
  { return (x >= 0) && (x < Width ()) && (y >= 0) && (y < Height ()); }

  inline bool Equal (int ixmin, int iymin, int ixmax, int iymax) const
  { return (xmin == ixmin) && (ymin == iymin) &&
           (xmax == ixmax) && (ymax == iymax); }
  inline bool Equal (const csRect &other) const
  { return Equal (other.xmin, other.ymin, other.xmax, other.ymax); }

  inline void Normalize ()
  {
    if (xmin > xmax) { int tmp = xmin; xmin = xmax; xmax = tmp; }
    if (ymin > ymax) { int tmp = ymin; ymin = ymax; ymax = tmp; }
  }

  inline int Area () const
  {
    if (IsEmpty ())
      return 0;
    else
      return Width () * Height ();
  }

  void AddAdjacent (const csRect &rect);
  
  CS_DEPRECATED_METHOD_MSG("Misspelling; use AddAdjacent() instead")
  void AddAdjanced (const csRect &rect)
  { AddAdjacent (rect); }

  inline bool operator == (const csRect& rect) const
  {
    return Equal (rect);
  }

  inline bool operator != (const csRect &rect) const
  {
    return !Equal (rect);
  }

  inline void Extend (int x, int y)
  {
    if (xmin > x) xmin = x; if (xmax < x+1) xmax = x+1;
    if (ymin > y) ymin = y; if (ymax < y+1) ymax = y+1;
  }

  void Join (const csRect &rect);

  void Outset(int n);

  void Inset(int n);

  bool ClipLineGeneral (int& x1, int& y1, int& x2, int& y2);

  bool ClipLine (int& x1, int& y1, int& x2, int& y2);

  bool ClipLineSafe (int& x1, int& y1, int& x2, int& y2);
};

#endif // __CS_RECT_H__

---