148 lines
4.8 KiB
C++
148 lines
4.8 KiB
C++
// Filename: boundingVolume.h
|
|
// Created by: drose (01Oct99)
|
|
//
|
|
////////////////////////////////////////////////////////////////////
|
|
|
|
#ifndef BOUNDINGVOLUME_H
|
|
#define BOUNDINGVOLUME_H
|
|
|
|
#include <pandabase.h>
|
|
|
|
#include <typeHandle.h>
|
|
#include <typedReferenceCount.h>
|
|
|
|
class BoundingSphere;
|
|
class BoundingHexahedron;
|
|
class BoundingLine;
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////
|
|
// Class : BoundingVolume
|
|
// Description : This is an abstract class for any volume in any sense
|
|
// which can be said to define the locality of reference
|
|
// of a node in a graph, along with all of its
|
|
// descendants. It is not necessarily a geometric
|
|
// volume (although see GeometricBoundingVolume); this
|
|
// is simply an abstract interface for bounds of any
|
|
// sort.
|
|
////////////////////////////////////////////////////////////////////
|
|
class EXPCL_PANDA BoundingVolume : public TypedReferenceCount {
|
|
public:
|
|
INLINE BoundingVolume();
|
|
virtual BoundingVolume *make_copy() const=0;
|
|
|
|
INLINE bool is_empty() const;
|
|
INLINE bool is_infinite() const;
|
|
|
|
INLINE void set_infinite();
|
|
|
|
INLINE bool extend_by(const BoundingVolume *vol);
|
|
|
|
// It might be nice to make these template member functions so we
|
|
// could have true STL-style first/last iterators, but that's
|
|
// impossible for virtual functions.
|
|
bool around(const BoundingVolume **first,
|
|
const BoundingVolume **last);
|
|
|
|
// The contains() functions return the union of one or more of these
|
|
// bits.
|
|
enum IntersectionFlags {
|
|
// If no bits are set, it is known that there is no intersection.
|
|
IF_no_intersection = 0,
|
|
|
|
// IF_possible is set if there might be an intersection.
|
|
IF_possible = 0x01,
|
|
|
|
// IF_some is set if there is definitely an intersection. In this
|
|
// case, IF_possible will also be set.
|
|
IF_some = 0x02,
|
|
|
|
// IF_all is set if the other bounding volume is known to be
|
|
// completely within this bounding volume: that is, there is no
|
|
// part of the other bounding volume that does not intersect this
|
|
// one. It does *not* indicate the inverse; it is possible that
|
|
// some part of this bounding volume does not intersect the other.
|
|
|
|
// Also, the converse is not implied: if IF_all is not set, you
|
|
// simply don't know whether the other volume is completely
|
|
// contained within this one or not.
|
|
|
|
// When IF_all is set, both IF_possible and IF_some will also be
|
|
// set.
|
|
IF_all = 0x04,
|
|
|
|
// IF_dont_understand is set if the particular volume/volume
|
|
// intersection test has not been implemented.
|
|
IF_dont_understand = 0x08
|
|
};
|
|
|
|
INLINE int contains(const BoundingVolume *vol) const;
|
|
|
|
virtual void output(ostream &out) const=0;
|
|
virtual void write(ostream &out, int indent_level = 0) const;
|
|
|
|
protected:
|
|
enum Flags {
|
|
F_empty = 0x01,
|
|
F_infinite = 0x02
|
|
};
|
|
int _flags;
|
|
|
|
protected:
|
|
// The following functions support double-dispatch of virtual
|
|
// methods, so we can easily extend_by() various types of bounding
|
|
// volumes.
|
|
|
|
// These functions are the first dispatch point.
|
|
virtual bool extend_other(BoundingVolume *other) const=0;
|
|
virtual bool around_other(BoundingVolume *other,
|
|
const BoundingVolume **first,
|
|
const BoundingVolume **last) const=0;
|
|
virtual int contains_other(const BoundingVolume *other) const=0;
|
|
|
|
// These functions are the second dispatch point. They actually do
|
|
// the work.
|
|
virtual bool extend_by_sphere(const BoundingSphere *sphere);
|
|
virtual bool extend_by_hexahedron(const BoundingHexahedron *hexahedron);
|
|
virtual bool extend_by_line(const BoundingLine *line);
|
|
|
|
virtual bool around_spheres(const BoundingVolume **first,
|
|
const BoundingVolume **last);
|
|
virtual bool around_hexahedrons(const BoundingVolume **first,
|
|
const BoundingVolume **last);
|
|
virtual bool around_lines(const BoundingVolume **first,
|
|
const BoundingVolume **last);
|
|
|
|
virtual int contains_sphere(const BoundingSphere *sphere) const;
|
|
virtual int contains_hexahedron(const BoundingHexahedron *hexahedron) const;
|
|
virtual int contains_line(const BoundingLine *line) const;
|
|
|
|
|
|
public:
|
|
static TypeHandle get_class_type() {
|
|
return _type_handle;
|
|
}
|
|
static void init_type() {
|
|
TypedReferenceCount::init_type();
|
|
register_type(_type_handle, "BoundingVolume",
|
|
TypedReferenceCount::get_class_type());
|
|
}
|
|
virtual TypeHandle get_type() const {
|
|
return get_class_type();
|
|
}
|
|
virtual TypeHandle force_init_type() {init_type(); return get_class_type();}
|
|
|
|
private:
|
|
static TypeHandle _type_handle;
|
|
|
|
friend class BoundingSphere;
|
|
friend class BoundingHexahedron;
|
|
friend class BoundingLine;
|
|
};
|
|
|
|
INLINE ostream &operator << (ostream &out, const BoundingVolume &bound);
|
|
|
|
#include "boundingVolume.I"
|
|
|
|
#endif
|