ai_bbox.h

Go to the documentation of this file.

// Copyright 2023 Autodesk, Inc.  All rights reserved.
//
// Use of this software is subject to the terms of the Autodesk license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
 
#pragma once
#include "ai_vector.h"
#include "ai_api.h"
 
#include <limits>
 
struct AtBBox
{
   AtBBox() = default;
 
   AI_DEVICE AtBBox(const AtVector& mn, const AtVector& mx)
   {
      min = mn;
      max = mx;
   }
 
   AI_DEVICE AtBBox(const AtVector& p0, const AtVector& p1, const AtVector& p2)
   {
      min = max = p0;
      min = AiV3Min(min, p1);
      max = AiV3Max(max, p1);
      min = AiV3Min(min, p2);
      max = AiV3Max(max, p2);
   }
 
   static AI_DEVICE AtBBox empty()
   {
      constexpr float bound = std::numeric_limits<float>::infinity();
      return {{bound, bound, bound}, {-bound, -bound, -bound}};
   }
 
   static AI_DEVICE AtBBox infinity()
   {
      constexpr float bound = std::numeric_limits<float>::infinity();
      return {{-bound, -bound, -bound}, {bound, bound, bound}};
   }
 
   AI_DEVICE void addSlack(float slack)
   {
      min -= slack;
      max += slack;
   }
 
   void init()
   {
      const float bound = std::numeric_limits<float>::infinity();
      min = AtVector( bound,  bound,  bound);
      max = AtVector(-bound, -bound, -bound);
   }
 
   void expand(const AtVector& v)
   {
      min = AiV3Min(min, v);
      max = AiV3Max(max, v);
   }
 
   void expand(const AtBBox& b2)
   {
      min = AiV3Min(min, b2.min);
      max = AiV3Max(max, b2.max);
   }
 
   AI_DEVICE bool inside(const AtVector& p) const
   {
      return AiAll(p >= min) && AiAll(p <= max);
   }
 
   float volume() const
   {
      return (max.x - min.x) * (max.y - min.y) * (max.z - min.z);
   }
 
   bool isEmpty() const
   {
      return AiAny(min > max);
   }
 
   float halfArea() const
   {
      const AtVector diag = max - min;
      return diag.x * (diag.y + diag.z) + diag.y * diag.z;
   }
 
   float area() const
   {
      return halfArea() * 2;
   }
 
   AI_DEVICE AtVector center() const
   {
      return (max + min) * 0.5f;
   }
 
   AtVector min, max;
};
 
inline AtBBox AiBBoxUnion(const AtBBox& b1, const AtBBox& b2)
{
   return AtBBox(AiV3Min(b1.min, b2.min),
                 AiV3Max(b1.max, b2.max));
}
 
inline AtBBox AiBBoxIntersection(const AtBBox& b1, const AtBBox& b2)
{
   return AtBBox(AiV3Max(b1.min, b2.min),
                 AiV3Min(b1.max, b2.max));
}
 
inline AtBBox AiBBoxLerp(float k, const AtBBox& lo, const AtBBox& hi)
{
   return AtBBox(AiV3Lerp(k, lo.min, hi.min),
                 AiV3Lerp(k, lo.max, hi.max));
}
 
struct AtBBox2
{
   AtBBox2() = default;
 
   constexpr AtBBox2(int min_x, int min_y, int max_x, int max_y) :
      minx(min_x), miny(min_y), maxx(max_x), maxy(max_y) {}
 
   constexpr int AiBBox2Area() const
   {
      return (maxx - minx + 1) * (maxy - miny + 1);
   }
 
   AI_DEVICE constexpr bool operator==(const AtBBox2& bb) const
   {
      return (minx == bb.minx && miny == bb.miny &&
              maxx == bb.maxx && maxy == bb.maxy);
   }
 
   AI_DEVICE constexpr bool operator!=(const AtBBox2& bb) const
   {
      return !(*this == bb);
   }
 
   int minx, miny, maxx, maxy;
};
 
 
static const AtBBox AI_BBOX_ZERO(AI_V3_ZERO, AI_V3_ZERO);
/*\}*/
 
/*\}*/