CURect.h

//
//  CURect.h
//  Cornell University Game Library (CUGL)
//
//  This module provides support for a 2d bouding rectangle.  This rectangle
//  is not intended for drawing.  Use CUPoly2 instead for rectangle graphics.
//
//  Because math objects are intended to be on the stack, we do not provide
//  any shared pointer support in this class.
//
//  CUGL MIT License:
//      This software is provided 'as-is', without any express or implied
//      warranty.  In no event will the authors be held liable for any damages
//      arising from the use of this software.
//
//      Permission is granted to anyone to use this software for any purpose,
//      including commercial applications, and to alter it and redistribute it
//      freely, subject to the following restrictions:
//
//      1. The origin of this software must not be misrepresented; you must not
//      claim that you wrote the original software. If you use this software
//      in a product, an acknowledgment in the product documentation would be
//      appreciated but is not required.
//
//      2. Altered source versions must be plainly marked as such, and must not
//      be misrepresented as being the original software.
//
//      3. This notice may not be removed or altered from any source distribution.
//
//  Author: Walker White
//  Version: 5/30/16
#ifndef __CU_RECT_H__
#define __CU_RECT_H__
 
#include "CUSize.h"
#include "CUVec2.h"
 
namespace cugl {
 
class Rect {
#pragma mark Values
public:
    Vec2 origin;
    Size  size;
    
    static const Rect ZERO;
    static const Rect UNIT;
 
 
#pragma mark -
#pragma mark Constructors
public:
    Rect() : Rect(Vec2::ZERO,Size::ZERO) {}
 
    Rect(float x, float y, float width, float height) :
        Rect(Vec2(x,y),Size(width,height)) {}
 
    Rect(float* array) : Rect(Vec2(array),Size(&array[2])) {}
 
    
    Rect(const Vec2& pos, const Size& dimen) {
        origin = pos; size = dimen;
    }
 
    
#pragma mark -
#pragma mark Setters
 
    Rect& operator=(const float* array) {
        return set(array);
    }
    
    Rect& set(float x, float y, float width, float height) {
        origin.set(x,y); size.set(width,height);
        return *this;
    }
 
    Rect& set(const float* array) {
        origin = &array[0]; size = &array[2];
        return *this;
    }
    Rect& set(const Vec2& pos, const Size& dimen) {
        origin.set(pos); size.set(dimen);
        return *this;
    }
    
    Rect& set(const Rect& other) {
        origin.set(other.origin); size.set(other.size);
        return *this;
    }
 
 
#pragma mark -
#pragma mark Accessors
    
    float getMinX() const { return (size.width < 0 ? origin.x+size.width : origin.x); }
    
    float getMidX() const { return origin.x + size.width / 2.0f; }
    
    float getMaxX() const { return (size.width < 0 ? origin.x : origin.x + size.width); }
    
    float getMinY() const { return (size.height < 0 ? origin.y+size.height : origin.y); }
    
    float getMidY() const { return origin.y + size.height / 2.0f; }
    
    float getMaxY() const { return (size.height < 0 ?  origin.y : origin.y + size.height); }
 
    float isDegenerate() const { return size.width <= 0 || size.height <= 0; }
 
 
#pragma mark -
#pragma mark Comparisons
 
    bool operator==(const Rect& rect) const {
        return origin == rect.origin && size == rect.size;
    }
    
    bool operator!=(const Rect& rect) const {
        return origin != rect.origin || size != rect.size;
    }
 
    bool equals(const Rect& rect, float variance=CU_MATH_EPSILON) const {
        return origin.equals(rect.origin,variance) && size.equals(rect.size,variance);
    }
    
    bool operator<=(const Rect& rect) const {
        return inside(rect);
    }
    
    bool operator<(const Rect& rect) const;
    
    bool operator>=(const Rect& rect) const {
        return contains(rect);
    }
 
    bool operator>(const Rect& rect) const;
    
    bool inside(const Rect& rect) const;
    
    bool contains(const Rect& rect) const;
 
    bool touches(const Vec2& point) const;
    
    bool contains(const Vec2& point) const;
    
    bool contains(const Vec2& center, float radius) const;
    
    bool doesIntersect(const Rect& rect) const;
 
    bool doesIntersect(const Vec2& center, float radius) const;
 
    
#pragma mark -
#pragma mark Rectangle Arithmetic
 
    Rect& merge(const Rect & rect);
 
    Rect& intersect(const Rect & rect);
 
    Rect& expand(float factor);
    
    Rect& expand(const Vec2& point);
    
    Rect getMerge(const Rect & rect) const {
        Rect result(*this);
        return result.merge(rect);
    }
    
    Rect getIntersection(const Rect & rect) const {
        Rect result(*this);
        return result.intersect(rect);
    }
    
    Rect getExpansion(float factor) const {
        Rect result(*this);
        return result.expand(factor);
    }
    
    Rect getExpansion(const Vec2& point) const {
        Rect result(*this);
        return result.expand(point);
    }
 
 
 
};
 
}
 
#endif /* __CU_RECT_H__ */