Plane.h

Go to the documentation of this file.

#ifndef G3D_Plane_h
#define G3D_Plane_h

#include "G3D/platform.h"
#include "G3D/Vector3.h"
#include "G3D/Vector4.h"
#include "G3D/debugAssert.h"

namespace G3D {

class Plane {
private:

 Vector3 _normal;
 float _distance;

 Plane(const Vector3& n, float d) : _normal(n), _distance(d) {
 }

public:

 Plane() : _normal(Vector3::unitY()), _distance(0) {
 }

 explicit Plane(const class Any& a);

 Any toAny() const;

 Plane
 (const Point3& point0,
 const Point3& point1,
 const Point3& point2);

 Plane(
 Vector4 point0,
 Vector4 point1,
 Vector4 point2);

 Plane
 (const Vector3& normal,
 const Point3& point);

 static Plane fromEquation(float a, float b, float c, float d);

 Plane(class BinaryInput& b);

 void serialize(class BinaryOutput& b) const;
 void deserialize(class BinaryInput& b);
 
 virtual ~Plane() {}

 inline bool halfSpaceContains(Point3 point) const {
 // Clamp to a finite range for testing
 point = point.clamp(Vector3::minFinite(), Vector3::maxFinite());

 // We can get away with putting values *at* the limits of the float32 range into
 // a dot product, since the dot product is carried out on float64.
 return _normal.dot(point) >= _distance;
 }

 inline bool halfSpaceContains(const Vector4& point) const {
 if (point.w == 0) {
 return _normal.dot(point.xyz()) > 0;
 } else {
 return halfSpaceContains(point.xyz() / point.w);
 }
 }

 inline bool halfSpaceContainsFinite(const Point3& point) const {
 debugAssert(point.isFinite());
 return _normal.dot(point) >= _distance;
 }

 inline bool fuzzyContains(const Point3& point) const {
 return fuzzyEq(point.dot(_normal), _distance);
 }

 inline const Vector3& normal() const {
 return _normal;
 }

 inline float distance(const Vector3& x) const {
 return (_normal.dot(x) - _distance);
 }

 inline Point3 closestPoint(const Point3& x) const {
 return x + (_normal * (-distance(x)));
 }

 Vector3 center() const {
 return _normal * _distance;
 }

 void flip();

 void getEquation(Vector3& normal, double& d) const;
 void getEquation(Vector3& normal, float& d) const;

 void getEquation(double& a, double& b, double& c, double& d) const;
 void getEquation(float& a, float& b, float& c, float& d) const;

 std::string toString() const;
};

} // namespace

#endif