3esbounds.h

//
// author: Kazys Stepanas
//
#ifndef _3ESBOUNDS_H
#define _3ESBOUNDS_H

#include "3es-core.h"

#include "3esvector3.h"

#include <limits>

namespace tes
{
  template <typename T>
  class Bounds
  {
  public:
    Bounds();

    Bounds(const Bounds<T> &other);

    template <typename Q>
    Bounds(const Bounds<Q> &other);

    Bounds(const Vector3<T> &minExt, const Vector3<T> maxExt);

    const Vector3<T> &minimum() const;
    const Vector3<T> &maximum() const;

    void expand(const Vector3<T> &point);

    void expand(const Bounds<T> &other);

    bool isValid() const;

    bool operator==(const Bounds<T> &other) const;

    bool operator!=(const Bounds<T> &other) const;

    Bounds<T> &operator = (const Bounds<T> &other);

  private:
    Vector3<T> _minimum;  
    Vector3<T> _maximum;  
  };

  template class _3es_coreAPI Bounds<float>;
  template class _3es_coreAPI Bounds<double>;
  typedef Bounds<float> Boundsf;
  typedef Bounds<double> Boundsd;

  template <typename T>
  inline Bounds<T>::Bounds()
    : _minimum( std::numeric_limits<T>::max())
    , _maximum(-std::numeric_limits<T>::max())
  {
  }


  template <typename T>
  inline Bounds<T>::Bounds(const Bounds<T> &other)
  {
    *this = other;
  }


  template <typename T>
  template <typename Q>
  inline Bounds<T>::Bounds(const Bounds<Q> &other)
  {
    _minimum = Vector3<T>(other._minimum);
    _maximum = Vector3<T>(other._maximum);
  }


  template <typename T>
  inline Bounds<T>::Bounds(const Vector3<T> &minExt, const Vector3<T> maxExt)
    : _minimum(minExt)
    , _maximum(maxExt)
  {
  }


  template <typename T>
  inline const Vector3<T> &Bounds<T>::minimum() const
  {
    return _minimum;
  }


  template <typename T>
  inline const Vector3<T> &Bounds<T>::maximum() const
  {
    return _maximum;
  }


  template <typename T>
  inline void Bounds<T>::expand(const Vector3<T> &point)
  {
    _minimum.x = (point.x < _minimum.x) ? point.x : _minimum.x;
    _minimum.y = (point.y < _minimum.y) ? point.y : _minimum.y;
    _minimum.z = (point.z < _minimum.z) ? point.z : _minimum.z;
    _maximum.x = (point.x > _maximum.x) ? point.x : _maximum.x;
    _maximum.y = (point.y > _maximum.y) ? point.y : _maximum.y;
    _maximum.z = (point.z > _maximum.z) ? point.z : _maximum.z;
  }


  template <typename T>
  inline void Bounds<T>::expand(const Bounds<T> &other)
  {
    expand(other.minimum());
    expand(other.maximum());
  }


  template <typename T>
  inline bool Bounds<T>::isValid() const
  {
    return _minimum.x <= _maximum.x && _minimum.y <= _maximum.y && _minimum.z <= _maximum.z;
  }


  template <typename T>
  inline bool Bounds<T>::operator==(const Bounds<T> &other) const
  {
    return _minimum.x == other._minimum.x && _minimum.y == other._minimum.y && _minimum.z == other._minimum.z &&
           _maximum.x == other._maximum.x && _maximum.y == other._maximum.y && _maximum.z == other._maximum.z;
  }


  template <typename T>
  inline bool Bounds<T>::operator!=(const Bounds<T> &other) const
  {
    return !operator==(other);
  }


  template <typename T>
  inline Bounds<T> &Bounds<T>::operator = (const Bounds<T> &other)
  {
    _minimum = other._minimum;
    _maximum = other._maximum;
    return *this;
  }
}


#endif  // _3ESBOUNDS_H