surface2.h

Go to the documentation of this file.

// Copyright (c) 2018 Doyub Kim
//
// I am making my contributions/submissions to this project solely in my
// personal capacity and am not conveying any rights to any intellectual
// property of any third parties.
 
#ifndef INCLUDE_JET_SURFACE2_H_
#define INCLUDE_JET_SURFACE2_H_
 
#include <jet/bounding_box2.h>
#include <jet/constants.h>
#include <jet/ray2.h>
#include <jet/transform2.h>
#include <memory>
 
namespace jet {
 
struct SurfaceRayIntersection2 {
    bool isIntersecting = false;
    double distance = kMaxD;
    Vector2D point;
    Vector2D normal;
};
 
class Surface2 {
 public:
    Transform2 transform;
 
    bool isNormalFlipped = false;
 
    Surface2(const Transform2& transform = Transform2(),
             bool isNormalFlipped = false);
 
    Surface2(const Surface2& other);
 
    virtual ~Surface2();
 
    Vector2D closestPoint(const Vector2D& otherPoint) const;
 
    BoundingBox2D boundingBox() const;
 
    bool intersects(const Ray2D& ray) const;
 
    double closestDistance(const Vector2D& otherPoint) const;
 
    SurfaceRayIntersection2 closestIntersection(const Ray2D& ray) const;
 
    Vector2D closestNormal(const Vector2D& otherPoint) const;
 
    virtual void updateQueryEngine();
 
    virtual bool isBounded() const;
 
    virtual bool isValidGeometry() const;
 
    bool isInside(const Vector2D& otherPoint) const;
 
 protected:
    virtual Vector2D closestPointLocal(const Vector2D& otherPoint) const = 0;
 
    virtual BoundingBox2D boundingBoxLocal() const = 0;
 
    virtual SurfaceRayIntersection2 closestIntersectionLocal(
        const Ray2D& ray) const = 0;
 
    virtual Vector2D closestNormalLocal(const Vector2D& otherPoint) const = 0;
 
    virtual bool intersectsLocal(const Ray2D& ray) const;
 
    virtual double closestDistanceLocal(const Vector2D& otherPoint) const;
 
    virtual bool isInsideLocal(const Vector2D& otherPoint) const;
};
 
typedef std::shared_ptr<Surface2> Surface2Ptr;
 
template <typename DerivedBuilder>
class SurfaceBuilderBase2 {
 public:
    DerivedBuilder& withIsNormalFlipped(bool isNormalFlipped);
 
    DerivedBuilder& withTranslation(const Vector2D& translation);
 
    DerivedBuilder& withOrientation(double orientation);
 
    DerivedBuilder& withTransform(const Transform2& transform);
 
 protected:
    bool _isNormalFlipped = false;
    Transform2 _transform;
};
 
template <typename T>
T& SurfaceBuilderBase2<T>::withIsNormalFlipped(bool isNormalFlipped) {
    _isNormalFlipped = isNormalFlipped;
    return static_cast<T&>(*this);
}
 
template <typename T>
T& SurfaceBuilderBase2<T>::withTranslation(const Vector2D& translation) {
    _transform.setTranslation(translation);
    return static_cast<T&>(*this);
}
 
template <typename T>
T& SurfaceBuilderBase2<T>::withOrientation(double orientation) {
    _transform.setOrientation(orientation);
    return static_cast<T&>(*this);
}
 
template <typename T>
T& SurfaceBuilderBase2<T>::withTransform(const Transform2& transform) {
    _transform = transform;
    return static_cast<T&>(*this);
}
 
}  // namespace jet
 
#endif  // INCLUDE_JET_SURFACE2_H_