Initial commit

Gems/ScriptCanvasPhysics/Code/CMakeLists.txt

@@ -0,0 +1,66 @@
+#
+# All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+# its licensors.
+#
+# For complete copyright and license terms please see the LICENSE at the root of this
+# distribution (the "License"). All use of this software is governed by the License,
+# or, if provided, by the license below or the license accompanying this file. Do not
+# remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#
+
+ly_add_target(
+    NAME ScriptCanvasPhysics.Static STATIC
+    NAMESPACE Gem
+    OUTPUT_NAME Gem.ScriptCanvasPhysics.Static
+    FILES_CMAKE
+        scriptcanvas_physics_files.cmake
+    INCLUDE_DIRECTORIES
+        PRIVATE
+            Source
+    BUILD_DEPENDENCIES
+        PUBLIC
+            Gem::ScriptCanvas
+        PRIVATE
+            Legacy::CryCommon
+)
+
+ly_add_target(
+    NAME ScriptCanvasPhysics ${PAL_TRAIT_MONOLITHIC_DRIVEN_MODULE_TYPE}
+    NAMESPACE Gem
+    OUTPUT_NAME Gem.ScriptCanvasPhysics.1c27519a4dda4ffaaeebf91514e5b1e8.v0.1.0
+    FILES_CMAKE
+        scriptcanvas_physics_shared_files.cmake
+    INCLUDE_DIRECTORIES
+        PRIVATE
+            Source
+    BUILD_DEPENDENCIES
+        PRIVATE
+            Legacy::CryCommon
+            Gem::ScriptCanvasPhysics.Static
+)
+
+################################################################################
+# Tests
+################################################################################
+if(PAL_TRAIT_BUILD_TESTS_SUPPORTED)
+    ly_add_target(
+        NAME ScriptCanvasPhysics.Tests ${PAL_TRAIT_TEST_TARGET_TYPE}
+        NAMESPACE Gem
+        FILES_CMAKE
+            scriptcanvas_physics_tests_files.cmake
+        INCLUDE_DIRECTORIES
+            PRIVATE
+                Source
+                Tests
+        BUILD_DEPENDENCIES
+            PRIVATE
+                AZ::AzFramework
+                AZ::AzTest
+                Legacy::CryCommon
+                Gem::ScriptCanvasPhysics.Static
+    )
+    ly_add_googletest(
+        NAME Gem::ScriptCanvasPhysics.Tests
+    )
+endif()

Gems/ScriptCanvasPhysics/Code/Source/PhysicsNodeLibrary.cpp

@@ -0,0 +1,58 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#include "ScriptCanvasPhysics_precompiled.h"
+
+#include "PhysicsNodeLibrary.h"
+#include "WorldNodes.h"
+
+#include <AzCore/Serialization/EditContext.h>
+#include <ScriptCanvas/Libraries/Libraries.h>
+
+namespace ScriptCanvasPhysics
+{
+    void PhysicsNodeLibrary::Reflect(AZ::ReflectContext* reflection)
+    {
+        AZ::SerializeContext* serializeContext = azrtti_cast<AZ::SerializeContext*>(reflection);
+        if (serializeContext)
+        {
+            serializeContext->Class<PhysicsNodeLibrary, LibraryDefinition>()
+                ->Version(0)
+            ;
+
+            AZ::EditContext* editContext = serializeContext->GetEditContext();
+            if (editContext)
+            {
+                editContext->Class<PhysicsNodeLibrary>("Physics", "")
+                    ->ClassElement(AZ::Edit::ClassElements::EditorData, "")
+                    ->Attribute(AZ::Script::Attributes::Category, "Physics")
+                    ->Attribute(AZ::Edit::Attributes::AutoExpand, true)
+                    ->Attribute(AZ::Edit::Attributes::Visibility, AZ::Edit::PropertyVisibility::ShowChildrenOnly)
+                ;
+            }
+        }
+    }
+
+    void PhysicsNodeLibrary::InitNodeRegistry(ScriptCanvas::NodeRegistry& nodeRegistry)
+    {
+        WorldNodes::Registrar::AddToRegistry<PhysicsNodeLibrary>(nodeRegistry);
+    }
+
+    AZStd::vector<AZ::ComponentDescriptor*> PhysicsNodeLibrary::GetComponentDescriptors()
+    {
+        AZStd::vector<AZ::ComponentDescriptor*> descriptors;
+
+        WorldNodes::Registrar::AddDescriptors(descriptors);
+
+        return descriptors;
+    }
+} // namespace ScriptCanvasPhysics

Gems/ScriptCanvasPhysics/Code/Source/PhysicsNodeLibrary.h

@@ -0,0 +1,34 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+#pragma once
+
+
+#include <ScriptCanvas/Libraries/Libraries.h>
+
+namespace AZ
+{
+    class ReflectContext;
+    class ComponentDescriptor;
+} // namespace AZ
+
+namespace ScriptCanvasPhysics
+{
+    //! Defines the Library for custom Script Canvas nodes needed for physics features. 
+    struct PhysicsNodeLibrary : public ScriptCanvas::Library::LibraryDefinition
+    {
+        AZ_RTTI(PhysicsNodeLibrary, "{FB17C991-5150-4E1D-8ECE-DE5C3E08ACB5}", ScriptCanvas::Library::LibraryDefinition);
+
+        static void Reflect(AZ::ReflectContext*);
+        static void InitNodeRegistry(ScriptCanvas::NodeRegistry& nodeRegistry);
+        static AZStd::vector<AZ::ComponentDescriptor*> GetComponentDescriptors();
+    };
+} // namespace ScriptCanvasPhysics

Gems/ScriptCanvasPhysics/Code/Source/ScriptCanvasPhysicsModule.cpp

@@ -0,0 +1,58 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#include "ScriptCanvasPhysics_precompiled.h"
+
+#include <AzCore/Memory/SystemAllocator.h>
+
+#include "ScriptCanvasPhysicsSystemComponent.h"
+#include "PhysicsNodeLibrary.h"
+
+#include <AzCore/Module/Module.h>
+
+namespace ScriptCanvasPhysics
+{
+    class ScriptCanvasPhysicsModule
+        : public AZ::Module
+    {
+    public:
+        AZ_RTTI(ScriptCanvasPhysicsModule, "{6B4D5464-DAA5-439D-A0D9-22311608C610}", AZ::Module);
+        AZ_CLASS_ALLOCATOR(ScriptCanvasPhysicsModule, AZ::SystemAllocator, 0);
+
+        ScriptCanvasPhysicsModule()
+            : AZ::Module()
+        {
+            // Push results of [MyComponent]::CreateDescriptor() into m_descriptors here.
+            m_descriptors.insert(m_descriptors.end(), {
+                    ScriptCanvasPhysicsSystemComponent::CreateDescriptor(),
+                });
+
+            AZStd::vector<AZ::ComponentDescriptor*> componentDescriptors(PhysicsNodeLibrary::GetComponentDescriptors());
+            m_descriptors.insert(m_descriptors.end(), componentDescriptors.begin(), componentDescriptors.end());
+        }
+
+        /**
+         * Add required SystemComponents to the SystemEntity.
+         */
+        AZ::ComponentTypeList GetRequiredSystemComponents() const override
+        {
+            return AZ::ComponentTypeList{
+                       azrtti_typeid<ScriptCanvasPhysicsSystemComponent>(),
+            };
+        }
+    };
+}
+
+// DO NOT MODIFY THIS LINE UNLESS YOU RENAME THE GEM
+// The first parameter should be GemName_GemIdLower
+// The second should be the fully qualified name of the class above
+AZ_DECLARE_MODULE_CLASS(Gem_ScriptCanvasPhysics, ScriptCanvasPhysics::ScriptCanvasPhysicsModule)

