Surface2.h

Go to the documentation of this file.

/*************************************************************************
> File Name: Surface2.h
> Project Name: CubbyFlow
> Author: Chan-Ho Chris Ohk
> Purpose: Abstract base class for 2-D surface.
> Created Time: 2017/03/20
> Copyright (c) 2018, Chan-Ho Chris Ohk
*************************************************************************/
#ifndef CUBBYFLOW_SURFACE2_H
#define CUBBYFLOW_SURFACE2_H

#include <Core/BoundingBox/BoundingBox2.h>
#include <Core/Ray/Ray2.h>
#include <Core/Transform/Transform2.h>
#include <Core/Vector/Vector2.h>

#include <limits>
#include <memory>

namespace CubbyFlow
{
    struct SurfaceRayIntersection2
    {
        bool isIntersecting = false;
        double distance = std::numeric_limits<double>::max();
        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();

    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;
    };

    using Surface2Ptr = std::shared_ptr<Surface2>;

    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 m_isNormalFlipped = false;
        Transform2 m_transform;
    };

    template <typename T>
    T& SurfaceBuilderBase2<T>::WithIsNormalFlipped(bool isNormalFlipped)
    {
        m_isNormalFlipped = isNormalFlipped;
        return static_cast<T&>(*this);
    }

    template <typename T>
    T& SurfaceBuilderBase2<T>::WithTranslation(const Vector2D& translation)
    {
        m_transform.SetTranslation(translation);
        return static_cast<T&>(*this);
    }

    template <typename T>
    T& SurfaceBuilderBase2<T>::WithOrientation(double orientation)
    {
        m_transform.SetOrientation(orientation);
        return static_cast<T&>(*this);
    }

    template <typename T>
    T& SurfaceBuilderBase2<T>::WithTransform(const Transform2& transform)
    {
        m_transform = transform;
        return static_cast<T&>(*this);
    }
}

#endif