Surface3.h

Go to the documentation of this file.

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

#include <Core/BoundingBox/BoundingBox3.h>
#include <Core/Ray/Ray3.h>
#include <Core/Transform/Transform3.h>
#include <Core/Vector/Vector3.h>

#include <limits>
#include <memory>

namespace CubbyFlow
{
    struct SurfaceRayIntersection3
    {
        bool isIntersecting = false;
        double distance = std::numeric_limits<double>::max();
        Vector3D point;
        Vector3D normal;
    };

    class Surface3
    {
    public:
        Transform3 transform;

        bool isNormalFlipped = false;

        Surface3(
            const Transform3& transform = Transform3(),
            bool isNormalFlipped = false);

        Surface3(const Surface3& other);

        virtual ~Surface3();

        Vector3D ClosestPoint(const Vector3D& otherPoint) const;

        BoundingBox3D BoundingBox() const;

        bool Intersects(const Ray3D& ray) const;

        double ClosestDistance(const Vector3D& otherPoint) const;

        SurfaceRayIntersection3 ClosestIntersection(const Ray3D& ray) const;

        Vector3D ClosestNormal(const Vector3D& otherPoint) const;

        virtual void UpdateQueryEngine();

    protected:
        virtual Vector3D ClosestPointLocal(const Vector3D& otherPoint) const = 0;

        virtual BoundingBox3D BoundingBoxLocal() const = 0;

        virtual SurfaceRayIntersection3 ClosestIntersectionLocal(const Ray3D& ray) const = 0;

        virtual Vector3D ClosestNormalLocal(const Vector3D& otherPoint) const = 0;

        virtual bool IntersectsLocal(const Ray3D& ray) const;

        virtual double ClosestDistanceLocal(const Vector3D& otherPoint) const;
    };

    using Surface3Ptr = std::shared_ptr<Surface3>;

    template <typename DerivedBuilder>
    class SurfaceBuilderBase3
    {
    public:
        DerivedBuilder& WithIsNormalFlipped(bool isNormalFlipped);

        DerivedBuilder& WithTranslation(const Vector3D& translation);

        DerivedBuilder& WithOrientation(const QuaternionD& orientation);

        DerivedBuilder& WithTransform(const Transform3& transform);

    protected:
        bool m_isNormalFlipped = false;
        Transform3 m_transform;
    };

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

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

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

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

#endif