Gems/ScriptCanvasPhysics/Code/Source/ScriptCanvasPhysicsSystemComponent.cpp

@@ -0,0 +1,78 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#include "ScriptCanvasPhysics_precompiled.h"
+
+#include <AzCore/Serialization/SerializeContext.h>
+#include <AzCore/Serialization/EditContext.h>
+#include <AzCore/RTTI/BehaviorContext.h>
+
+#include "ScriptCanvasPhysicsSystemComponent.h"
+#include "PhysicsNodeLibrary.h"
+
+namespace ScriptCanvasPhysics
+{
+    void ScriptCanvasPhysicsSystemComponent::Reflect(AZ::ReflectContext* context)
+    {
+        if (AZ::SerializeContext* serialize = azrtti_cast<AZ::SerializeContext*>(context))
+        {
+            serialize->Class<ScriptCanvasPhysicsSystemComponent, AZ::Component>()
+                ->Version(0);
+
+            if (AZ::EditContext* ec = serialize->GetEditContext())
+            {
+                ec->Class<ScriptCanvasPhysicsSystemComponent>("ScriptCanvasPhysics", "Exposes legacy physics features to scripting through the Behavior Context to Lua and Script Canvas.")
+                    ->ClassElement(AZ::Edit::ClassElements::EditorData, "")
+                    ->Attribute(AZ::Edit::Attributes::AppearsInAddComponentMenu, AZ_CRC("System", 0xc94d118b))
+                    ->Attribute(AZ::Script::Attributes::Category, "Physics")
+                    ->Attribute(AZ::Edit::Attributes::AutoExpand, true)
+                    ->Attribute(AZ::Edit::Attributes::Visibility, AZ::Edit::PropertyVisibility::ShowChildrenOnly)
+                ;
+            }
+        }
+
+        PhysicsNodeLibrary::Reflect(context);
+    }
+
+    void ScriptCanvasPhysicsSystemComponent::GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& provided)
+    {
+        provided.push_back(AZ_CRC("ScriptCanvasPhysicsService", 0x4686eefd));
+    }
+
+    void ScriptCanvasPhysicsSystemComponent::GetIncompatibleServices(AZ::ComponentDescriptor::DependencyArrayType& incompatible)
+    {
+        incompatible.push_back(AZ_CRC("ScriptCanvasPhysicsService", 0x4686eefd));
+    }
+
+    void ScriptCanvasPhysicsSystemComponent::GetRequiredServices(AZ::ComponentDescriptor::DependencyArrayType& required)
+    {
+        required.push_back(AZ_CRC("LmbrCentralService", 0xc3a02410));
+    }
+
+    void ScriptCanvasPhysicsSystemComponent::GetDependentServices(AZ::ComponentDescriptor::DependencyArrayType& dependent)
+    {
+        (void)dependent;
+    }
+
+    void ScriptCanvasPhysicsSystemComponent::Init()
+    {
+        PhysicsNodeLibrary::InitNodeRegistry(ScriptCanvas::GetNodeRegistry().Get());
+    }
+
+    void ScriptCanvasPhysicsSystemComponent::Activate()
+    {
+    }
+
+    void ScriptCanvasPhysicsSystemComponent::Deactivate()
+    {
+    }
+}

Gems/ScriptCanvasPhysics/Code/Source/ScriptCanvasPhysicsSystemComponent.h

@@ -0,0 +1,40 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#pragma once
+
+#include <AzCore/Component/Component.h>
+
+namespace ScriptCanvasPhysics
+{
+    class ScriptCanvasPhysicsSystemComponent
+        : public AZ::Component
+    {
+    public:
+        AZ_COMPONENT(ScriptCanvasPhysicsSystemComponent, "{F70E22C3-B940-42F3-B4D9-6A7C5E0F2C4E}");
+
+        static void Reflect(AZ::ReflectContext* context);
+
+        static void GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& provided);
+        static void GetIncompatibleServices(AZ::ComponentDescriptor::DependencyArrayType& incompatible);
+        static void GetRequiredServices(AZ::ComponentDescriptor::DependencyArrayType& required);
+        static void GetDependentServices(AZ::ComponentDescriptor::DependencyArrayType& dependent);
+
+    protected:
+        ////////////////////////////////////////////////////////////////////////
+        // AZ::Component interface implementation
+        void Init() override;
+        void Activate() override;
+        void Deactivate() override;
+        ////////////////////////////////////////////////////////////////////////
+    };
+}

Gems/ScriptCanvasPhysics/Code/Source/ScriptCanvasPhysics_precompiled.cpp

@@ -0,0 +1,13 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#include "ScriptCanvasPhysics_precompiled.h"

Gems/ScriptCanvasPhysics/Code/Source/ScriptCanvasPhysics_precompiled.h

@@ -0,0 +1,15 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#pragma once
+
+#include <platform.h> // Many CryCommon files require that this is included first.

Gems/ScriptCanvasPhysics/Code/Source/WorldNodes.h

