o3de/Code/Framework/AzToolsFramework/AzToolsFramework/Picking/ContextBoundAPI.h

/*
 * Copyright (c) Contributors to the Open 3D Engine Project.
 * For complete copyright and license terms please see the LICENSE at the root of this distribution.
 *
 * SPDX-License-Identifier: Apache-2.0 OR MIT
 *
 */

#pragma once

#include <AzCore/EBus/EBus.h>
#include <AzCore/Math/Quaternion.h>
#include <AzCore/Math/Spline.h>
#include <AzCore/Math/Transform.h>
#include <AzCore/Math/Vector3.h>
#include <AzCore/Memory/SystemAllocator.h>
#include <AzCore/RTTI/RTTI.h>
#include <AzCore/std/smart_ptr/make_shared.h>
#include <AzToolsFramework/Picking/BoundInterface.h>
#include <AzToolsFramework/Picking/Manipulators/ManipulatorBounds.h>

namespace AzToolsFramework
{
    namespace Picking
    {
        //! An interface concrete shape types can implement to create specific BoundShapeInterfaces.
        class BoundRequestShapeBase
        {
        public:
            AZ_RTTI(BoundRequestShapeBase, "{60D52E6E-54A6-4236-A397-322FD7607FA3}");

            BoundRequestShapeBase() = default;
            virtual ~BoundRequestShapeBase() = default;

            virtual AZStd::shared_ptr<BoundShapeInterface> MakeShapeInterface(RegisteredBoundId id) const = 0;
        };

        class BoundShapeBox : public BoundRequestShapeBase
        {
        public:
            AZ_RTTI(BoundShapeBox, "{6BF78BC6-5100-41A1-84E1-6F4E552E2FC5}", BoundRequestShapeBase);
            AZ_CLASS_ALLOCATOR(BoundShapeBox, AZ::SystemAllocator, 0);

            AZStd::shared_ptr<BoundShapeInterface> MakeShapeInterface(RegisteredBoundId id) const override
            {
                AZStd::shared_ptr<BoundShapeInterface> box = AZStd::make_shared<ManipulatorBoundBox>(id);
                box->SetShapeData(*this);
                return box;
            }

            AZ::Vector3 m_center;
            AZ::Quaternion m_orientation;
            AZ::Vector3 m_halfExtents;
        };

        class BoundShapeSphere : public BoundRequestShapeBase
        {
        public:
            AZ_RTTI(BoundShapeSphere, "{786168B7-46BB-4C0E-9642-5A7B94BF00FA}", BoundRequestShapeBase);
            AZ_CLASS_ALLOCATOR(BoundShapeSphere, AZ::SystemAllocator, 0);

            AZStd::shared_ptr<BoundShapeInterface> MakeShapeInterface(RegisteredBoundId id) const override
            {
                AZStd::shared_ptr<BoundShapeInterface> sphere = AZStd::make_shared<ManipulatorBoundSphere>(id);
                sphere->SetShapeData(*this);
                return sphere;
            }

            AZ::Vector3 m_center;
            float m_radius;
        };

        class BoundShapeCylinder : public BoundRequestShapeBase
        {
        public:
            AZ_RTTI(BoundShapeCylinder, "{3D9A8328-4371-4EC5-BEC2-783998B19200}", BoundRequestShapeBase);
            AZ_CLASS_ALLOCATOR(BoundShapeCylinder, AZ::SystemAllocator, 0);

            AZStd::shared_ptr<BoundShapeInterface> MakeShapeInterface(RegisteredBoundId id) const override
            {
                AZStd::shared_ptr<BoundShapeInterface> cylinder = AZStd::make_shared<ManipulatorBoundCylinder>(id);
                cylinder->SetShapeData(*this);
                return cylinder;
            }

            AZ::Vector3 m_axis;
            AZ::Vector3 m_base;
            float m_height;
            float m_radius;
        };

        class BoundShapeCone : public BoundRequestShapeBase
        {
        public:
            AZ_RTTI(BoundShapeCone, "{68D67118-EAC9-4384-BE99-2CAB72A0450A}", BoundRequestShapeBase);
            AZ_CLASS_ALLOCATOR(BoundShapeCone, AZ::SystemAllocator, 0);

            AZStd::shared_ptr<BoundShapeInterface> MakeShapeInterface(RegisteredBoundId id) const override
            {
                AZStd::shared_ptr<BoundShapeInterface> cone = AZStd::make_shared<ManipulatorBoundCone>(id);
                cone->SetShapeData(*this);
                return cone;
            }

