vee_bounding_square.h

Go to the documentation of this file.

/* -*- C++ -*- */

/* COPYRIGHT
 *
 * This file is part of the Visual Effects Engine - VEE
 *
 * Read the "VEE-LICENSE" file for the license.
 *
 * Authors & Copyright:   
 *
 * Tommi Ilmonen, Tuukka Heikura, Marko Myllymaa and 
 * Janne Kontkanen 2001-2004
 *
 * Additional copyrights: Tekes 2003-2004
 *
 * firstname.lastname@hut.fi
 *
 */

#ifndef VEE_BOUNDING_SQUARE_H
#define VEE_BOUNDING_SQUARE_H

#include <vee_vector2.h>
#include <vee_matrix4.h>

class VEE_BoundingSquare
{
public:
  VEE_BoundingSquare() {}
  VEE_BoundingSquare(const VEE_Vector2 * lowHigh) 
    : m_low(*lowHigh), m_high(*lowHigh) {}
  VEE_BoundingSquare(const VEE_Vector2 & low, const VEE_Vector2 & high) 
    : m_low(low), m_high(high) {}
  ~VEE_BoundingSquare() {}

  void scale(float v) { m_low = m_low * v; m_high = m_high * v; }
  inline void scale(const VEE_Vector2 &v);
  void move(const VEE_Vector2 &v) { m_low += v; m_high += v; }

  void clear() { m_low = m_high = VEE_Vector2ZERO; }
  void clear(const VEE_Vector2 &v) { m_low = m_high = v; }

  inline void expand(const VEE_Vector2 &v);
  inline void expand(const VEE_Vector2 &v, float radius);
  inline void expand(const VEE_BoundingSquare &b);

  VEE_Vector2 & low() { return m_low; }
  const VEE_Vector2 & low() const { return m_low; }
  VEE_Vector2 & high() { return m_high; }
  const VEE_Vector2 & high() const { return m_high; }

  void set(float lx, float ly, float hx, float hy)
  { m_low.make(lx, ly); m_high.make(hx, hy); }

  void set(const VEE_Vector2 &low, const VEE_Vector2 &high)
  { m_low = low; m_high = high; }

  void set(const VEE_Vector2 &point)
  { m_low = m_high = point; }

  void set(const VEE_Vector2 &point, float radius)
  { m_low = point - radius; m_high = point + radius; }
  
  inline VEE_Vector2 center() const { return (m_low + m_high) * 0.5; }
  inline VEE_Vector2 span() const { return m_high - m_low; }
  inline VEE_Vector2 topCenter() const;

  inline bool intersects(const VEE_BoundingSquare &) const;
  inline bool contains(const VEE_Vector2 &) const;
  inline bool contains(const VEE_BoundingSquare &b) const;
  
  inline VEE_Vector2 clamp(const VEE_Vector2 &) const;
  
protected:
  VEE_Vector2 m_low, m_high;
};

inline void VEE_BoundingSquare::expand(const VEE_Vector2 &v)
{
  if(v[0] < m_low[0]) m_low[0] = v[0];
  if(v[1] < m_low[1]) m_low[1] = v[1];

  if(v[0] > m_high[0]) m_high[0] = v[0];
  if(v[1] > m_high[1]) m_high[1] = v[1];
}

inline void VEE_BoundingSquare::expand(const VEE_Vector2 &v, float radius)
{
  expand(v - VEE_Vector2(radius, radius));
  expand(v + VEE_Vector2(radius, radius));
}

inline void VEE_BoundingSquare::expand(const VEE_BoundingSquare &b)
{
  if(b.m_low[0] < m_low[0]) m_low[0] = b.m_low[0];
  if(b.m_low[1] < m_low[1]) m_low[1] = b.m_low[1];

  if(b.m_high[0] > m_high[0]) m_high[0] = b.m_high[0];
  if(b.m_high[1] > m_high[1]) m_high[1] = b.m_high[1];
}

void VEE_BoundingSquare::scale(const VEE_Vector2 &v)
{
  m_low[0] *= v[0];
  m_low[1] *= v[1];

  m_high[0] *= v[0];
  m_high[1] *= v[1];
}

VEE_Vector2 VEE_BoundingSquare::topCenter() const
{ 
  return VEE_Vector2((m_low.x + m_high.x) * 0.5, m_high.y);
}

bool VEE_BoundingSquare::intersects(const VEE_BoundingSquare &b) const
{
  for(int i=0; i < 2; i++) {
    if(b.m_high[i] < m_low[i] || b.m_low[i] > m_high[i])
      return false;
  }

  return true;
}

inline bool VEE_BoundingSquare::contains(const VEE_Vector2 &v) const
{
  return ((v[0] >= m_low[0]) && (v[0] <= m_high[0]) &&
    (v[1] >= m_low[1]) && (v[1] <= m_high[1]));  
}

inline bool VEE_BoundingSquare::contains(const VEE_BoundingSquare &b) const
{
  return ((b.m_low[0] >= m_low[0]) && (b.m_high[0] <= m_high[0]) &&
    (b.m_low[1] >= m_low[1]) && (b.m_high[1] <= m_high[1]));
}

inline VEE_Vector2 VEE_BoundingSquare::clamp(const VEE_Vector2 &v) const
{
  int i;
  VEE_Vector2 r(v);

  for(i=0; i < 2; i++)
    if(r[i] < m_low[i]) r[i] = m_low[i];

  for(i=0; i < 2; i++)
    if(r[i] > m_high[i]) r[i] = m_high[i];

  return r;
}

template <class M>
inline VEE_BoundingSquare operator * (const M &m, const VEE_BoundingSquare &b)
{
  VEE_Vector2 tmp, low = b.low(), high = b.high();

  VEE_BoundingSquare square;
  square.set(m * low);
  
  for(uint x = 0; x < 2; x++) {
    for(uint y = 0; y < 2; y++) {
      tmp.x = x ? low.x : high.x;
      tmp.y = y ? low.y : high.y;

      square.expand(m * tmp);
    }
  }

  return square;
}

#endif

---