@@ -0,0 +1,522 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#pragma once
+
+#include <ScriptCanvas/Core/NodeFunctionGeneric.h>
+#include <ScriptCanvas/Data/Data.h>
+#include <AzFramework/Physics/World.h>
+#include <AzFramework/Physics/Material.h>
+#include <AzFramework/Physics/ShapeConfiguration.h>
+#include <AzFramework/Physics/Collision/CollisionGroups.h>
+#include <AzCore/Component/TransformBus.h>
+
+namespace ScriptCanvasPhysics
+{
+    namespace WorldNodes
+    {
+        using Result = AZStd::tuple<
+            bool /*true if an object was hit*/,
+            AZ::Vector3 /*world space position*/,
+            AZ::Vector3 /*surface normal*/,
+            float /*distance to the hit*/,
+            AZ::EntityId /*entity hit, if any*/,
+            AZ::Crc32 /*tag of material surface hit, if any*/
+        >;
+
+        using OverlapResult = AZStd::tuple<
+            bool, /*true if the overlap returned hits*/
+            AZStd::vector<AZ::EntityId> /*list of entityIds*/
+        >;
+
+        AZ_INLINE Result RayCastWorldSpaceWithGroup(const AZ::Vector3& start,
+            const AZ::Vector3& direction,
+            float distance,
+            const AZStd::string& collisionGroup,
+            AZ::EntityId ignore)
+        {
+            Physics::RayCastRequest request;
+            request.m_start = start;
+            request.m_direction = direction.GetNormalized();
+            request.m_distance = distance;
+            request.m_filterCallback = [ignore](const Physics::WorldBody* body, [[maybe_unused]] const Physics::Shape* shape)
+            {
+                return body->GetEntityId() != ignore ? Physics::QueryHitType::Block : Physics::QueryHitType::None;
+            };
+
+            if (!collisionGroup.empty())
+            {
+                request.m_collisionGroup = AzPhysics::CollisionGroup(collisionGroup);
+            }
+
+            Physics::RayCastHit hit;
+            Physics::WorldRequestBus::BroadcastResult(hit, &Physics::World::RayCast, request);
+
+            AZ::EntityId id;
+            AZ::Crc32 surfaceType;
+            if (hit.m_body)
+            {
+                id = hit.m_body->GetEntityId();
+            }
+            if (hit.m_material)
+            {
+                surfaceType = hit.m_material->GetSurfaceType();
+            }
+            return AZStd::make_tuple(hit.m_body != nullptr, hit.m_position, hit.m_normal, hit.m_distance, id, surfaceType);
+        }
+        SCRIPT_CANVAS_GENERIC_FUNCTION_NODE(RayCastWorldSpaceWithGroup,
+            "PhysX/World",
+            "{695EE108-68C1-40E3-ADA5-8ED9AB74D054}",
+            "Returns the first entity hit by a ray cast in world space from the start position in the specified direction.",
+            "Start",
+            "Direction",
+            "Distance",
+            "Collision group",
+            "Ignore",
+            "Object hit",
+            "Position",
+            "Normal",
+            "Distance",
+            "EntityId",
+            "Surface");
+
+        AZ_INLINE Result RayCastLocalSpaceWithGroup(const AZ::EntityId& fromEntityId,
+            const AZ::Vector3& direction,
+            float distance,
+            const AZStd::string& collisionGroup,
+            AZ::EntityId ignore)
+        {
+            AZ::Transform worldSpaceTransform = AZ::Transform::CreateIdentity();
+            AZ::TransformBus::EventResult(worldSpaceTransform, fromEntityId, &AZ::TransformInterface::GetWorldTM);
+
+            Physics::RayCastRequest request;
+            request.m_start = worldSpaceTransform.GetTranslation();
+            request.m_direction = worldSpaceTransform.TransformVector(direction.GetNormalized());
+            request.m_distance = distance;
+            request.m_filterCallback = [ignore](const Physics::WorldBody* body, [[maybe_unused]] const Physics::Shape* shape)
+            {
+                return body->GetEntityId() != ignore ? Physics::QueryHitType::Block : Physics::QueryHitType::None;
+            };
+            if (!collisionGroup.empty())
+            {
+                request.m_collisionGroup = AzPhysics::CollisionGroup(collisionGroup);
+            }
+
+            Physics::RayCastHit hit;
+            Physics::WorldRequestBus::BroadcastResult(hit, &Physics::World::RayCast, request);
+
+            AZ::EntityId id;
+            AZ::Crc32 surfaceType;
+            if (hit.m_body)
+            {
+                id = hit.m_body->GetEntityId();
+            }
+            if (hit.m_material)
+            {
+                surfaceType = hit.m_material->GetSurfaceType();
+            }
+            return AZStd::make_tuple(hit.m_body != nullptr, hit.m_position, hit.m_normal, hit.m_distance, id, surfaceType);
+        }
+        SCRIPT_CANVAS_GENERIC_FUNCTION_NODE(RayCastLocalSpaceWithGroup,
+            "PhysX/World",
+            "{938E0C6E-C6A3-4716-9233-941EFA70241A}",
+            "Returns the first entity hit by a ray cast in local space from the source entity in the specified direction.",
+            "Source",
+            "Direction",
+            "Distance",
+            "Collision group",
+            "Ignore",
+            "Object hit",
+            "Position",
+            "Normal",
+            "Distance",
+            "EntityId",
+            "Surface");
+
+        AZ_INLINE AZStd::vector<Physics::RayCastHit> RayCastMultipleLocalSpaceWithGroup(const AZ::EntityId& fromEntityId,
+            const AZ::Vector3& direction,
+            float distance,
+            const AZStd::string& collisionGroup,
+            AZ::EntityId ignore)
+        {
+            AZ::Transform worldSpaceTransform = AZ::Transform::CreateIdentity();
+            AZ::TransformBus::EventResult(worldSpaceTransform, fromEntityId, &AZ::TransformInterface::GetWorldTM);
+
+            Physics::RayCastRequest request;
+            request.m_start = worldSpaceTransform.GetTranslation();
+            request.m_direction = worldSpaceTransform.TransformVector(direction.GetNormalized());
+            request.m_distance = distance;
+            request.m_filterCallback = [ignore](const Physics::WorldBody* body, [[maybe_unused]] const Physics::Shape* shape)
+            {
+                return body->GetEntityId() != ignore ? Physics::QueryHitType::Touch : Physics::QueryHitType::None;
+            };
+            if (!collisionGroup.empty())
+            {
+                request.m_collisionGroup = AzPhysics::CollisionGroup(collisionGroup);
+            }
+
+            AZStd::vector<Physics::RayCastHit> hits;
+            Physics::WorldRequestBus::BroadcastResult(hits, &Physics::World::RayCastMultiple, request);
+            return hits;
+        }
+        SCRIPT_CANVAS_GENERIC_FUNCTION_NODE(RayCastMultipleLocalSpaceWithGroup,
+            "PhysX/World",
+            "{A867FC55-6610-42C2-97E8-C614450CAE92}",
+            "Returns all entities hit by a ray cast in local space from the source entity in the specified direction.",
+            "Source",
+            "Direction",
+            "Distance",
+            "Collision group",
+            "Ignore",
+            "Objects hit");
+
+        OverlapResult OverlapQuery(const AZ::Transform& pose,
+            Physics::ShapeConfiguration& shape,
+            const AZStd::string& collisionGroup,
+            AZ::EntityId ignore)
+        {
+            Physics::OverlapRequest request;
+            request.m_pose = pose;
+            request.m_shapeConfiguration = &shape;
+            request.m_filterCallback = [ignore](const Physics::WorldBody* body, [[maybe_unused]] const Physics::Shape* shape)
+            {
+                return body->GetEntityId() != ignore;
+            };
+
+            if (!collisionGroup.empty())
+            {
+                request.m_collisionGroup = AzPhysics::CollisionGroup(collisionGroup);
+            }
+
+            AZStd::vector<Physics::OverlapHit> overlaps;
+            Physics::WorldRequestBus::BroadcastResult(overlaps, &Physics::World::Overlap, request);
+
+            AZStd::vector<AZ::EntityId> overlapIds;
+            overlapIds.reserve(overlaps.size());
+            AZStd::transform(overlaps.begin(), overlaps.end(), AZStd::back_inserter(overlapIds), [](const Physics::OverlapHit& overlap)
+            {
+                return overlap.m_body->GetEntityId();
+            });
+            return AZStd::make_tuple(!overlapIds.empty(), overlapIds);
+        }
+
+        AZ_INLINE OverlapResult OverlapSphereWithGroup(const AZ::Vector3& position,
+            float radius,
+            const AZStd::string& collisionGroup,
+            AZ::EntityId ignore)
+        {
+            Physics::SphereShapeConfiguration sphere(radius);
+            return OverlapQuery(AZ::Transform::CreateTranslation(position), sphere, collisionGroup, ignore);
+        }
+        SCRIPT_CANVAS_GENERIC_FUNCTION_NODE(OverlapSphereWithGroup,
+            "PhysX/World",
+            "{0A2831AB-E994-4533-8E64-700631994E64}",
+            "Returns the objects overlapping a sphere at a position",
+            "Position",
+            "Radius",
+            "Collision group",
+            "Ignore"
+        );
+
+        AZ_INLINE OverlapResult OverlapBoxWithGroup(const AZ::Transform& pose,
+            const AZ::Vector3& dimensions,
+            const AZStd::string& collisionGroup,
+            AZ::EntityId ignore)
+        {
+            Physics::BoxShapeConfiguration box(dimensions);
+            return OverlapQuery(pose, box, collisionGroup, ignore);
+        }
+        SCRIPT_CANVAS_GENERIC_FUNCTION_NODE(OverlapBoxWithGroup,
+            "PhysX/World",
+            "{1991BA3D-3848-4BF0-B696-C39C42CFE49A}",
+            "Returns the objects overlapping a box at a position",
+            "Pose",
+            "Dimensions",
+            "Collision group",
+            "Ignore"
+        );
+
+        AZ_INLINE OverlapResult OverlapCapsuleWithGroup(const AZ::Transform& pose,
+            float height,
+            float radius,
+            const AZStd::string& collisionGroup,
+            AZ::EntityId ignore)
+        {
+            Physics::CapsuleShapeConfiguration capsule(height, radius);
+            return OverlapQuery(pose, capsule, collisionGroup, ignore);
+        }
+        SCRIPT_CANVAS_GENERIC_FUNCTION_NODE(OverlapCapsuleWithGroup,
+            "PhysX/World",
+            "{1DD49D7A-348A-4CB1-82C0-D93FE01FEFA1}",
+            "Returns the objects overlapping a capsule at a position",
+            "Pose",
+            "Height",
+            "Radius",
+            "Collision group",
+            "Ignore"
+        );
+
+        Result ShapecastQuery(float distance,
+            const AZ::Transform& pose,
+            const AZ::Vector3& direction,
+            Physics::ShapeConfiguration& shape,
+            const AZStd::string& collisionGroup,
+            AZ::EntityId ignore)
+        {
+            Physics::ShapeCastRequest request;
+            request.m_distance = distance;
+            request.m_start = pose;
+            request.m_direction = direction;
+            request.m_shapeConfiguration = &shape;
+            request.m_filterCallback = [ignore](const Physics::WorldBody* body, [[maybe_unused]] const Physics::Shape* shape)
+            {
+                return body->GetEntityId() != ignore ? Physics::QueryHitType::Block : Physics::QueryHitType::None;
+            };
+
+            if (!collisionGroup.empty())
+            {
+                request.m_collisionGroup = AzPhysics::CollisionGroup(collisionGroup);
+            }
+
+            Physics::RayCastHit hit;
+            Physics::WorldRequestBus::BroadcastResult(hit, &Physics::World::ShapeCast, request);
+
+            AZ::EntityId id;
+            AZ::Crc32 surfaceType;
+            if (hit.m_body)
+            {
+                id = hit.m_body->GetEntityId();
+            }
+            if (hit.m_material)
+            {
+                surfaceType = hit.m_material->GetSurfaceType();
+            }
+            return AZStd::make_tuple(hit.m_body != nullptr, hit.m_position, hit.m_normal, hit.m_distance, id, surfaceType);
+        }
+
+        AZ_INLINE Result SphereCastWithGroup(float distance,
+            const AZ::Transform& pose,
+            const AZ::Vector3& direction,
+            float radius,
+            const AZStd::string& collisionGroup,
+            AZ::EntityId ignore)
+        {
+            Physics::SphereShapeConfiguration sphere(radius);
+            return ShapecastQuery(distance, pose, direction, sphere, collisionGroup, ignore);
+        }
+        SCRIPT_CANVAS_GENERIC_FUNCTION_NODE(SphereCastWithGroup,
+            "PhysX/World",
+            "{7A4D8893-51F5-444F-9C77-64D179F9C9BB}", "SphereCast",
+            "Distance", "Pose", "Direction", "Radius", "Collision group", "Ignore", // In Params
+            "Object Hit", "Position", "Normal", "Distance", "EntityId", "Surface" // Out Params
+
+        );
+
+        AZ_INLINE Result BoxCastWithGroup(float distance,
+            const AZ::Transform& pose,
+            const AZ::Vector3& direction,
+            const AZ::Vector3& dimensions,
+            const AZStd::string& collisionGroup,
+            AZ::EntityId ignore)
+        {
+            Physics::BoxShapeConfiguration box(dimensions);
+            return ShapecastQuery(distance, pose, direction, box, collisionGroup, ignore);
+        }
+        SCRIPT_CANVAS_GENERIC_FUNCTION_NODE(BoxCastWithGroup,
+            "PhysX/World",
+            "{E7C2CFE0-3FB9-438B-9A8A-A5D333AB0791}", "BoxCast",
+            "Distance", "Pose", "Direction", "Dimensions", "Collision group", "Ignore", // In Params
+            "Object Hit", "Position", "Normal", "Distance", "EntityId", "Surface" // Out Params
+        );
+
+        AZ_INLINE Result CapsuleCastWithGroup(float distance,
+            const AZ::Transform& pose,
+            const AZ::Vector3& direction,
+            float height,
+            float radius,
+            const AZStd::string& collisionGroup,
+            AZ::EntityId ignore)
+        {
+            Physics::CapsuleShapeConfiguration capsule(height, radius);
+            return ShapecastQuery(distance, pose, direction, capsule, collisionGroup, ignore);
+        }
+        SCRIPT_CANVAS_GENERIC_FUNCTION_NODE(CapsuleCastWithGroup,
+            "PhysX/World",
+            "{938B047C-6282-4510-8AFE-21D58426061D}", "CapsuleCast",
+            "Distance", "Pose", "Direction", "Height", "Radius", "Collision group", "Ignore", // In Params
+            "Object Hit", "Position", "Normal", "Distance", "EntityId", "Surface" // Out Params
+        );
+
+        ///////////////////////////////////////////////////////////////
+        // Deprecated nodes
+
+        using DeprecatedResult = AZStd::tuple<
+            bool /*true if an object was hit*/,
+            AZ::Vector3 /*world space position*/,
+            AZ::Vector3 /*surface normal*/,
+            float /*distance to the hit*/,
+            AZ::EntityId /*entity hit, if any*/
+        >;
+
+        DeprecatedResult DeprecatedResultFunc(bool arg1, const AZ::Vector3& arg2, const AZ::Vector3& arg3, float arg4, AZ::EntityId arg5, AZ::Crc32)
+        {
+            return DeprecatedResult(arg1, arg2, arg3, arg4, arg5);
+        };
+
+        AZ_INLINE DeprecatedResult RayCastWorldSpace(const AZ::Vector3& start, const AZ::Vector3& direction, float distance, AZ::EntityId ignore)
+        {
+            return AZStd::apply(DeprecatedResultFunc, RayCastWorldSpaceWithGroup(start, direction, distance, "", ignore));
+        }
+
+        SCRIPT_CANVAS_GENERIC_FUNCTION_NODE_DEPRECATED(RayCastWorldSpace,
+            "PhysX/World",
+            "{F75EF071-6755-40A3-8D5D-0603964774AE}",
+            "This node is deprecated, use RayCastWorldSpaceWithGroup",
+            "Start",
+            "Direction",
+            "Distance",
+            "Ignore",
+            "Object hit",
+            "Position",
+            "Normal",
+            "Distance",
+            "EntityId");
+
+        AZ_INLINE DeprecatedResult RayCastLocalSpace(const AZ::EntityId& fromEntityId, const AZ::Vector3& direction, float distance, AZ::EntityId ignore)
+        {
+            return AZStd::apply(DeprecatedResultFunc, RayCastLocalSpaceWithGroup(fromEntityId, direction, distance, "", ignore));
+        }
+        SCRIPT_CANVAS_GENERIC_FUNCTION_NODE_DEPRECATED(RayCastLocalSpace,
+            "PhysX/World",
+            "{1D6935AF-8EE9-4636-9F0C-E0485D935800}",
+            "This node is deprecated, use RayCastLocalSpaceWithGroup",
+            "Source",
+            "Direction",
+            "Distance",
+            "Ignore",
+            "Object hit",
+            "Position",
+            "Normal",
+            "Distance",
+            "EntityId");
+
+        AZ_INLINE AZStd::vector<Physics::RayCastHit> RayCastMultipleLocalSpace(const AZ::EntityId& fromEntityId, const AZ::Vector3& direction, float distance, AZ::EntityId ignore)
+        {
+            return RayCastMultipleLocalSpaceWithGroup(fromEntityId, direction, distance, "", ignore);
+        }
+        SCRIPT_CANVAS_GENERIC_FUNCTION_NODE_DEPRECATED(RayCastMultipleLocalSpace,
+            "PhysX/World",
+            "{AB48C54A-0E0D-41F1-B73E-F689B9570446}",
+            "This node is deprecated, use RayCastMultipleLocalSpaceWithGroup",
+            "Source",
+            "Direction",
+            "Distance",
+            "Ignore",
+            "Objects hit");
+
+        AZ_INLINE OverlapResult OverlapSphere(const AZ::Vector3& position, float radius, AZ::EntityId ignore)
+        {
+            return OverlapSphereWithGroup(position, radius, "", ignore);
+        }
+        SCRIPT_CANVAS_GENERIC_FUNCTION_NODE_DEPRECATED(OverlapSphere,
+            "PhysX/World",
+            "{ED1CE1E1-5BF1-46BA-8DFF-78966FFDBF75}",
+            "This node is deprecated, use OverlapSphereWithGroup",
+            "Position",
+            "Radius",
+            "Ignore"
+        );
+
+        AZ_INLINE OverlapResult OverlapBox(const AZ::Transform& pose, const AZ::Vector3& dimensions, AZ::EntityId ignore)
+        {
+            return OverlapBoxWithGroup(pose, dimensions, "", ignore);
+        }
+        SCRIPT_CANVAS_GENERIC_FUNCTION_NODE_DEPRECATED(OverlapBox,
+            "PhysX/World",
+            "{8D60E5FA-6101-4D3B-BC60-28449CC93AC2}",
+            "This node is deprecated, use OverlapBoxWithGroup",
+            "Pose",
+            "Dimensions",
+            "Ignore"
+        );
+
+        AZ_INLINE OverlapResult OverlapCapsule(const AZ::Transform& pose, float height, float radius, AZ::EntityId ignore)
+        {
+            return OverlapCapsuleWithGroup(pose, height, radius, "", ignore);
+        }
+        SCRIPT_CANVAS_GENERIC_FUNCTION_NODE_DEPRECATED(OverlapCapsule,
+            "PhysX/World",
+            "{600D8F16-2F18-4FA3-858B-D7B59484BEF1}",
+            "This node is deprecated, use OverlapCapsuleWithGroup",
+            "Pose",
+            "Height",
+            "Radius",
+            "Ignore"
+        );
+
+        AZ_INLINE DeprecatedResult SphereCast(float distance, const AZ::Transform& pose, const AZ::Vector3& direction, float radius, AZ::EntityId ignore)
+        {
+            return AZStd::apply(DeprecatedResultFunc, SphereCastWithGroup(distance, pose, direction, radius, "", ignore));
+        }
+        SCRIPT_CANVAS_GENERIC_FUNCTION_NODE_DEPRECATED(SphereCast,
+            "PhysX/World",
+            "{0236AC59-190C-4A41-99ED-5AFA3AD6C500}", "This node is deprecated, use SphereCastWithGroup",
+            "Distance", "Pose", "Direction", "Radius", "Ignore", // In Params
+            "Object Hit", "Position", "Normal", "Distance", "EntityId" // Out Params
+        );
+
+        AZ_INLINE DeprecatedResult BoxCast(float distance, const AZ::Transform& pose, const AZ::Vector3& direction, const AZ::Vector3& dimensions, AZ::EntityId ignore)
+        {
+            return AZStd::apply(DeprecatedResultFunc, BoxCastWithGroup(distance, pose, direction, dimensions, "", ignore));
+        }
+        SCRIPT_CANVAS_GENERIC_FUNCTION_NODE_DEPRECATED(BoxCast,
+            "PhysX/World",
+            "{E9DB2310-21FE-4D58-BA13-512CA9BAA305}", "This node is deprecated, use BoxCastWithGroup",
+            "Distance", "Pose", "Direction", "Dimensions", "Ignore", // In Params
+            "Object Hit", "Position", "Normal", "Distance", "EntityId" // Out Params
+        );
+
+        AZ_INLINE DeprecatedResult CapsuleCast(float distance, const AZ::Transform& pose, const AZ::Vector3& direction, float height, float radius, AZ::EntityId ignore)
+        {
+            return AZStd::apply(DeprecatedResultFunc, CapsuleCastWithGroup(distance, pose, direction, height, radius, "", ignore));
+        }
+        SCRIPT_CANVAS_GENERIC_FUNCTION_NODE_DEPRECATED(CapsuleCast,
+            "PhysX/World",
+            "{FC9F0631-4D63-453C-A876-EC87BC4F2A23}", "This node is deprecated, use CapsuleCastWithGroup",
+            "Distance", "Pose", "Direction", "Height", "Radius", "Ignore", // In Params
+            "Object Hit", "Position", "Normal", "Distance", "EntityId" // Out Params
+        );
+
+        ///////////////////////////////////////////////////////////////
+        using Registrar = ScriptCanvas::RegistrarGeneric
+            < 
+            RayCastWorldSpaceNode,
+            RayCastWorldSpaceWithGroupNode,
+            RayCastLocalSpaceNode,
+            RayCastLocalSpaceWithGroupNode,
+            RayCastMultipleLocalSpaceNode,
+            RayCastMultipleLocalSpaceWithGroupNode,
+            OverlapSphereNode,
+            OverlapSphereWithGroupNode,
+            OverlapBoxNode,
+            OverlapBoxWithGroupNode,
+            OverlapCapsuleNode,
+            OverlapCapsuleWithGroupNode,
+            SphereCastNode,
+            SphereCastWithGroupNode,
+            BoxCastNode,
+            BoxCastWithGroupNode,
+            CapsuleCastNode,
+            CapsuleCastWithGroupNode
+            >;
+    }
+}

