bbox.h

Go to the documentation of this file.

#pragma once
 
//-----------------------------------------------------------------------------
// bbox Header Includes
//-----------------------------------------------------------------------------
#include "bsphere.h"
#include "math_types.h"
#include "plane.h"
#include "transform.hpp"
#include <array>
 
namespace math
{
using namespace glm;
 
struct bbox
{
    bbox();
 
    bbox(const vec3& minimum, const vec3& maximum);
 
    bbox(float xMin, float yMin, float zMin, float xMax, float yMax, float zMax);
 
    plane get_plane(volume_plane::e side) const;
 
    void get_plane_points(volume_plane::e side, vec3 points_out[]) const;
 
    bbox& from_points(const char* point_buffer, unsigned int point_count, unsigned int point_stride, bool reset = true);
 
    bbox& from_sphere(const vec3& center, float radius);
 
    bool intersect(const bbox& bounds) const;
 
    bool intersect(const bbox& bounds, bool& contained) const;
 
    bool intersect(const bbox& bounds, bbox& intersection) const;
 
    bool intersect(const bbox& bounds, const vec3& tolerance) const;
 
    bool intersect(const vec3& origin, const vec3& velocity, float& t, bool restrict_range = true) const;
 
    bool intersect(const vec3& v0, const vec3& v1, const vec3& v2, const bbox& triangle_bounds) const;
 
    bool intersect(const vec3& v0, const vec3& v1, const vec3& v2) const;
 
    bool contains_point(const vec3& point) const;
 
    bool contains_point(const vec3& point, const vec3& tolerance) const;
 
    bool contains_point(const vec3& point, float tolerance) const;
 
    vec3 closest_point(const vec3& source_point) const;
 
    void validate();
 
    void reset();
 
    bbox& mul(const transform& t);
    bbox& mul_no_scale(const transform& t);
 
    static bbox mul(const bbox& bounds, const transform& t);
    static bbox mul_no_scale(const bbox& bounds, const transform& t);
 
    bbox& add_point(const vec3& point);
 
    vec3 get_dimensions() const;
 
    vec3 get_center() const;
 
    vec3 get_extents() const;
 
    void inflate(float amount);
 
    void inflate(const vec3& amount);
 
    bool is_populated() const;
 
    bool is_degenerate() const;
 
    std::array<vec3, 8> get_corners() const;
 
    bbox operator*(float scale) const;
 
    bbox& operator+=(const vec3& shift);
 
    bbox& operator-=(const vec3& shift);
 
    bbox& operator*=(const transform& t);
 
    bbox& operator*=(float scale);
 
    bool operator==(const bbox& bounds) const;
 
    bool operator!=(const bbox& bounds) const;
 
    vec3 min;
 
    vec3 max;
 
    static bbox empty;
};
} // namespace math