            AZ::Vector3 m_axis;
            AZ::Vector3 m_base;
            float m_height;
            float m_radius;
        };

        //! The quad shape consists of 4 points in 3D space. Please set them from \ref m_corner1 to \ref m_corner4
        //! in either clock-wise winding or counter clock-wise winding. In another word, \ref m_corner1 and
        //! \ref corner_2 cannot be diagonal corners.
        class BoundShapeQuad : public BoundRequestShapeBase
        {
        public:
            AZ_RTTI(BoundShapeQuad, "{D1F73C4B-3B42-4493-B1D1-38EE59F2C7F3}", BoundRequestShapeBase)
            AZ_CLASS_ALLOCATOR(BoundShapeQuad, AZ::SystemAllocator, 0)

            AZStd::shared_ptr<BoundShapeInterface> MakeShapeInterface(RegisteredBoundId id) const override
            {
                AZStd::shared_ptr<BoundShapeInterface> quad = AZStd::make_shared<ManipulatorBoundQuad>(id);
                quad->SetShapeData(*this);
                return quad;
            }

            AZ::Vector3 m_corner1;
            AZ::Vector3 m_corner2;
            AZ::Vector3 m_corner3;
            AZ::Vector3 m_corner4;
        };

        //! The line segment consists of two points in 3D space defining a line the user can interact with.
        class BoundShapeLineSegment : public BoundRequestShapeBase
        {
        public:
            AZ_RTTI(BoundShapeLineSegment, "{BC5DCB8B-E9F7-41BB-AD93-00D3EAB108D3}", BoundRequestShapeBase)
            AZ_CLASS_ALLOCATOR(BoundShapeLineSegment, AZ::SystemAllocator, 0)

            AZStd::shared_ptr<BoundShapeInterface> MakeShapeInterface(RegisteredBoundId id) const override
            {
                AZStd::shared_ptr<BoundShapeInterface> lineSegment = AZStd::make_shared<ManipulatorBoundLineSegment>(id);
                lineSegment->SetShapeData(*this);
                return lineSegment;
            }

            AZ::Vector3 m_start;
            AZ::Vector3 m_end;
            float m_width;
        };

        //! The torus shape is approximated by a cylinder whose radius is the sum of the torus's major radius
        //! and minor radius and height is twice the torus's minor radius.
        class BoundShapeTorus : public BoundRequestShapeBase
        {
        public:
            AZ_RTTI(BoundShapeTorus, "{2EF456F8-87D4-44CD-9929-FC45981289D4}", BoundRequestShapeBase)
            AZ_CLASS_ALLOCATOR(BoundShapeTorus, AZ::SystemAllocator, 0)

            AZStd::shared_ptr<BoundShapeInterface> MakeShapeInterface(RegisteredBoundId id) const override
            {
                AZStd::shared_ptr<BoundShapeInterface> torus = AZStd::make_shared<ManipulatorBoundTorus>(id);
                torus->SetShapeData(*this);
                return torus;
            }

            AZ::Vector3 m_axis;
            AZ::Vector3 m_center;
            float m_majorRadius;
            float m_minorRadius;
        };

        //! The spline is specified by a number of vertices. A piecewise approximation of the curve
        //! is computed by using a number of linear steps (defined by the granularity of the curve).
        class BoundShapeSpline : public BoundRequestShapeBase
        {
        public:
            AZ_RTTI(BoundShapeSpline, "{65CBF85A-5126-4F2A-AA2E-047367435DEC}", BoundRequestShapeBase)
            AZ_CLASS_ALLOCATOR(BoundShapeSpline, AZ::SystemAllocator, 0)

            AZStd::shared_ptr<BoundShapeInterface> MakeShapeInterface(RegisteredBoundId id) const override
            {
                AZStd::shared_ptr<BoundShapeInterface> spline = AZStd::make_shared<ManipulatorBoundSpline>(id);
                spline->SetShapeData(*this);
                return spline;
            }

            AZStd::weak_ptr<const AZ::Spline> m_spline;
            AZ::Transform m_transform;
            float m_width;
        };

        //! Ray query for intersection against bounds.
        struct RaySelectInfo
        {
            AZ::Vector3 m_origin; //!< Start of ray.
            AZ::Vector3 m_direction; //!< Direction of ray - make sure m_direction is unit length.
            AZStd::vector<AZStd::pair<RegisteredBoundId, float>> m_boundIdsHit; //!< Store the id of the intersected bound
                                                                                //!< and the parameter of the corresponding
                                                                                //!< intersecting point.
        };
    } // namespace Picking
} // namespace AzToolsFramework