Gems/ScriptCanvasPhysics/Code/Tests/ScriptCanvasPhysicsTest.cpp

@@ -0,0 +1,357 @@
+/*
+* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+* its licensors.
+*
+* For complete copyright and license terms please see the LICENSE at the root of this
+* distribution (the "License"). All use of this software is governed by the License,
+* or, if provided, by the license below or the license accompanying this file. Do not
+* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+*
+*/
+
+#include "ScriptCanvasPhysics_precompiled.h"
+
+#include <AzTest/GemTestEnvironment.h>
+#include <gmock/gmock.h>
+#include <AzFramework/Physics/Material.h>
+#include <AzFramework/Physics/Shape.h>
+#include <AzFramework/Physics/ShapeConfiguration.h>
+#include <AzFramework/Physics/World.h>
+#include <AzFramework/Components/TransformComponent.h>
+#include <AzFramework/Physics/Collision/CollisionGroups.h>
+#include <AzFramework/Physics/Collision/CollisionLayers.h>
+#include <WorldNodes.h>
+
+namespace ScriptCanvasPhysics
+{
+    namespace WorldNodes
+    {
+        using Result = AZStd::tuple<
+            bool /*true if an object was hit*/,
+            AZ::Vector3 /*world space position*/,
+            AZ::Vector3 /*surface normal*/,
+            float /*distance to the hit*/,
+            AZ::EntityId /*entity hit, if any*/,
+            AZ::Crc32 /*tag of material surface hit, if any*/
+        >;
+
+        using OverlapResult = AZStd::tuple<
+            bool, /*true if the overlap returned hits*/
+            AZStd::vector<AZ::EntityId> /*list of entityIds*/
+        >;
+
+        extern Result RayCastWorldSpaceWithGroup(const AZ::Vector3& start,
+            const AZ::Vector3& direction,
+            float distance,
+            const AZStd::string& collisionGroup,
+            AZ::EntityId ignore);
+
+        extern Result RayCastLocalSpaceWithGroup(const AZ::EntityId& fromEntityId,
+            const AZ::Vector3& direction,
+            float distance,
+            const AZStd::string& collisionGroup,
+            AZ::EntityId ignore);
+
+        extern AZStd::vector<Physics::RayCastHit> RayCastMultipleLocalSpaceWithGroup(const AZ::EntityId& fromEntityId,
+            const AZ::Vector3& direction,
+            float distance,
+            const AZStd::string& collisionGroup,
+            AZ::EntityId ignore);
+
+        extern Result ShapecastQuery(float distance,
+            const AZ::Transform& pose,
+            const AZ::Vector3& direction,
+            Physics::ShapeConfiguration& shape,
+            const AZStd::string& collisionGroup,
+            AZ::EntityId ignore);
+    }
+}
+
+namespace ScriptCanvasPhysicsTests
+{
+    using namespace ::testing;
+
+    class MockWorld
+        : public Physics::WorldRequestBus::Handler
+    {
+    public:
+        MockWorld()
+        {
+            Physics::WorldRequestBus::Handler::BusConnect(Physics::DefaultPhysicsWorldId);
+        }
+        ~MockWorld() override
+        {
+            Physics::WorldRequestBus::Handler::BusDisconnect();
+        }
+
+        MOCK_METHOD1(Update, void(float deltaTime));
+        MOCK_METHOD1(StartSimulation, void(float deltaTime));
+        MOCK_METHOD0(FinishSimulation, void());
+        MOCK_METHOD1(RayCast, Physics::RayCastHit(const Physics::RayCastRequest& request));
+        MOCK_METHOD1(RayCastMultiple, AZStd::vector<Physics::RayCastHit>(const Physics::RayCastRequest& request));
+        MOCK_METHOD1(ShapeCast, Physics::RayCastHit(const Physics::ShapeCastRequest& request));
+        MOCK_METHOD1(ShapeCastMultiple, AZStd::vector<Physics::RayCastHit>(const Physics::ShapeCastRequest& request));
+        MOCK_METHOD1(Overlap, AZStd::vector<Physics::OverlapHit>(const Physics::OverlapRequest& request));
+        MOCK_METHOD2(OverlapUnbounded, void(const Physics::OverlapRequest& request, const Physics::HitCallback<Physics::OverlapHit>& hitCallback));
+        MOCK_METHOD2(RegisterSuppressedCollision, void(const Physics::WorldBody& body0, const Physics::WorldBody& body1));
+        MOCK_METHOD2(UnregisterSuppressedCollision, void(const Physics::WorldBody& body0, const Physics::WorldBody& body1));
+        MOCK_METHOD1(AddBody, void(Physics::WorldBody& body));
+        MOCK_METHOD1(RemoveBody, void(Physics::WorldBody& body));
+        MOCK_METHOD1(SetSimFunc, void(std::function<void(void*)> func));
+        MOCK_METHOD1(SetEventHandler, void(Physics::WorldEventHandler* eventHandler));
+        MOCK_CONST_METHOD0(GetGravity, AZ::Vector3());
+        MOCK_METHOD1(SetGravity, void(const AZ::Vector3& gravity));
+        MOCK_METHOD1(SetMaxDeltaTime, void(float maxDeltaTime));
+        MOCK_METHOD1(SetFixedDeltaTime, void(float fixedDeltaTime));
+        MOCK_METHOD1(DeferDelete, void(AZStd::unique_ptr<Physics::WorldBody> worldBody));
+        MOCK_METHOD1(SetTriggerEventCallback, void(Physics::ITriggerEventCallback* triggerCallback));
+        MOCK_CONST_METHOD0(GetWorldId, AZ::Crc32());
+    };
+
+    class MockWorldBody
+        : public Physics::WorldBody
+    {
+    public:
+        MOCK_CONST_METHOD0(GetEntityId, AZ::EntityId());
+        MOCK_CONST_METHOD0(GetWorld, Physics::World*());
+        MOCK_CONST_METHOD0(GetTransform, AZ::Transform());
+        MOCK_METHOD1(SetTransform, void(const AZ::Transform& transform));
+        MOCK_CONST_METHOD0(GetPosition, AZ::Vector3());
+        MOCK_CONST_METHOD0(GetOrientation, AZ::Quaternion());
+        MOCK_CONST_METHOD0(GetAabb, AZ::Aabb());
+        MOCK_METHOD1(RayCast, Physics::RayCastHit(const Physics::RayCastRequest& request));
+        MOCK_CONST_METHOD0(GetNativeType, AZ::Crc32());
+        MOCK_CONST_METHOD0(GetNativePointer, void*());
+        MOCK_METHOD1(AddToWorld, void(Physics::World&));
+        MOCK_METHOD1(RemoveFromWorld, void(Physics::World&));
+    };
+
+    class MockShape        
+        : public Physics::Shape
+    {
+    public:
+        MOCK_METHOD1(SetMaterial, void(const AZStd::shared_ptr<Physics::Material>& material));
+        MOCK_CONST_METHOD0(GetMaterial, AZStd::shared_ptr<Physics::Material>());
+        MOCK_METHOD1(SetCollisionLayer, void(const AzPhysics::CollisionLayer& layer));
+        MOCK_CONST_METHOD0(GetCollisionLayer, AzPhysics::CollisionLayer());
+        MOCK_METHOD1(SetCollisionGroup, void(const AzPhysics::CollisionGroup& group));
+        MOCK_CONST_METHOD0(GetCollisionGroup, AzPhysics::CollisionGroup());
+        MOCK_METHOD1(SetName, void(const char* name));
+        MOCK_METHOD2(SetLocalPose, void(const AZ::Vector3& offset, const AZ::Quaternion& rotation));
+        MOCK_CONST_METHOD0(GetLocalPose, AZStd::pair<AZ::Vector3, AZ::Quaternion>());
+        MOCK_METHOD0(GetNativePointer, void*());
+        MOCK_CONST_METHOD0(GetTag, AZ::Crc32());
+        MOCK_METHOD1(AttachedToActor, void(void* actor));
+        MOCK_METHOD0(DetachedFromActor, void());
+        MOCK_METHOD2(RayCast, Physics::RayCastHit(const Physics::RayCastRequest& worldSpaceRequest, const AZ::Transform& worldTransform));
+        MOCK_METHOD1(RayCastLocal, Physics::RayCastHit(const Physics::RayCastRequest& localSpaceRequest));
+        MOCK_METHOD3(GetGeometry, void(AZStd::vector<AZ::Vector3>&, AZStd::vector<AZ::u32>&, AZ::Aabb*));
+        MOCK_CONST_METHOD1(GetAabb, AZ::Aabb(const AZ::Transform& worldTransform));
+        MOCK_CONST_METHOD0(GetAabbLocal, AZ::Aabb());
+        MOCK_CONST_METHOD0(GetRestOffset, float());
+        MOCK_METHOD1(SetRestOffset, void(float));
+        MOCK_CONST_METHOD0(GetContactOffset, float());
+        MOCK_METHOD1(SetContactOffset, void(float));
+    };
+
+    class MockPhysicsMaterial        
+        : public Physics::Material
+    {
+    public:
+        MOCK_CONST_METHOD0(GetSurfaceType, AZ::Crc32());
+        MOCK_METHOD1(SetSurfaceType, void(AZ::Crc32));
+        MOCK_CONST_METHOD0(GetSurfaceTypeName, const AZStd::string&());
+        MOCK_CONST_METHOD0(GetDynamicFriction, float());
+        MOCK_METHOD1(SetDynamicFriction, void(float));
+        MOCK_CONST_METHOD0(GetStaticFriction, float());
+        MOCK_METHOD1(SetStaticFriction, void(float));
+        MOCK_CONST_METHOD0(GetRestitution, float());
+        MOCK_METHOD1(SetRestitution, void(float));
+        MOCK_CONST_METHOD0(GetFrictionCombineMode, CombineMode());
+        MOCK_METHOD1(SetFrictionCombineMode, void(CombineMode));
+        MOCK_CONST_METHOD0(GetRestitutionCombineMode, CombineMode());
+        MOCK_METHOD1(SetRestitutionCombineMode, void(CombineMode));
+        MOCK_CONST_METHOD0(GetCryEngineSurfaceId, AZ::u32());
+        MOCK_METHOD0(GetNativePointer, void*());
+        MOCK_CONST_METHOD0(GetDensity, float());
+        MOCK_METHOD1(SetDensity, void(float));
+    };
+
+    class ScriptCanvasPhysicsTestEnvironment
+        : public AZ::Test::GemTestEnvironment
+    {
+        void AddGemsAndComponents() override
+        {
+            AddComponentDescriptors({ AzFramework::TransformComponent::CreateDescriptor() });
+        }
+    };
+
+    class ScriptCanvasPhysicsTest
+        : public ::testing::Test
+    {
+    protected:
+        void SetUp() override
+        {
+            ::testing::Test::SetUp();
+
+            ON_CALL(m_material, GetSurfaceType())
+                .WillByDefault(Return(AZ::Crc32("CustomSurface")));
+
+            m_hit.m_body = &m_worldBody;
+            m_hit.m_position = AZ::Vector3(1.f, 2.f, 3.f);
+            m_hit.m_distance = 2.5f;
+            m_hit.m_normal = AZ::Vector3(-1.f, 3.5f, 0.5f);
+            m_hit.m_shape = &m_shape;
+            m_hit.m_material = &m_material;
+        }
+
+        NiceMock<MockWorldBody> m_worldBody;
+        NiceMock<MockShape> m_shape;
+        NiceMock<MockPhysicsMaterial> m_material;
+        NiceMock<MockWorld> m_worldMock;
+        Physics::RayCastHit m_hit;
+
+        bool ResultIsEqualToHit(const ScriptCanvasPhysics::WorldNodes::Result& result, const Physics::RayCastHit& hit)
+        {
+            return
+                AZStd::get<0>(result) == (hit.m_body != nullptr) &&
+                AZStd::get<1>(result) == hit.m_position &&
+                AZStd::get<2>(result) == hit.m_normal &&
+                AZStd::get<3>(result) == hit.m_distance &&
+                AZStd::get<4>(result) == (hit.m_body ? hit.m_body->GetEntityId() : AZ::EntityId()) &&
+                AZStd::get<5>(result) == (hit.m_material ? hit.m_material->GetSurfaceType() : AZ::Crc32())
+                ;
+        }
+    };
+
+
+    TEST_F(ScriptCanvasPhysicsTest, WorldNodes_RayCastWorldSpaceWithGroup_FT)
+    {
+        ON_CALL(m_worldMock, RayCast(_))
+            .WillByDefault(Return(m_hit));
+
+        // given raycast data
+        const AZ::Vector3 start = AZ::Vector3::CreateZero();
+        const AZ::Vector3 direction = AZ::Vector3(0.f,1.f,0.f);
+        const float distance = 1.f;
+        const AZStd::string collisionGroup = "default";
+        const AZ::EntityId ignoreEntityId;
+
+        // when a raycast is performed
+        auto result = ScriptCanvasPhysics::WorldNodes::RayCastWorldSpaceWithGroup(
+            start,
+            direction,
+            distance,
+            collisionGroup,
+            ignoreEntityId
+        );
+
+        // expect a valid hit is returned
+        EXPECT_TRUE(ResultIsEqualToHit(result, m_hit));
+    }
+
+    TEST_F(ScriptCanvasPhysicsTest, WorldNodes_RayCastLocalSpaceWithGroup_FT)
+    {
+        ON_CALL(m_worldMock, RayCast(_))
+            .WillByDefault(Return(m_hit));
+
+        // given raycast data
+        const AZ::Vector3 start = AZ::Vector3::CreateZero();
+        const AZ::Vector3 direction = AZ::Vector3(0.f,1.f,0.f);
+        const float distance = 1.f;
+        const AZStd::string collisionGroup = "default";
+        const AZ::EntityId ignoreEntityId;
+
+        auto fromEntity = AZStd::make_unique<AZ::Entity>("Entity");
+        fromEntity->CreateComponent<AzFramework::TransformComponent>()->SetWorldTM(AZ::Transform::Identity());
+        fromEntity->Init();
+        fromEntity->Activate();
+
+        // when a raycast is performed
+        auto result = ScriptCanvasPhysics::WorldNodes::RayCastLocalSpaceWithGroup(
+            fromEntity->GetId(),
+            direction,
+            distance,
+            collisionGroup,
+            fromEntity->GetId()
+        );
+
+        // expect a valid hit is returned
+        EXPECT_TRUE(ResultIsEqualToHit(result, m_hit));
+    }
+
+    TEST_F(ScriptCanvasPhysicsTest, WorldNodes_RayCastMultipleLocalSpaceWithGroup_FT)
+    {
+        AZStd::vector<Physics::RayCastHit> hits;
+        hits.push_back(m_hit);
+
+        ON_CALL(m_worldMock, RayCastMultiple(_))
+            .WillByDefault(Return(hits));
+
+        // given raycast data
+        const AZ::Vector3 start = AZ::Vector3::CreateZero();
+        const AZ::Vector3 direction = AZ::Vector3(0.f,1.f,0.f);
+        const float distance = 1.f;
+        const AZStd::string collisionGroup = "default";
+        const AZ::EntityId ignoreEntityId;
+
+        auto fromEntity = AZStd::make_unique<AZ::Entity>("Entity");
+        fromEntity->CreateComponent<AzFramework::TransformComponent>()->SetWorldTM(AZ::Transform::Identity());
+        fromEntity->Init();
+        fromEntity->Activate();
+
+        // when a raycast is performed
+        auto results = ScriptCanvasPhysics::WorldNodes::RayCastMultipleLocalSpaceWithGroup(
+            fromEntity->GetId(),
+            direction,
+            distance,
+            collisionGroup,
+            fromEntity->GetId()
+        );
+
+        // expect valid hits are returned
+        EXPECT_FALSE(results.empty());
+
+        for (auto result : results)
+        {
+            EXPECT_EQ(result.m_body, m_hit.m_body);
+            EXPECT_EQ(result.m_distance, m_hit.m_distance);
+            EXPECT_EQ(result.m_material, m_hit.m_material);
+            EXPECT_EQ(result.m_normal, m_hit.m_normal);
+            EXPECT_EQ(result.m_position, m_hit.m_position);
+            EXPECT_EQ(result.m_shape, m_hit.m_shape);
+        }
+    }
+
+    TEST_F(ScriptCanvasPhysicsTest, WorldNodes_ShapecastQuery_FT)
+    {
+        ON_CALL(m_worldMock, ShapeCast(_))
+            .WillByDefault(Return(m_hit));
+
+        // given shapecast data
+        const AZ::Vector3 start = AZ::Vector3::CreateZero();
+        const AZ::Vector3 direction = AZ::Vector3(0.f,1.f,0.f);
+        const float distance = 1.f;
+        const AZStd::string collisionGroup = "default";
+        const AZ::EntityId ignoreEntityId;
+        const AZ::Transform pose = AZ::Transform::CreateIdentity();
+        Physics::BoxShapeConfiguration boxShapeConfiguration = Physics::BoxShapeConfiguration();
+
+        // when a shapecast is performed
+        auto result = ScriptCanvasPhysics::WorldNodes::ShapecastQuery(
+            distance,
+            pose,
+            direction,
+            boxShapeConfiguration,
+            collisionGroup,
+            ignoreEntityId
+        );
+
+        // expect a valid hit is returned
+        EXPECT_TRUE(ResultIsEqualToHit(result, m_hit));
+    }
+
+}
+
+AZ_UNIT_TEST_HOOK(new ScriptCanvasPhysicsTests::ScriptCanvasPhysicsTestEnvironment);

