rect.h

Go to the documentation of this file.

/***************************************************************************
                    rect.h  -  Wrapper class for SDL_Rect
                             -------------------
    begin                : Wed Mar 5 2003
    copyright            : (C) 2003 by Tyler Montbriand
    email                : tsm@accesscomm.ca
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#ifndef RECT_H
#define RECT_H

#include "RotateImage.h"
#include "Fxp.h"

#include <SDL/begin_code.h>


class DECLSPEC Rect:public SDL_Rect
{
public:
  inline Rect()
  {
    Set(0,0,0,0);
  }

  inline Rect(SDL_Rect rect)
  {
    Set(rect);
  }

  inline Rect(Sint16 xin, Sint16 yin, Uint16 win, Uint16 hin)
  {
    Set(xin,yin,win,hin);
  }

  Rect(SfxpCoord coord, Uint16 win, Uint16 hin)
  {
    x=coord.X();
    y=coord.Y();
    w=win;
    h=hin;
  }

  inline Rect Set(SDL_Rect r)
  {
    x=r.x;
    y=r.y;
    w=r.w;
    h=r.h;
    return(*this);
  }

  inline Rect operator =(SDL_Rect r)
  {
    Set(r);
    return(*this);
  }

  inline Rect Set(Sint16 xin, Sint16 yin, Uint16 win, Uint16 hin)
  {
    x=xin;
    y=yin;
    w=win;
    h=hin;
    return(*this);
  }

  inline Rect MoveTo(Sint16 xin, Sint16 yin)
  {
    x=xin;
    y=yin;
    return(*this);
  }

  inline Rect Resize(Uint16 win, Uint16 hin)
  {
    w=win;
    h=hin;
    return(*this);
  }

  inline Rect operator +=(const SfxpCoord coord)
  {
    x+=coord.X();
    y+=coord.Y();
    return(*this);
  }

  inline Rect operator -=(const SfxpCoord coord)
  {
    x-=coord.X();
    y-=coord.Y();
    return(*this);
  }

  inline bool operator ==(const Rect &rect)
  {
    if((x==rect.x)&&(y==rect.y)&&(w=rect.w)&&(h==rect.h))
    {
      return(true);
    }
    else
    {
      return(false);
    }
  }

  inline bool operator !=(const Rect &rect)
  {
    return(!((*this)==rect));
  }
  
  inline int LastX()
  {
    if(w==0)  return(-1); /* Return -1 if rect has no area  */
    else      return(x+(w-1));
  }

  inline int LastY()
  {
    if(h==0)  return(-1); /* Return -1 if rect has no area  */
    else      return(y+(h-1));
  }

  inline bool Intersect(SDL_Rect &r, SDL_Rect rect) const
  {
    if(Intersect1D(r.x,r.w,x,w,rect.x,rect.w))
    {
      return(Intersect1D(r.y,r.h,y,h,rect.y,rect.h));      
    }
    else
    {
      return(false);
    }
  }

  inline bool Overlaps(SDL_Rect rect) const
  {
    if(Collide1D(x,w,rect.x,rect.w))
    {
      return(Collide1D(y,h,rect.y,rect.h));
    }
    else
    {
      return(false);
    }
  }

  inline void Draw(SDL_Surface *surf, Uint8 r, Uint8 g, Uint8 b)
  {
    if(surf==NULL)  return;

    SDL_FillRect(surf,this,SDL_MapRGB(surf->format,r,g,b));
  }

  inline void Update(SDL_Surface *screen)
  {
    SDL_UpdateRect(screen,x,y,w,h);    
  }

  inline int Area() const
  {
    return(((Sint16)w)*((Sint16)h));
  }

  inline Rect &Normalize()
  {
    if(x<0)
    {
      w+=x;
      x=0;
    }

    if(y<0)
    {
      h+=y;
      y=0;
    }
   
    return(*this);
  }

  inline bool Merge(SDL_Rect r)
  {
    int minx=0,maxx=0,miny=0,maxy=0;
    int prevarea=-1;
    Rect newrect;

    prevarea=Rect(r).Area()+Area();
    
    minx=x;
    maxx=x+w;
    miny=y;
    maxy=y+h;

    if(r.x<minx)      minx=r.x;
    if(r.x+r.w>maxx)  maxx=r.x+r.w;
    if(r.y<miny)      miny=r.y;
    if(r.y+r.h>maxy)  maxy=r.y+r.h;
    
    newrect.Set(minx,miny,maxx-minx,maxy-miny);
    
    if(newrect.Area()<=prevarea)
    {
      Set(newrect);      
      return(true);
    }
    else
    {  
      return(false);
    }    
  }

  int Print(FILE *fp=stderr) const
  {
    return(fprintf(fp,"Rect(%p) (%d,%d:%d,%d)\n",(void *)this,x,y,w,h));
  }


  /*** Some extra functions, implemented in rect_ops.h ***/
  
  inline Rect Shrink(int border=1);  
  inline Rect ShrinkBottom(int amount);
  inline Rect ShrinkTop(int amount);
  inline Rect ExpandDown(int amount, int max=-1);
  inline Rect ExpandUp(int amount);  
  inline Rect ShrinkLeft(int amount);  
  inline Rect ExpandLeft(int amount);
  inline Rect ShrinkRight(int amount);    
  inline Rect ExpandRight(int amount, int max=-1);
  inline bool AreaIsTransparent(SDL_Surface *surf, Rect r);
  
private:

  inline bool Intersect1D(Sint16 &pout, Uint16 &lout,
                          Sint16 pos1, Uint16 len1,
                          Sint16 pos2, Uint16 len2   ) const
  {
    int dp=pos2-pos1;

    if(dp<0)
    {
      Swap(pos1,pos2);
      Swap(len1,len2);
      dp=-dp;
    }

    if(Collide1D(pos1,len1,pos2,len2))
    {      
      if(Contains(pos1,len1,pos2,len2))
      {
        pout=pos2;
        lout=len2;
        return(true);
      }
      else
      {
        if(len1==dp)  return(false);
        
        pout=pos2;
        lout=len1-dp;
        return(true);
      }
    }
                
    return(false);
  }

  inline void Swap(Sint16 &i1, Sint16 &i2) const
  {
    Sint16 i3=i1;
    i1=i2;
    i2=i3;
  }
  
  inline void Swap(Uint16 &i1, Uint16 &i2) const
  {
    Uint16 i3=i1;
    i1=i2;
    i2=i3;
  }

  inline bool Contains(int pos1, int len1, int pos2, int len2) const
  {
    if( (pos2>=pos1) && ((pos2+len2)<=(pos1+len1)) )
    {
      return(true);      
    }
    else
    {
      return(false);
    }
  }

  inline bool Collide1D(int pos1, int len1, int pos2, int len2) const
  {
    int dp=pos2-pos1;
    if(dp>=0)
    {
      if(dp<len1) return(true);
      else        return(false);      
    }
    else
    {
      dp=-dp;
      if(dp<len2) return(true);
      else        return(false);
    }
  }
};


#include <SDL/close_code.h>

#endif/*RECT_H_*/

---