Gems/ScriptCanvasPhysics/Code/scriptcanvas_physics_files.cmake

@@ -0,0 +1,20 @@
+#
+# All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+# its licensors.
+#
+# For complete copyright and license terms please see the LICENSE at the root of this
+# distribution (the "License"). All use of this software is governed by the License,
+# or, if provided, by the license below or the license accompanying this file. Do not
+# remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#
+
+set(FILES
+    Source/ScriptCanvasPhysics_precompiled.cpp
+    Source/ScriptCanvasPhysics_precompiled.h
+    Source/PhysicsNodeLibrary.cpp
+    Source/PhysicsNodeLibrary.h
+    Source/ScriptCanvasPhysicsSystemComponent.cpp
+    Source/ScriptCanvasPhysicsSystemComponent.h
+    Source/WorldNodes.h
+)

Gems/ScriptCanvasPhysics/Code/scriptcanvas_physics_shared_files.cmake

@@ -0,0 +1,16 @@
+#
+# All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+# its licensors.
+#
+# For complete copyright and license terms please see the LICENSE at the root of this
+# distribution (the "License"). All use of this software is governed by the License,
+# or, if provided, by the license below or the license accompanying this file. Do not
+# remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#
+
+set(FILES
+    Source/ScriptCanvasPhysics_precompiled.cpp
+    Source/ScriptCanvasPhysics_precompiled.h
+    Source/ScriptCanvasPhysicsModule.cpp
+)

Gems/ScriptCanvasPhysics/Code/scriptcanvas_physics_tests_files.cmake

@@ -0,0 +1,14 @@
+#
+# All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+# its licensors.
+#
+# For complete copyright and license terms please see the LICENSE at the root of this
+# distribution (the "License"). All use of this software is governed by the License,
+# or, if provided, by the license below or the license accompanying this file. Do not
+# remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#
+
+set(FILES
+    Tests/ScriptCanvasPhysicsTest.cpp
+)