Re-structure Atom test folders in AutomatedTesting. (#4206)

* move shader asset builder test into test_Atom_MainSuite_Optimized.py, update CMakeLists.txt, and move all imports inside the test class for hydra_ShaderAssetBuilder_RecompilesShaderAsChainOfDependenciesChanges.py

Signed-off-by: jromnoa <jromnoa@amazon.com>

* re-organize the Atom automated test structure to match the new parallel + batched test structures

Signed-off-by: jromnoa <jromnoa@amazon.com>

* fix CMakeLists.txt registrations for test files

Signed-off-by: jromnoa <jromnoa@amazon.com>

AutomatedTesting/Gem/PythonTests/Atom/tests/TestAssets/ShaderAssetBuilder/DependencyValidation.azsl.txt

@@ -0,0 +1,55 @@
+/*
+ * 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
+ *
+ */
+
+ /*
+    This is a dummy shader used to validate detection of "#included files"
+ */
+
+#include <Atom/Features/SrgSemantics.azsli>
+
+#include "Test1Color.azsli"
+#include <Test3Color.azsli>
+
+ShaderResourceGroup DummySrg : SRG_PerDraw
+{
+    float4 m_color;
+}
+
+struct VSInput
+{
+    float3 m_position : POSITION;
+    float4 m_color : COLOR0;
+};
+
+struct VSOutput
+{
+    float4 m_position : SV_Position;
+    float4 m_color : COLOR0;
+};
+
+VSOutput MainVS(VSInput vsInput)
+{
+    VSOutput OUT;
+    OUT.m_position = float4(vsInput.m_position, 1.0);
+    OUT.m_color = vsInput.m_color;
+    return OUT;
+}
+
+struct PSOutput
+{
+    float4 m_color : SV_Target0;
+};
+
+PSOutput MainPS(VSOutput vsOutput)
+{
+    PSOutput OUT;
+
+    OUT.m_color = GetTest1Color(DummySrg::m_color) + GetTest3Color(DummySrg::m_color);
+
+    return OUT;
+}

AutomatedTesting/Gem/PythonTests/Atom/tests/TestAssets/ShaderAssetBuilder/DependencyValidation.shader.txt

@@ -0,0 +1,26 @@
+// This is a dummy shader used to validate detection of "#included files"
+{
+    "Source" : "DependencyValidation.azsl",
+
+    "DepthStencilState" : {
+        "Depth" : { "Enable" : false, "CompareFunc" : "GreaterEqual" }
+    },
+
+    "DrawList" : "forward",
+
+    "ProgramSettings":
+    {
+      "EntryPoints":
+      [
+        {
+          "name": "MainVS",
+          "type": "Vertex"
+        },
+        {
+          "name": "MainPS",
+          "type": "Fragment"
+        }
+      ]
+    }
+
+}

AutomatedTesting/Gem/PythonTests/Atom/tests/TestAssets/ShaderAssetBuilder/Test1Color.azsli.txt

@@ -0,0 +1,18 @@
+/*
+ * 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
+ *
+ */
+
+ /*
+    This is a dummy shader used to validate detection of "#included files"
+ */
+
+#include "Test2Color.azsli"
+
+float4 GetTest1Color(float4 color)
+{
+    return color + GetTest2Color(color);
+}

AutomatedTesting/Gem/PythonTests/Atom/tests/TestAssets/ShaderAssetBuilder/Test2Color.azsli.txt

@@ -0,0 +1,16 @@
+/*
+ * 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
+ *
+ */
+
+ /*
+    This is a dummy shader used to validate detection of "#included files"
+ */
+
+float4 GetTest2Color(float4 color)
+{
+    return color * 0.5;
+}

AutomatedTesting/Gem/PythonTests/Atom/tests/TestAssets/ShaderAssetBuilder/Test3Color.azsli.txt

@@ -0,0 +1,16 @@
+/*
+ * 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
+ *
+ */
+
+ /*
+    This is a dummy shader used to validate detection of "#included files"
+ */
+
+float4 GetTest3Color(float4 color)
+{
+    return color * 0.13;
+}

AutomatedTesting/Gem/PythonTests/Atom/tests/__init__.py

@@ -0,0 +1,6 @@
+"""
+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
+"""

AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_AddedToEntity.py

@@ -0,0 +1,238 @@
+"""
+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
+"""
+
+import os
+import sys
+
+import azlmbr.math as math
+import azlmbr.bus as bus
+import azlmbr.paths
+import azlmbr.asset as asset
+import azlmbr.entity as entity
+import azlmbr.legacy.general as general
+import azlmbr.editor as editor
+import azlmbr.render as render
+
+sys.path.append(os.path.join(azlmbr.paths.devroot, "AutomatedTesting", "Gem", "PythonTests"))
+
+import editor_python_test_tools.hydra_editor_utils as hydra
+from editor_python_test_tools.utils import TestHelper
+
+
+def run():
+    """
+    Summary:
+    The below common tests are done for each of the components.
+    1) Addition of component to the entity
+    2) UNDO/REDO of addition of component
+    3) Enter/Exit game mode
+    4) Hide/Show entity containing component
+    5) Deletion of component
+    6) UNDO/REDO of deletion of component
+    Some additional tests for specific components include
+    1) Assigning value to some properties of each component
+    2) Verifying if the component is activated only when the required components are added
+
+    Expected Result:
+    1) Component can be added to an entity.
+    2) The addition of component can be undone and redone.
+    3) Game mode can be entered/exited without issue.
+    4) Entity with component can be hidden/shown.
+    5) Component can be deleted.
+    6) The deletion of component can be undone and redone.
+    7) Component is activated only when the required components are added
+    8) Values can be assigned to the properties of the component
+
+    :return: None
+    """
+
+    def create_entity_undo_redo_component_addition(component_name):
+        new_entity = hydra.Entity(f"{component_name}")
+        new_entity.create_entity(math.Vector3(512.0, 512.0, 34.0), [component_name])
+        general.log(f"{component_name}_test: Component added to the entity: "
+                    f"{hydra.has_components(new_entity.id, [component_name])}")
+
+        # undo component addition
+        general.undo()
+        TestHelper.wait_for_condition(lambda: not hydra.has_components(new_entity.id, [component_name]), 2.0)
+        general.log(f"{component_name}_test: Component removed after UNDO: "
+                    f"{not hydra.has_components(new_entity.id, [component_name])}")
+
+        # redo component addition
+        general.redo()
+        TestHelper.wait_for_condition(lambda: hydra.has_components(new_entity.id, [component_name]), 2.0)
+        general.log(f"{component_name}_test: Component added after REDO: "
+                    f"{hydra.has_components(new_entity.id, [component_name])}")
+
+        return new_entity
+
+    def verify_enter_exit_game_mode(component_name):
+        general.enter_game_mode()
+        TestHelper.wait_for_condition(lambda: general.is_in_game_mode(), 2.0)
+        general.log(f"{component_name}_test: Entered game mode: {general.is_in_game_mode()}")
+        general.exit_game_mode()
+        TestHelper.wait_for_condition(lambda: not general.is_in_game_mode(), 2.0)
+        general.log(f"{component_name}_test: Exit game mode: {not general.is_in_game_mode()}")
+
+    def verify_hide_unhide_entity(component_name, entity_obj):
+
+        def is_entity_hidden(entity_id):
+            return editor.EditorEntityInfoRequestBus(bus.Event, "IsHidden", entity_id)
+
+        editor.EditorEntityAPIBus(bus.Event, "SetVisibilityState", entity_obj.id, False)
+        general.idle_wait_frames(1)
+        general.log(f"{component_name}_test: Entity is hidden: {is_entity_hidden(entity_obj.id)}")
+        editor.EditorEntityAPIBus(bus.Event, "SetVisibilityState", entity_obj.id, True)
+        general.idle_wait_frames(1)
+        general.log(f"{component_name}_test: Entity is shown: {not is_entity_hidden(entity_obj.id)}")
+
+    def verify_deletion_undo_redo(component_name, entity_obj):
+        editor.ToolsApplicationRequestBus(bus.Broadcast, "DeleteEntityById", entity_obj.id)
+        TestHelper.wait_for_condition(lambda: not hydra.find_entity_by_name(entity_obj.name), 2.0)
+        general.log(f"{component_name}_test: Entity deleted: {not hydra.find_entity_by_name(entity_obj.name)}")
+
+        general.undo()
+        TestHelper.wait_for_condition(lambda: hydra.find_entity_by_name(entity_obj.name) is not None, 2.0)
+        general.log(f"{component_name}_test: UNDO entity deletion works: "
+                    f"{hydra.find_entity_by_name(entity_obj.name) is not None}")
+
+        general.redo()
+        TestHelper.wait_for_condition(lambda: not hydra.find_entity_by_name(entity_obj.name), 2.0)
+        general.log(f"{component_name}_test: REDO entity deletion works: "
+                    f"{not hydra.find_entity_by_name(entity_obj.name)}")
+
+    def verify_required_component_addition(entity_obj, components_to_add, component_name):
+
+        def is_component_enabled(entity_componentid_pair):
+            return editor.EditorComponentAPIBus(bus.Broadcast, "IsComponentEnabled", entity_componentid_pair)
+
+        general.log(
+            f"{component_name}_test: Entity disabled initially: "
+            f"{not is_component_enabled(entity_obj.components[0])}")
+        for component in components_to_add:
+            entity_obj.add_component(component)
+        TestHelper.wait_for_condition(lambda: is_component_enabled(entity_obj.components[0]), 2.0)
+        general.log(
+            f"{component_name}_test: Entity enabled after adding "
+            f"required components: {is_component_enabled(entity_obj.components[0])}"
+        )
+
+    def verify_set_property(entity_obj, path, value):
+        entity_obj.get_set_test(0, path, value)
+
+    # Verify cubemap generation
+    def verify_cubemap_generation(component_name, entity_obj):
+        # Initially Check if the component has Reflection Probe component
+        if not hydra.has_components(entity_obj.id, ["Reflection Probe"]):
+            raise ValueError(f"Given entity {entity_obj.name} has no Reflection Probe component")
+        render.EditorReflectionProbeBus(azlmbr.bus.Event, "BakeReflectionProbe", entity_obj.id)
+
+        def get_value():
+            hydra.get_component_property_value(entity_obj.components[0], "Cubemap|Baked Cubemap Path")
+
+        TestHelper.wait_for_condition(lambda: get_value() != "", 20.0)
+        general.log(f"{component_name}_test: Cubemap is generated: {get_value() != ''}")
+
+    # Wait for Editor idle loop before executing Python hydra scripts.
+    TestHelper.init_idle()
+
+    # Delete all existing entities initially
+    search_filter = azlmbr.entity.SearchFilter()
+    all_entities = entity.SearchBus(azlmbr.bus.Broadcast, "SearchEntities", search_filter)
+    editor.ToolsApplicationRequestBus(bus.Broadcast, "DeleteEntities", all_entities)
+
+    class ComponentTests:
+        """Test launcher for each component."""
+        def __init__(self, component_name, *additional_tests):
+            self.component_name = component_name
+            self.additional_tests = additional_tests
+            self.run_component_tests()
+
+        def run_component_tests(self):
+            # Run common and additional tests
+            entity_obj = create_entity_undo_redo_component_addition(self.component_name)
+
+            # Enter/Exit game mode test
+            verify_enter_exit_game_mode(self.component_name)
+
+            # Any additional tests are executed here
+            for test in self.additional_tests:
+                test(entity_obj)
+
+            # Hide/Unhide entity test
+            verify_hide_unhide_entity(self.component_name, entity_obj)
+
+            # Deletion/Undo/Redo test
+            verify_deletion_undo_redo(self.component_name, entity_obj)
+
+    # DepthOfField Component
+    camera_entity = hydra.Entity("camera_entity")
+    camera_entity.create_entity(math.Vector3(512.0, 512.0, 34.0), ["Camera"])
+    depth_of_field = "DepthOfField"
+    ComponentTests(
+        depth_of_field,
+        lambda entity_obj: verify_required_component_addition(entity_obj, ["PostFX Layer"], depth_of_field),
+        lambda entity_obj: verify_set_property(
+            entity_obj, "Controller|Configuration|Camera Entity", camera_entity.id))
+
+    # Decal Component
+    material_asset_path = os.path.join("AutomatedTesting", "Materials", "basic_grey.material")
+    material_asset = asset.AssetCatalogRequestBus(
+        bus.Broadcast, "GetAssetIdByPath", material_asset_path, math.Uuid(), False)
+    ComponentTests(
+        "Decal (Atom)", lambda entity_obj: verify_set_property(
+            entity_obj, "Controller|Configuration|Material", material_asset))
+
+    # Directional Light Component
+    ComponentTests(
+        "Directional Light",
+        lambda entity_obj: verify_set_property(
+            entity_obj, "Controller|Configuration|Shadow|Camera", camera_entity.id))
+
+    # Exposure Control Component
+    ComponentTests(
+        "Exposure Control", lambda entity_obj: verify_required_component_addition(
+            entity_obj, ["PostFX Layer"], "Exposure Control"))
+
+    # Global Skylight (IBL) Component
+    diffuse_image_path = os.path.join("LightingPresets", "greenwich_park_02_4k_iblskyboxcm.exr.streamingimage")
+    diffuse_image_asset = asset.AssetCatalogRequestBus(
+        bus.Broadcast, "GetAssetIdByPath", diffuse_image_path, math.Uuid(), False)
+    specular_image_path = os.path.join("LightingPresets", "greenwich_park_02_4k_iblskyboxcm.exr.streamingimage")
+    specular_image_asset = asset.AssetCatalogRequestBus(
+        bus.Broadcast, "GetAssetIdByPath", specular_image_path, math.Uuid(), False)
+    ComponentTests(
+        "Global Skylight (IBL)",
+        lambda entity_obj: verify_set_property(
+            entity_obj, "Controller|Configuration|Diffuse Image", diffuse_image_asset),
+        lambda entity_obj: verify_set_property(
+            entity_obj, "Controller|Configuration|Specular Image", specular_image_asset))
+
+    # Physical Sky Component
+    ComponentTests("Physical Sky")
+
+    # PostFX Layer Component
+    ComponentTests("PostFX Layer")
+
+    # PostFX Radius Weight Modifier Component
+    ComponentTests("PostFX Radius Weight Modifier")
+
+    # Light Component
+    ComponentTests("Light")
+
+    # Display Mapper Component
+    ComponentTests("Display Mapper")
+
+    # Reflection Probe Component
+    reflection_probe = "Reflection Probe"
+    ComponentTests(
+        reflection_probe,
+        lambda entity_obj: verify_required_component_addition(entity_obj, ["Box Shape"], reflection_probe),
+        lambda entity_obj: verify_cubemap_generation(reflection_probe, entity_obj),)
+
+if __name__ == "__main__":
+    run()

AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_DecalAdded.py

@@ -0,0 +1,151 @@
+"""
+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
+"""
+
+# fmt: off
+class Tests:
+    camera_creation =           ("Camera Entity successfully created",           "Camera Entity failed to be created")
+    camera_component_added =    ("Camera component was added to entity",         "Camera component failed to be added to entity")
+    camera_component_check =    ("Entity has a Camera component",                "Entity failed to find Camera component")
+    creation_undo =             ("UNDO Entity creation success",                 "UNDO Entity creation failed")
+    creation_redo =             ("REDO Entity creation success",                 "REDO Entity creation failed")
+    decal_creation =            ("Decal Entity successfully created",            "Decal Entity failed to be created")
+    decal_component =           ("Entity has a Decal component",                 "Entity failed to find Decal component")
+    material_property_set =     ("Material property set on Decal component",     "Couldn't set Material property on Decal component")
+    enter_game_mode =           ("Entered game mode",                            "Failed to enter game mode")
+    exit_game_mode =            ("Exited game mode",                             "Couldn't exit game mode")
+    is_visible =                ("Entity is visible",                            "Entity was not visible")
+    is_hidden =                 ("Entity is hidden",                             "Entity was not hidden")
+    entity_deleted =            ("Entity deleted",                               "Entity was not deleted")
+    deletion_undo =             ("UNDO deletion success",                        "UNDO deletion failed")
+    deletion_redo =             ("REDO deletion success",                        "REDO deletion failed")
+    no_error_occurred =         ("No errors detected",                           "Errors were detected")
+# fmt: on
+
+
+def AtomEditorComponents_Decal_AddedToEntity():
+    """
+    Summary:
+    Tests the Decal component can be added to an entity and has the expected functionality.
+
+    Test setup:
+    - Wait for Editor idle loop.
+    - Open the "Base" level.
+
+    Expected Behavior:
+    The component can be added, used in game mode, hidden/shown, deleted, and has accurate required components.
+    Creation and deletion undo/redo should also work.
+
+    Test Steps:
+    1) Create a Decal entity with no components.
+    2) Add Decal component to Decal entity.
+    3) UNDO the entity creation and component addition.
+    4) REDO the entity creation and component addition.
+    5) Enter/Exit game mode.
+    6) Test IsHidden.
+    7) Test IsVisible.
+    8) Set Material property on Decal component.
+    9) Delete Decal entity.
+    10) UNDO deletion.
+    11) REDO deletion.
+    12) Look for errors.
+
+    :return: None
+    """
+    import os
+
+    import azlmbr.asset as asset
+    import azlmbr.bus as bus
+    import azlmbr.legacy.general as general
+    import azlmbr.math as math
+
+    from editor_python_test_tools.editor_entity_utils import EditorEntity
+    from editor_python_test_tools.utils import Report, Tracer, TestHelper as helper
+
+    with Tracer() as error_tracer:
+        # Test setup begins.
+        # Setup: Wait for Editor idle loop before executing Python hydra scripts then open "Base" level.
+        helper.init_idle()
+        helper.open_level("", "Base")
+
+        # Test steps begin.
+        # 1. Create a Decal entity with no components.
+        decal_name = "Decal (Atom)"
+        decal_entity = EditorEntity.create_editor_entity_at(math.Vector3(512.0, 512.0, 34.0), decal_name)
+        Report.critical_result(Tests.decal_creation, decal_entity.exists())
+
+        # 2. Add Decal component to Decal entity.
+        decal_component = decal_entity.add_component(decal_name)
+        Report.critical_result(Tests.decal_component, decal_entity.has_component(decal_name))
+
+        # 3. UNDO the entity creation and component addition.
+        # -> UNDO component addition.
+        general.undo()
+        # -> UNDO naming entity.
+        general.undo()
+        # -> UNDO selecting entity.
+        general.undo()
+        # -> UNDO entity creation.
+        general.undo()
+        general.idle_wait_frames(1)
+        Report.result(Tests.creation_undo, not decal_entity.exists())
+
+        # 4. REDO the entity creation and component addition.
+        # -> REDO entity creation.
+        general.redo()
+        # -> REDO selecting entity.
+        general.redo()
+        # -> REDO naming entity.
+        general.redo()
+        # -> REDO component addition.
+        general.redo()
+        general.idle_wait_frames(1)
+        Report.result(Tests.creation_redo, decal_entity.exists())
+
+        # 5. Enter/Exit game mode.
+        helper.enter_game_mode(Tests.enter_game_mode)
+        general.idle_wait_frames(1)
+        helper.exit_game_mode(Tests.exit_game_mode)
+
+        # 6. Test IsHidden.
+        decal_entity.set_visibility_state(False)
+        Report.result(Tests.is_hidden, decal_entity.is_hidden() is True)
+
+        # 7. Test IsVisible.
+        decal_entity.set_visibility_state(True)
+        general.idle_wait_frames(1)
+        Report.result(Tests.is_visible, decal_entity.is_visible() is True)
+
+        # 8. Set Material property on Decal component.
+        decal_material_property_path = "Controller|Configuration|Material"
+        decal_material_asset_path = os.path.join("AutomatedTesting", "Materials", "basic_grey.material")
+        decal_material_asset = asset.AssetCatalogRequestBus(
+            bus.Broadcast, "GetAssetIdByPath", decal_material_asset_path, math.Uuid(), False)
+        decal_component.set_component_property_value(decal_material_property_path, decal_material_asset)
+        get_material_property = decal_component.get_component_property_value(decal_material_property_path)
+        Report.result(Tests.material_property_set, get_material_property == decal_material_asset)
+
+        # 9. Delete Decal entity.
+        decal_entity.delete()
+        Report.result(Tests.entity_deleted, not decal_entity.exists())
+
+        # 10. UNDO deletion.
+        general.undo()
+        general.idle_wait_frames(1)
+        Report.result(Tests.deletion_undo, decal_entity.exists())
+
+        # 11. REDO deletion.
+        general.redo()
+        Report.result(Tests.deletion_redo, not decal_entity.exists())
+
+        # 12. Look for errors.
+        helper.wait_for_condition(lambda: error_tracer.has_errors, 1.0)
+        Report.result(Tests.no_error_occurred, not error_tracer.has_errors)
+
+
+if __name__ == "__main__":
+    from editor_python_test_tools.utils import Report
+    Report.start_test(AtomEditorComponents_Decal_AddedToEntity)

AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_DepthOfFieldAdded.py

@@ -0,0 +1,173 @@
+"""
+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
+"""
+
+# fmt: off
+class Tests:
+    camera_creation =           ("Camera Entity successfully created",            "Camera Entity failed to be created")
+    camera_component_added =    ("Camera component was added to Camera entity",   "Camera component failed to be added to entity")
+    camera_component_check =    ("Entity has a Camera component",                 "Entity failed to find Camera component")
+    camera_property_set =       ("DepthOfField Entity set Camera Entity",         "DepthOfField Entity could not set Camera Entity")
+    creation_undo =             ("UNDO Entity creation success",                  "UNDO Entity creation failed")
+    creation_redo =             ("REDO Entity creation success",                  "REDO Entity creation failed")
+    depth_of_field_creation =   ("DepthOfField Entity successfully created",      "DepthOfField Entity failed to be created")
+    depth_of_field_component =  ("Entity has a DepthOfField component",           "Entity failed to find DepthOfField component")
+    depth_of_field_disabled =   ("DepthOfField component disabled",               "DepthOfField component was not disabled.")
+    post_fx_component =         ("Entity has a Post FX Layer component",          "Entity did not have a Post FX Layer component")
+    depth_of_field_enabled =    ("DepthOfField component enabled",                "DepthOfField component was not enabled.")
+    enter_game_mode =           ("Entered game mode",                             "Failed to enter game mode")
+    exit_game_mode =            ("Exited game mode",                              "Couldn't exit game mode")
+    is_visible =                ("Entity is visible",                             "Entity was not visible")
+    is_hidden =                 ("Entity is hidden",                              "Entity was not hidden")
+    entity_deleted =            ("Entity deleted",                                "Entity was not deleted")
+    deletion_undo =             ("UNDO deletion success",                         "UNDO deletion failed")
+    deletion_redo =             ("REDO deletion success",                         "REDO deletion failed")
+    no_error_occurred =         ("No errors detected",                            "Errors were detected")
+# fmt: on
+
+
+def AtomEditorComponents_DepthOfField_AddedToEntity():
+    """
+    Summary:
+    Tests the DepthOfField component can be added to an entity and has the expected functionality.
+
+    Test setup:
+    - Wait for Editor idle loop.
+    - Open the "Base" level.
+
+    Expected Behavior:
+    The component can be added, used in game mode, hidden/shown, deleted, and has accurate required components.
+    Creation and deletion undo/redo should also work.
+
+    Test Steps:
+    1) Create a DepthOfField entity with no components.
+    2) Add a DepthOfField component to DepthOfField entity.
+    3) UNDO the entity creation and component addition.
+    4) REDO the entity creation and component addition.
+    5) Verify DepthOfField component not enabled.
+    6) Add Post FX Layer component since it is required by the DepthOfField component.
+    7) Verify DepthOfField component is enabled.
+    8) Enter/Exit game mode.
+    9) Test IsHidden.
+    10) Test IsVisible.
+    11) Add Camera entity.
+    12) Add Camera component to Camera entity.
+    13) Set the DepthOfField components's Camera Entity to the newly created Camera entity.
+    14) Delete DepthOfField entity.
+    15) UNDO deletion.
+    16) REDO deletion.
+    17) Look for errors.
+
+    :return: None
+    """
+
+    import azlmbr.legacy.general as general
+    import azlmbr.math as math
+
+    from editor_python_test_tools.editor_entity_utils import EditorEntity
+    from editor_python_test_tools.utils import Report, Tracer, TestHelper as helper
+
+    with Tracer() as error_tracer:
+        # Test setup begins.
+        # Setup: Wait for Editor idle loop before executing Python hydra scripts then open "Base" level.
+        helper.init_idle()
+        helper.open_level("", "Base")
+
+        # Test steps begin.
+        # 1. Create a DepthOfField entity with no components.
+        depth_of_field_name = "DepthOfField"
+        depth_of_field_entity = EditorEntity.create_editor_entity_at(
+            math.Vector3(512.0, 512.0, 34.0), depth_of_field_name)
+        Report.critical_result(Tests.depth_of_field_creation, depth_of_field_entity.exists())
+
+        # 2. Add a DepthOfField component to DepthOfField entity.
+        depth_of_field_component = depth_of_field_entity.add_component(depth_of_field_name)
+        Report.critical_result(Tests.depth_of_field_component, depth_of_field_entity.has_component(depth_of_field_name))
+
+        # 3. UNDO the entity creation and component addition.
+        # -> UNDO component addition.
+        general.undo()
+        # -> UNDO naming entity.
+        general.undo()
+        # -> UNDO selecting entity.
+        general.undo()
+        # -> UNDO entity creation.
+        general.undo()
+        general.idle_wait_frames(1)
+        Report.result(Tests.creation_undo, not depth_of_field_entity.exists())
+
+        # 4. REDO the entity creation and component addition.
+        # -> REDO entity creation.
+        general.redo()
+        # -> REDO selecting entity.
+        general.redo()
+        # -> REDO naming entity.
+        general.redo()
+        # -> REDO component addition.
+        general.redo()
+        general.idle_wait_frames(1)
+        Report.result(Tests.creation_redo, depth_of_field_entity.exists())
+
+        # 5. Verify DepthOfField component not enabled.
+        Report.result(Tests.depth_of_field_disabled, not depth_of_field_component.is_enabled())
+
+        # 6. Add Post FX Layer component since it is required by the DepthOfField component.
+        post_fx_layer = "PostFX Layer"
+        depth_of_field_entity.add_component(post_fx_layer)
+        Report.result(Tests.post_fx_component, depth_of_field_entity.has_component(post_fx_layer))
+
+        # 7. Verify DepthOfField component is enabled.
+        Report.result(Tests.depth_of_field_enabled, depth_of_field_component.is_enabled())
+
+        # 8. Enter/Exit game mode.
+        helper.enter_game_mode(Tests.enter_game_mode)
+        general.idle_wait_frames(1)
+        helper.exit_game_mode(Tests.exit_game_mode)
+
+        # 9. Test IsHidden.
+        depth_of_field_entity.set_visibility_state(False)
+        Report.result(Tests.is_hidden, depth_of_field_entity.is_hidden() is True)
+
+        # 10. Test IsVisible.
+        depth_of_field_entity.set_visibility_state(True)
+        general.idle_wait_frames(1)
+        Report.result(Tests.is_visible, depth_of_field_entity.is_visible() is True)
+
+        # 11. Add Camera entity.
+        camera_name = "Camera"
+        camera_entity = EditorEntity.create_editor_entity_at(math.Vector3(512.0, 512.0, 34.0), camera_name)
+        Report.result(Tests.camera_creation, camera_entity.exists())
+
+        # 12. Add Camera component to Camera entity.
+        camera_entity.add_component(camera_name)
+        Report.result(Tests.camera_component_added, camera_entity.has_component(camera_name))
+
+        # 13. Set the DepthOfField components's Camera Entity to the newly created Camera entity.
+        depth_of_field_camera_property_path = "Controller|Configuration|Camera Entity"
+        depth_of_field_component.set_component_property_value(depth_of_field_camera_property_path, camera_entity.id)
+        camera_entity_set = depth_of_field_component.get_component_property_value(depth_of_field_camera_property_path)
+        Report.result(Tests.camera_property_set, camera_entity.id == camera_entity_set)
+
+        # 14. Delete DepthOfField entity.
+        depth_of_field_entity.delete()
+        Report.result(Tests.entity_deleted, not depth_of_field_entity.exists())
+
+        # 15. UNDO deletion.
+        general.undo()
+        Report.result(Tests.deletion_undo, depth_of_field_entity.exists())
+
+        # 16. REDO deletion.
+        general.redo()
+        Report.result(Tests.deletion_redo, not depth_of_field_entity.exists())
+
+        # 17. Look for errors.
+        helper.wait_for_condition(lambda: error_tracer.has_errors, 1.0)
+        Report.result(Tests.no_error_occurred, not error_tracer.has_errors)
+
+
+if __name__ == "__main__":
+    from editor_python_test_tools.utils import Report
+    Report.start_test(AtomEditorComponents_DepthOfField_AddedToEntity)

AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_DirectionalLightAdded.py

@@ -0,0 +1,157 @@
+"""
+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
+"""
+
+# fmt: off
+class Tests:
+    camera_creation =              ("Camera Entity successfully created",              "Camera Entity failed to be created")
+    camera_component_added =       ("Camera component was added to entity",            "Camera component failed to be added to entity")
+    camera_component_check =       ("Entity has a Camera component",                   "Entity failed to find Camera component")
+    creation_undo =                ("UNDO Entity creation success",                    "UNDO Entity creation failed")
+    creation_redo =                ("REDO Entity creation success",                    "REDO Entity creation failed")
+    directional_light_creation =   ("Directional Light Entity successfully created",   "Directional Light Entity failed to be created")
+    directional_light_component =  ("Entity has a Directional Light component",        "Entity failed to find Directional Light component")
+    shadow_camera_check =          ("Directional Light component Shadow camera set",   "Directional Light component Shadow camera was not set")
+    enter_game_mode =              ("Entered game mode",                               "Failed to enter game mode")
+    exit_game_mode =               ("Exited game mode",                                "Couldn't exit game mode")
+    is_visible =                   ("Entity is visible",                               "Entity was not visible")
+    is_hidden =                    ("Entity is hidden",                                "Entity was not hidden")
+    entity_deleted =               ("Entity deleted",                                  "Entity was not deleted")
+    deletion_undo =                ("UNDO deletion success",                           "UNDO deletion failed")
+    deletion_redo =                ("REDO deletion success",                           "REDO deletion failed")
+    no_error_occurred =            ("No errors detected",                              "Errors were detected")
+# fmt: on
+
+
+def AtomEditorComponents_DirectionalLight_AddedToEntity():
+    """
+    Summary:
+    Tests the Directional Light component can be added to an entity and has the expected functionality.
+
+    Test setup:
+    - Wait for Editor idle loop.
+    - Open the "Base" level.
+
+    Expected Behavior:
+    The component can be added, used in game mode, hidden/shown, deleted, and has accurate required components.
+    Creation and deletion undo/redo should also work.
+
+    Test Steps:
+    1) Create a Directional Light entity with no components.
+    2) Add Directional Light component to Directional Light entity.
+    3) UNDO the entity creation and component addition.
+    4) REDO the entity creation and component addition.
+    5) Enter/Exit game mode.
+    6) Test IsHidden.
+    7) Test IsVisible.
+    8) Add Camera entity.
+    9) Add Camera component to Camera entity
+    10) Set the Directional Light component property Shadow|Camera to the Camera entity.
+    11) Delete Directional Light entity.
+    12) UNDO deletion.
+    13) REDO deletion.
+    14) Look for errors.
+
+    :return: None
+    """
+
+    import azlmbr.legacy.general as general
+    import azlmbr.math as math
+
+    from editor_python_test_tools.editor_entity_utils import EditorEntity
+    from editor_python_test_tools.utils import Report, Tracer, TestHelper as helper
+
+    with Tracer() as error_tracer:
+        # Test setup begins.
+        # Setup: Wait for Editor idle loop before executing Python hydra scripts then open "Base" level.
+        helper.init_idle()
+        helper.open_level("", "Base")
+
+        # Test steps begin.
+        # 1. Create a Directional Light entity with no components.
+        directional_light_name = "Directional Light"
+        directional_light_entity = EditorEntity.create_editor_entity_at(
+            math.Vector3(512.0, 512.0, 34.0), directional_light_name)
+        Report.critical_result(Tests.directional_light_creation, directional_light_entity.exists())
+
+        # 2. Add Directional Light component to Directional Light entity.
+        directional_light_component = directional_light_entity.add_component(directional_light_name)
+        Report.critical_result(
+            Tests.directional_light_component, directional_light_entity.has_component(directional_light_name))
+
+        # 3. UNDO the entity creation and component addition.
+        # -> UNDO component addition.
+        general.undo()
+        # -> UNDO naming entity.
+        general.undo()
+        # -> UNDO selecting entity.
+        general.undo()
+        # -> UNDO entity creation.
+        general.undo()
+        general.idle_wait_frames(1)
+        Report.result(Tests.creation_undo, not directional_light_entity.exists())
+
+        # 4. REDO the entity creation and component addition.
+        # -> REDO entity creation.
+        general.redo()
+        # -> REDO selecting entity.
+        general.redo()
+        # -> REDO naming entity.
+        general.redo()
+        # -> REDO component addition.
+        general.redo()
+        general.idle_wait_frames(1)
+        Report.result(Tests.creation_redo, directional_light_entity.exists())
+
+        # 5. Enter/Exit game mode.
+        helper.enter_game_mode(Tests.enter_game_mode)
+        general.idle_wait_frames(1)
+        helper.exit_game_mode(Tests.exit_game_mode)
+
+        # 6. Test IsHidden.
+        directional_light_entity.set_visibility_state(False)
+        Report.result(Tests.is_hidden, directional_light_entity.is_hidden() is True)
+
+        # 7. Test IsVisible.
+        directional_light_entity.set_visibility_state(True)
+        general.idle_wait_frames(1)
+        Report.result(Tests.is_visible, directional_light_entity.is_visible() is True)
+
+        # 8. Add Camera entity.
+        camera_name = "Camera"
+        camera_entity = EditorEntity.create_editor_entity_at(math.Vector3(512.0, 512.0, 34.0), camera_name)
+        Report.result(Tests.camera_creation, camera_entity.exists())
+
+        # 9. Add Camera component to Camera entity.
+        camera_entity.add_component(camera_name)
+        Report.result(Tests.camera_component_added, camera_entity.has_component(camera_name))
+
+        # 10. Set the Directional Light component property Shadow|Camera to the Camera entity.
+        shadow_camera_property_path = "Controller|Configuration|Shadow|Camera"
+        directional_light_component.set_component_property_value(shadow_camera_property_path, camera_entity.id)
+        shadow_camera_set = directional_light_component.get_component_property_value(shadow_camera_property_path)
+        Report.result(Tests.shadow_camera_check, camera_entity.id == shadow_camera_set)
+
+        # 11. Delete DirectionalLight entity.
+        directional_light_entity.delete()
+        Report.result(Tests.entity_deleted, not directional_light_entity.exists())
+
+        # 12. UNDO deletion.
+        general.undo()
+        Report.result(Tests.deletion_undo, directional_light_entity.exists())
+
+        # 13. REDO deletion.
+        general.redo()
+        Report.result(Tests.deletion_redo, not directional_light_entity.exists())
+
+        # 14. Look for errors.
+        helper.wait_for_condition(lambda: error_tracer.has_errors, 1.0)
+        Report.result(Tests.no_error_occurred, not error_tracer.has_errors)
+
+
+if __name__ == "__main__":
+    from editor_python_test_tools.utils import Report
+    Report.start_test(AtomEditorComponents_DirectionalLight_AddedToEntity)

AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_DisplayMapperAdded.py

@@ -0,0 +1,137 @@
+"""
+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
+"""
+
+# fmt: off
+class Tests:
+    camera_creation =            ("Camera Entity successfully created",         "Camera Entity failed to be created")
+    camera_component_added =     ("Camera component was added to entity",       "Camera component failed to be added to entity")
+    camera_component_check =     ("Entity has a Camera component",              "Entity failed to find Camera component")
+    creation_undo =              ("UNDO Entity creation success",               "UNDO Entity creation failed")
+    creation_redo =              ("REDO Entity creation success",               "REDO Entity creation failed")
+    display_mapper_creation =    ("Display Mapper Entity successfully created", "Display Mapper Entity failed to be created")
+    display_mapper_component =   ("Entity has a Display Mapper component",      "Entity failed to find Display Mapper component")
+    enter_game_mode =            ("Entered game mode",                          "Failed to enter game mode")
+    exit_game_mode =             ("Exited game mode",                           "Couldn't exit game mode")
+    is_visible =                 ("Entity is visible",                          "Entity was not visible")
+    is_hidden =                  ("Entity is hidden",                           "Entity was not hidden")
+    entity_deleted =             ("Entity deleted",                             "Entity was not deleted")
+    deletion_undo =              ("UNDO deletion success",                      "UNDO deletion failed")
+    deletion_redo =              ("REDO deletion success",                      "REDO deletion failed")
+    no_error_occurred =          ("No errors detected",                         "Errors were detected")
+# fmt: on
+
+
+def AtomEditorComponents_DisplayMapper_AddedToEntity():
+    """
+    Summary:
+    Tests the Display Mapper component can be added to an entity and has the expected functionality.
+
+    Test setup:
+    - Wait for Editor idle loop.
+    - Open the "Base" level.
+
+    Expected Behavior:
+    The component can be added, used in game mode, hidden/shown, deleted, and has accurate required components.
+    Creation and deletion undo/redo should also work.
+
+    Test Steps:
+    1) Create a Display Mapper entity with no components.
+    2) Add Display Mapper component to Display Mapper entity.
+    3) UNDO the entity creation and component addition.
+    4) REDO the entity creation and component addition.
+    5) Enter/Exit game mode.
+    6) Test IsHidden.
+    7) Test IsVisible.
+    8) Delete Display Mapper entity.
+    9) UNDO deletion.
+    10) REDO deletion.
+    11) Look for errors.
+
+    :return: None
+    """
+
+    import azlmbr.legacy.general as general
+    import azlmbr.math as math
+
+    from editor_python_test_tools.editor_entity_utils import EditorEntity
+    from editor_python_test_tools.utils import Report, Tracer, TestHelper as helper
+
+    with Tracer() as error_tracer:
+        # Test setup begins.
+        # Setup: Wait for Editor idle loop before executing Python hydra scripts then open "Base" level.
+        helper.init_idle()
+        helper.open_level("", "Base")
+
+        # Test steps begin.
+        # 1. Create a Display Mapper entity with no components.
+        display_mapper = "Display Mapper"
+        display_mapper_entity = EditorEntity.create_editor_entity_at(
+            math.Vector3(512.0, 512.0, 34.0), f"{display_mapper}")
+        Report.critical_result(Tests.display_mapper_creation, display_mapper_entity.exists())
+
+        # 2. Add Display Mapper component to Display Mapper entity.
+        display_mapper_entity.add_component(display_mapper)
+        Report.critical_result(Tests.display_mapper_component, display_mapper_entity.has_component(display_mapper))
+
+        # 3. UNDO the entity creation and component addition.
+        # -> UNDO component addition.
+        general.undo()
+        # -> UNDO naming entity.
+        general.undo()
+        # -> UNDO selecting entity.
+        general.undo()
+        # -> UNDO entity creation.
+        general.undo()
+        general.idle_wait_frames(1)
+        Report.result(Tests.creation_undo, not display_mapper_entity.exists())
+
+        # 4. REDO the entity creation and component addition.
+        # -> REDO entity creation.
+        general.redo()
+        # -> REDO selecting entity.
+        general.redo()
+        # -> REDO naming entity.
+        general.redo()
+        # -> REDO component addition.
+        general.redo()
+        general.idle_wait_frames(1)
+        Report.result(Tests.creation_redo, display_mapper_entity.exists())
+
+        # 5. Enter/Exit game mode.
+        helper.enter_game_mode(Tests.enter_game_mode)
+        general.idle_wait_frames(1)
+        helper.exit_game_mode(Tests.exit_game_mode)
+
+        # 6. Test IsHidden.
+        display_mapper_entity.set_visibility_state(False)
+        Report.result(Tests.is_hidden, display_mapper_entity.is_hidden() is True)
+
+        # 7. Test IsVisible.
+        display_mapper_entity.set_visibility_state(True)
+        general.idle_wait_frames(1)
+        Report.result(Tests.is_visible, display_mapper_entity.is_visible() is True)
+
+        # 8. Delete Display Mapper entity.
+        display_mapper_entity.delete()
+        Report.result(Tests.entity_deleted, not display_mapper_entity.exists())
+
+        # 9. UNDO deletion.
+        general.undo()
+        Report.result(Tests.deletion_undo, display_mapper_entity.exists())
+
+        # 10. REDO deletion.
+        general.redo()
+        Report.result(Tests.deletion_redo, not display_mapper_entity.exists())
+
+        # 11. Look for errors.
+        helper.wait_for_condition(lambda: error_tracer.has_errors, 1.0)
+        Report.result(Tests.no_error_occurred, not error_tracer.has_errors)
+
+
+if __name__ == "__main__":
+    from editor_python_test_tools.utils import Report
+    Report.start_test(AtomEditorComponents_DisplayMapper_AddedToEntity)

AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_ExposureControlAdded.py

@@ -0,0 +1,145 @@
+"""
+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
+"""
+
+# fmt: off
+class Tests:
+    camera_creation =              ("Camera Entity successfully created",          "Camera Entity failed to be created")
+    camera_component_added =       ("Camera component was added to entity",        "Camera component failed to be added to entity")
+    camera_component_check =       ("Entity has a Camera component",               "Entity failed to find Camera component")
+    creation_undo =                ("UNDO Entity creation success",                "UNDO Entity creation failed")
+    creation_redo =                ("REDO Entity creation success",                "REDO Entity creation failed")
+    exposure_control_creation =    ("ExposureControl Entity successfully created", "ExposureControl Entity failed to be created")
+    exposure_control_component =   ("Entity has a Exposure Control component",     "Entity failed to find Exposure Control component")
+    post_fx_component =            ("Entity has a Post FX Layer component",        "Entity did not have a Post FX Layer component")
+    enter_game_mode =              ("Entered game mode",                           "Failed to enter game mode")
+    exit_game_mode =               ("Exited game mode",                            "Couldn't exit game mode")
+    is_visible =                   ("Entity is visible",                           "Entity was not visible")
+    is_hidden =                    ("Entity is hidden",                            "Entity was not hidden")
+    entity_deleted =               ("Entity deleted",                              "Entity was not deleted")
+    deletion_undo =                ("UNDO deletion success",                       "UNDO deletion failed")
+    deletion_redo =                ("REDO deletion success",                       "REDO deletion failed")
+    no_error_occurred =            ("No errors detected",                          "Errors were detected")
+# fmt: on
+
+
+def AtomEditorComponents_ExposureControl_AddedToEntity():
+    """
+    Summary:
+    Tests the Exposure Control component can be added to an entity and has the expected functionality.
+
+    Test setup:
+    - Wait for Editor idle loop.
+    - Open the "Base" level.
+
+    Expected Behavior:
+    The component can be added, used in game mode, hidden/shown, deleted, and has accurate required components.
+    Creation and deletion undo/redo should also work.
+
+    Test Steps:
+    1) Create an Exposure Control entity with no components.
+    2) Add Exposure Control component to Exposure Control entity.
+    3) UNDO the entity creation and component addition.
+    4) REDO the entity creation and component addition.
+    5) Enter/Exit game mode.
+    6) Test IsHidden.
+    7) Test IsVisible.
+    8) Add Post FX Layer component.
+    9) Delete Exposure Control entity.
+    10) UNDO deletion.
+    11) REDO deletion.
+    12) Look for errors.
+
+    :return: None
+    """
+
+    import azlmbr.legacy.general as general
+    import azlmbr.math as math
+
+    from editor_python_test_tools.editor_entity_utils import EditorEntity
+    from editor_python_test_tools.utils import Report, Tracer, TestHelper as helper
+
+    with Tracer() as error_tracer:
+        # Test setup begins.
+        # Setup: Wait for Editor idle loop before executing Python hydra scripts then open "Base" level.
+        helper.init_idle()
+        helper.open_level("", "Base")
+
+        # Test steps begin.
+        # 1. Creation of Exposure Control entity with no components.
+        exposure_control_name = "Exposure Control"
+        exposure_control_entity = EditorEntity.create_editor_entity_at(
+            math.Vector3(512.0, 512.0, 34.0), f"{exposure_control_name}")
+        Report.critical_result(Tests.exposure_control_creation, exposure_control_entity.exists())
+
+        # 2. Add Exposure Control component to Exposure Control entity.
+        exposure_control_entity.add_component(exposure_control_name)
+        Report.critical_result(
+            Tests.exposure_control_component, exposure_control_entity.has_component(exposure_control_name))
+
+        # 3. UNDO the entity creation and component addition.
+        # -> UNDO component addition.
+        general.undo()
+        # -> UNDO naming entity.
+        general.undo()
+        # -> UNDO selecting entity.
+        general.undo()
+        # -> UNDO entity creation.
+        general.undo()
+        general.idle_wait_frames(1)
+        Report.result(Tests.creation_undo, not exposure_control_entity.exists())
+
+        # 4. REDO the entity creation and component addition.
+        # -> REDO entity creation.
+        general.redo()
+        # -> REDO selecting entity.
+        general.redo()
+        # -> REDO naming entity.
+        general.redo()
+        # -> REDO component addition.
+        general.redo()
+        general.idle_wait_frames(1)
+        Report.result(Tests.creation_redo, exposure_control_entity.exists())
+
+        # 5. Enter/Exit game mode.
+        helper.enter_game_mode(Tests.enter_game_mode)
+        general.idle_wait_frames(1)
+        helper.exit_game_mode(Tests.exit_game_mode)
+
+        # 6. Test IsHidden.
+        exposure_control_entity.set_visibility_state(False)
+        Report.result(Tests.is_hidden, exposure_control_entity.is_hidden() is True)
+
+        # 7. Test IsVisible.
+        exposure_control_entity.set_visibility_state(True)
+        general.idle_wait_frames(1)
+        Report.result(Tests.is_visible, exposure_control_entity.is_visible() is True)
+
+        # 8. Add Post FX Layer component.
+        post_fx_layer_name = "PostFX Layer"
+        exposure_control_entity.add_component(post_fx_layer_name)
+        Report.result(Tests.post_fx_component, exposure_control_entity.has_component(post_fx_layer_name))
+
+        # 9. Delete ExposureControl entity.
+        exposure_control_entity.delete()
+        Report.result(Tests.entity_deleted, not exposure_control_entity.exists())
+
+        # 10. UNDO deletion.
+        general.undo()
+        Report.result(Tests.deletion_undo, exposure_control_entity.exists())
+
+        # 11. REDO deletion.
+        general.redo()
+        Report.result(Tests.deletion_redo, not exposure_control_entity.exists())
+
+        # 12. Look for errors.
+        helper.wait_for_condition(lambda: error_tracer.has_errors, 1.0)
+        Report.result(Tests.no_error_occurred, not error_tracer.has_errors)
+
+
+if __name__ == "__main__":
+    from editor_python_test_tools.utils import Report
+    Report.start_test(AtomEditorComponents_ExposureControl_AddedToEntity)

AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_GlobalSkylightIBLAdded.py

@@ -0,0 +1,164 @@
+"""
+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
+"""
+
+# fmt: off
+class Tests:
+    camera_creation =             ("Camera Entity successfully created",                  "Camera Entity failed to be created")
+    camera_component_added =      ("Camera component was added to entity",                "Camera component failed to be added to entity")
+    camera_component_check =      ("Entity has a Camera component",                       "Entity failed to find Camera component")
+    creation_undo =               ("UNDO Entity creation success",                        "UNDO Entity creation failed")
+    creation_redo =               ("REDO Entity creation success",                        "REDO Entity creation failed")
+    global_skylight_creation =    ("Global Skylight (IBL) Entity successfully created",   "Global Skylight (IBL) Entity failed to be created")
+    global_skylight_component =   ("Entity has a Global Skylight (IBL) component",        "Entity failed to find Global Skylight (IBL) component")
+    diffuse_image_set =           ("Entity has the Diffuse Image set",                    "Entity did not the Diffuse Image set")
+    specular_image_set =          ("Entity has the Specular Image set",                   "Entity did not the Specular Image set")
+    enter_game_mode =             ("Entered game mode",                                   "Failed to enter game mode")
+    exit_game_mode =              ("Exited game mode",                                    "Couldn't exit game mode")
+    is_visible =                  ("Entity is visible",                                   "Entity was not visible")
+    is_hidden =                   ("Entity is hidden",                                    "Entity was not hidden")
+    entity_deleted =              ("Entity deleted",                                      "Entity was not deleted")
+    deletion_undo =               ("UNDO deletion success",                               "UNDO deletion failed")
+    deletion_redo =               ("REDO deletion success",                               "REDO deletion failed")
+    no_error_occurred =           ("No errors detected",                                  "Errors were detected")
+# fmt: on
+
+
+def AtomEditorComponents_GlobalSkylightIBL_AddedToEntity():
+    """
+    Summary:
+    Tests the Global Skylight (IBL) component can be added to an entity and has the expected functionality.
+
+    Test setup:
+    - Wait for Editor idle loop.
+    - Open the "Base" level.
+
+    Expected Behavior:
+    The component can be added, used in game mode, hidden/shown, deleted, and has accurate required components.
+    Creation and deletion undo/redo should also work.
+
+    Test Steps:
+    1) Create a Global Skylight (IBL) entity with no components.
+    2) Add Global Skylight (IBL) component to Global Skylight (IBL) entity.
+    3) UNDO the entity creation and component addition.
+    4) REDO the entity creation and component addition.
+    5) Enter/Exit game mode.
+    6) Test IsHidden.
+    7) Test IsVisible.
+    8) Add Post FX Layer component.
+    9) Add Camera component
+    10) Delete Global Skylight (IBL) entity.
+    11) UNDO deletion.
+    12) REDO deletion.
+    13) Look for errors.
+
+    :return: None
+    """
+    import os
+
+    import azlmbr.legacy.general as general
+    import azlmbr.math as math
+
+    from editor_python_test_tools.asset_utils import Asset
+    from editor_python_test_tools.editor_entity_utils import EditorEntity
+    from editor_python_test_tools.utils import Report, Tracer, TestHelper as helper
+
+    with Tracer() as error_tracer:
+        # Test setup begins.
+        # Setup: Wait for Editor idle loop before executing Python hydra scripts then open "Base" level.
+        helper.init_idle()
+        helper.open_level("", "Base")
+
+        # Test steps begin.
+        # 1. Create a Global Skylight (IBL) entity with no components.
+        global_skylight_name = "Global Skylight (IBL)"
+        global_skylight_entity = EditorEntity.create_editor_entity_at(
+            math.Vector3(512.0, 512.0, 34.0), global_skylight_name)
+        Report.critical_result(Tests.global_skylight_creation, global_skylight_entity.exists())
+
+        # 2. Add Global Skylight (IBL) component to Global Skylight (IBL) entity.
+        global_skylight_component = global_skylight_entity.add_component(global_skylight_name)
+        Report.critical_result(
+            Tests.global_skylight_component, global_skylight_entity.has_component(global_skylight_name))
+
+        # 3. UNDO the entity creation and component addition.
+        # -> UNDO component addition.
+        general.undo()
+        # -> UNDO naming entity.
+        general.undo()
+        # -> UNDO selecting entity.
+        general.undo()
+        # -> UNDO entity creation.
+        general.undo()
+        general.idle_wait_frames(1)
+        Report.result(Tests.creation_undo, not global_skylight_entity.exists())
+
+        # 4. REDO the entity creation and component addition.
+        # -> REDO entity creation.
+        general.redo()
+        # -> REDO selecting entity.
+        general.redo()
+        # -> REDO naming entity.
+        general.redo()
+        # -> REDO component addition.
+        general.redo()
+        general.idle_wait_frames(1)
+        Report.result(Tests.creation_redo, global_skylight_entity.exists())
+
+        # 5. Enter/Exit game mode.
+        helper.enter_game_mode(Tests.enter_game_mode)
+        general.idle_wait_frames(1)
+        helper.exit_game_mode(Tests.exit_game_mode)
+
+        # 6. Test IsHidden.
+        global_skylight_entity.set_visibility_state(False)
+        Report.result(Tests.is_hidden, global_skylight_entity.is_hidden() is True)
+
+        # 7. Test IsVisible.
+        global_skylight_entity.set_visibility_state(True)
+        general.idle_wait_frames(1)
+        Report.result(Tests.is_visible, global_skylight_entity.is_visible() is True)
+
+        # 8. Set the Diffuse Image asset on the Global Skylight (IBL) entity.
+        global_skylight_diffuse_image_property = "Controller|Configuration|Diffuse Image"
+        diffuse_image_path = os.path.join("LightingPresets", "greenwich_park_02_4k_iblskyboxcm.exr.streamingimage")
+        diffuse_image_asset = Asset.find_asset_by_path(diffuse_image_path, False)
+        global_skylight_component.set_component_property_value(
+            global_skylight_diffuse_image_property, diffuse_image_asset.id)
+        diffuse_image_set = global_skylight_component.get_component_property_value(
+            global_skylight_diffuse_image_property)
+        Report.result(Tests.diffuse_image_set, diffuse_image_set == diffuse_image_asset.id)
+
+        # 9. Set the Specular Image asset on the Global Light (IBL) entity.
+        global_skylight_specular_image_property = "Controller|Configuration|Specular Image"
+        specular_image_path = os.path.join("LightingPresets", "greenwich_park_02_4k_iblskyboxcm.exr.streamingimage")
+        specular_image_asset = Asset.find_asset_by_path(specular_image_path, False)
+        global_skylight_component.set_component_property_value(
+            global_skylight_specular_image_property, specular_image_asset.id)
+        specular_image_added = global_skylight_component.get_component_property_value(
+            global_skylight_specular_image_property)
+        Report.result(Tests.specular_image_set, specular_image_added == specular_image_asset.id)
+
+        # 10. Delete Global Skylight (IBL) entity.
+        global_skylight_entity.delete()
+        Report.result(Tests.entity_deleted, not global_skylight_entity.exists())
+
+        # 11. UNDO deletion.
+        general.undo()
+        Report.result(Tests.deletion_undo, global_skylight_entity.exists())
+
+        # 12. REDO deletion.
+        general.redo()
+        Report.result(Tests.deletion_redo, not  global_skylight_entity.exists())
+
+        # 13. Look for errors.
+        helper.wait_for_condition(lambda: error_tracer.has_errors, 1.0)
+        Report.result(Tests.no_error_occurred, not error_tracer.has_errors)
+
+
+if __name__ == "__main__":
+    from editor_python_test_tools.utils import Report
+    Report.start_test(AtomEditorComponents_GlobalSkylightIBL_AddedToEntity)

AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_LightAdded.py

@@ -0,0 +1,136 @@
+"""
+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
+"""
+
+# fmt: off
+class Tests:
+    camera_creation =          ("Camera Entity successfully created",   "Camera Entity failed to be created")
+    camera_component_added =   ("Camera component was added to entity", "Camera component failed to be added to entity")
+    camera_component_check =   ("Entity has a Camera component",        "Entity failed to find Camera component")
+    creation_undo =            ("UNDO Entity creation success",         "UNDO Entity creation failed")
+    creation_redo =            ("REDO Entity creation success",         "REDO Entity creation failed")
+    light_creation =           ("Light Entity successfully created",    "Light Entity failed to be created")
+    light_component =          ("Entity has a Light component",         "Entity failed to find Light component")
+    enter_game_mode =          ("Entered game mode",                    "Failed to enter game mode")
+    exit_game_mode =           ("Exited game mode",                     "Couldn't exit game mode")
+    is_visible =               ("Entity is visible",                    "Entity was not visible")
+    is_hidden =                ("Entity is hidden",                     "Entity was not hidden")
+    entity_deleted =           ("Entity deleted",                       "Entity was not deleted")
+    deletion_undo =            ("UNDO deletion success",                "UNDO deletion failed")
+    deletion_redo =            ("REDO deletion success",                "REDO deletion failed")
+    no_error_occurred =        ("No errors detected",                   "Errors were detected")
+# fmt: on
+
+
+def AtomEditorComponents_Light_AddedToEntity():
+    """
+    Summary:
+    Tests the Light component can be added to an entity and has the expected functionality.
+
+    Test setup:
+    - Wait for Editor idle loop.
+    - Open the "Base" level.
+
+    Expected Behavior:
+    The component can be added, used in game mode, hidden/shown, deleted, and has accurate required components.
+    Creation and deletion undo/redo should also work.
+
+    Test Steps:
+    1) Create a Light entity with no components.
+    2) Add Light component to the Light entity.
+    3) UNDO the entity creation and component addition.
+    4) REDO the entity creation and component addition.
+    5) Enter/Exit game mode.
+    6) Test IsHidden.
+    7) Test IsVisible.
+    8) Delete Light entity.
+    9) UNDO deletion.
+    10) REDO deletion.
+    11) Look for errors.
+
+    :return: None
+    """
+
+    import azlmbr.legacy.general as general
+    import azlmbr.math as math
+
+    from editor_python_test_tools.editor_entity_utils import EditorEntity
+    from editor_python_test_tools.utils import Report, Tracer, TestHelper as helper
+
+    with Tracer() as error_tracer:
+        # Test setup begins.
+        # Setup: Wait for Editor idle loop before executing Python hydra scripts then open "Base" level.
+        helper.init_idle()
+        helper.open_level("", "Base")
+
+        # Test steps begin.
+        # 1. Create a Light entity with no components.
+        light_name = "Light"
+        light_entity = EditorEntity.create_editor_entity_at(math.Vector3(512.0, 512.0, 34.0), light_name)
+        Report.critical_result(Tests.light_creation, light_entity.exists())
+
+        # 2. Add Light component to the Light entity.
+        light_entity.add_component(light_name)
+        Report.critical_result(Tests.light_component, light_entity.has_component(light_name))
+
+        # 3. UNDO the entity creation and component addition.
+        # -> UNDO component addition.
+        general.undo()
+        # -> UNDO naming entity.
+        general.undo()
+        # -> UNDO selecting entity.
+        general.undo()
+        # -> UNDO entity creation.
+        general.undo()
+        general.idle_wait_frames(1)
+        Report.result(Tests.creation_undo, not light_entity.exists())
+
+        # 4. REDO the entity creation and component addition.
+        # -> REDO entity creation.
+        general.redo()
+        # -> REDO selecting entity.
+        general.redo()
+        # -> REDO naming entity.
+        general.redo()
+        # -> REDO component addition.
+        general.redo()
+        general.idle_wait_frames(1)
+        Report.result(Tests.creation_redo, light_entity.exists())
+
+        # 5. Enter/Exit game mode.
+        helper.enter_game_mode(Tests.enter_game_mode)
+        general.idle_wait_frames(1)
+        helper.exit_game_mode(Tests.exit_game_mode)
+
+        # 6. Test IsHidden.
+        light_entity.set_visibility_state(False)
+        Report.result(Tests.is_hidden, light_entity.is_hidden() is True)
+
+        # 7. Test IsVisible.
+        light_entity.set_visibility_state(True)
+        general.idle_wait_frames(1)
+        Report.result(Tests.is_visible, light_entity.is_visible() is True)
+
+        # 8. Delete Light entity.
+        light_entity.delete()
+        Report.result(Tests.entity_deleted, not light_entity.exists())
+
+        # 9. UNDO deletion.
+        general.undo()
+        Report.result(Tests.deletion_undo, light_entity.exists())
+
+        # 10. REDO deletion.
+        general.redo()
+        Report.result(Tests.deletion_redo, not light_entity.exists())
+
+        # 11. Look for errors.
+        helper.wait_for_condition(lambda: error_tracer.has_errors, 1.0)
+        Report.result(Tests.no_error_occurred, not error_tracer.has_errors)
+
+
+if __name__ == "__main__":
+    from editor_python_test_tools.utils import Report
+    Report.start_test(AtomEditorComponents_Light_AddedToEntity)

AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_LightComponent.py

@@ -0,0 +1,213 @@
+"""
+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
+"""
+
+import os
+import sys
+
+import azlmbr.bus as bus
+import azlmbr.editor as editor
+import azlmbr.math as math
+import azlmbr.paths
+import azlmbr.legacy.general as general
+
+sys.path.append(os.path.join(azlmbr.paths.devassets, "Gem", "PythonTests"))
+
+import editor_python_test_tools.hydra_editor_utils as hydra
+from Atom.atom_utils.atom_constants import LIGHT_TYPES
+
+LIGHT_TYPE_PROPERTY = 'Controller|Configuration|Light type'
+SPHERE_AND_SPOT_DISK_LIGHT_PROPERTIES = [
+    ("Controller|Configuration|Shadows|Enable shadow", True),
+    ("Controller|Configuration|Shadows|Shadowmap size", 0),  # 256
+    ("Controller|Configuration|Shadows|Shadowmap size", 1),  # 512
+    ("Controller|Configuration|Shadows|Shadowmap size", 2),  # 1024
+    ("Controller|Configuration|Shadows|Shadowmap size", 3),  # 2048
+    ("Controller|Configuration|Shadows|Shadow filter method", 1),  # PCF
+    ("Controller|Configuration|Shadows|Filtering sample count", 4.0),
+    ("Controller|Configuration|Shadows|Filtering sample count", 64.0),
+    ("Controller|Configuration|Shadows|Shadow filter method", 2),  # ECM
+    ("Controller|Configuration|Shadows|ESM exponent", 50),
+    ("Controller|Configuration|Shadows|ESM exponent", 5000),
+    ("Controller|Configuration|Shadows|Shadow filter method", 3),  # ESM+PCF
+]
+QUAD_LIGHT_PROPERTIES = [
+    ("Controller|Configuration|Both directions", True),
+    ("Controller|Configuration|Fast approximation", True),
+]
+SIMPLE_POINT_LIGHT_PROPERTIES = [
+    ("Controller|Configuration|Attenuation radius|Mode", 0),
+    ("Controller|Configuration|Attenuation radius|Radius", 100.0),
+]
+SIMPLE_SPOT_LIGHT_PROPERTIES = [
+    ("Controller|Configuration|Shutters|Inner angle", 45.0),
+    ("Controller|Configuration|Shutters|Outer angle", 90.0),
+]
+
+
+def verify_required_component_property_value(entity_name, component, property_path, expected_property_value):
+    """
+    Compares the property value of component against the expected_property_value.
+    :param entity_name: name of the entity to use (for test verification purposes).
+    :param component: component to check on a given entity for its current property value.
+    :param property_path: the path to the property inside the component.
+    :param expected_property_value: The value expected from the value inside property_path.
+    :return: None, but prints to general.log() which the test uses to verify against.
+    """
+    property_value = editor.EditorComponentAPIBus(
+        bus.Broadcast, "GetComponentProperty", component, property_path).GetValue()
+    general.log(f"{entity_name}_test: Property value is {property_value} "
+                f"which matches {expected_property_value}")
+
+
+def run():
+    """
+    Test Case - Light Component
+    1. Creates a "light_entity" Entity and attaches a "Light" component to it.
+    2. Updates the Light component to each light type option from the LIGHT_TYPES constant.
+    3. The test will check the Editor log to ensure each light type was selected.
+    4. Prints the string "Light component test (non-GPU) completed" after completion.
+
+    Tests will fail immediately if any of these log lines are found:
+    1. Trace::Assert
+    2. Trace::Error
+    3. Traceback (most recent call last):
+
+    :return: None
+    """
+    # Create a "light_entity" entity with "Light" component.
+    light_entity_name = "light_entity"
+    light_component = "Light"
+    light_entity = hydra.Entity(light_entity_name)
+    light_entity.create_entity(math.Vector3(-1.0, -2.0, 3.0), [light_component])
+    general.log(
+        f"{light_entity_name}_test: Component added to the entity: "
+        f"{hydra.has_components(light_entity.id, [light_component])}")
+
+    # Populate the light_component_id_pair value so that it can be used to select all Light component options.
+    light_component_id_pair = None
+    component_type_id_list = azlmbr.editor.EditorComponentAPIBus(
+        azlmbr.bus.Broadcast, 'FindComponentTypeIdsByEntityType', [light_component], 0)
+    if len(component_type_id_list) < 1:
+        general.log(f"ERROR: A component class with name {light_component} doesn't exist")
+        light_component_id_pair = None
+    elif len(component_type_id_list) > 1:
+        general.log(f"ERROR: Found more than one component classes with same name: {light_component}")
+        light_component_id_pair = None
+    entity_component_id_pair = azlmbr.editor.EditorComponentAPIBus(
+        azlmbr.bus.Broadcast, 'GetComponentOfType', light_entity.id, component_type_id_list[0])
+    if entity_component_id_pair.IsSuccess():
+        light_component_id_pair = entity_component_id_pair.GetValue()
+
+    # Test each Light component option can be selected and it's properties updated.
+    # Point (sphere) light type checks.
+    light_type_property_test(
+        light_type=LIGHT_TYPES['sphere'],
+        light_properties=SPHERE_AND_SPOT_DISK_LIGHT_PROPERTIES,
+        light_component_id_pair=light_component_id_pair,
+        light_entity_name=light_entity_name,
+        light_entity=light_entity
+    )
+
+    # Spot (disk) light type checks.
+    light_type_property_test(
+        light_type=LIGHT_TYPES['spot_disk'],
+        light_properties=SPHERE_AND_SPOT_DISK_LIGHT_PROPERTIES,
+        light_component_id_pair=light_component_id_pair,
+        light_entity_name=light_entity_name,
+        light_entity=light_entity
+    )
+
+    # Capsule light type checks.
+    azlmbr.editor.EditorComponentAPIBus(
+        azlmbr.bus.Broadcast,
+        'SetComponentProperty',
+        light_component_id_pair,
+        LIGHT_TYPE_PROPERTY,
+        LIGHT_TYPES['capsule']
+    )
+    verify_required_component_property_value(
+        entity_name=light_entity_name,
+        component=light_entity.components[0],
+        property_path=LIGHT_TYPE_PROPERTY,
+        expected_property_value=LIGHT_TYPES['capsule']
+    )
+
+    # Quad light type checks.
+    light_type_property_test(
+        light_type=LIGHT_TYPES['quad'],
+        light_properties=QUAD_LIGHT_PROPERTIES,
+        light_component_id_pair=light_component_id_pair,
+        light_entity_name=light_entity_name,
+        light_entity=light_entity
+    )
+
+    # Polygon light type checks.
+    azlmbr.editor.EditorComponentAPIBus(
+        azlmbr.bus.Broadcast,
+        'SetComponentProperty',
+        light_component_id_pair,
+        LIGHT_TYPE_PROPERTY,
+        LIGHT_TYPES['polygon']
+    )
+    verify_required_component_property_value(
+        entity_name=light_entity_name,
+        component=light_entity.components[0],
+        property_path=LIGHT_TYPE_PROPERTY,
+        expected_property_value=LIGHT_TYPES['polygon']
+    )
+
+    # Point (simple punctual) light type checks.
+    light_type_property_test(
+        light_type=LIGHT_TYPES['simple_point'],
+        light_properties=SIMPLE_POINT_LIGHT_PROPERTIES,
+        light_component_id_pair=light_component_id_pair,
+        light_entity_name=light_entity_name,
+        light_entity=light_entity
+    )
+
+    # Spot (simple punctual) light type checks.
+    light_type_property_test(
+        light_type=LIGHT_TYPES['simple_spot'],
+        light_properties=SIMPLE_SPOT_LIGHT_PROPERTIES,
+        light_component_id_pair=light_component_id_pair,
+        light_entity_name=light_entity_name,
+        light_entity=light_entity
+    )
+
+    general.log("Light component test (non-GPU) completed.")
+
+
+def light_type_property_test(light_type, light_properties, light_component_id_pair, light_entity_name, light_entity):
+    """
+    Updates the current light type and modifies its properties, then verifies they are accurate to what was set.
+    :param light_type: The type of light to update, must match a value in LIGHT_TYPES
+    :param light_properties: List of tuples detailing properties to modify with update values.
+    :param light_component_id_pair: Entity + component ID pair for updating the light component on a given entity.
+    :param light_entity_name: the name of the Entity holding the light component.
+    :param light_entity: the Entity object containing the light component.
+    :return: None
+    """
+    azlmbr.editor.EditorComponentAPIBus(
+        azlmbr.bus.Broadcast,
+        'SetComponentProperty',
+        light_component_id_pair,
+        LIGHT_TYPE_PROPERTY,
+        light_type
+    )
+    verify_required_component_property_value(
+        entity_name=light_entity_name,
+        component=light_entity.components[0],
+        property_path=LIGHT_TYPE_PROPERTY,
+        expected_property_value=light_type
+    )
+
+    for light_property in light_properties:
+        light_entity.get_set_test(0, light_property[0], light_property[1])
+
+
+if __name__ == "__main__":
+    run()

AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_PhysicalSkyAdded.py

@@ -0,0 +1,136 @@
+"""
+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
+"""
+
+# fmt: off
+class Tests:
+    camera_creation =          ("Camera Entity successfully created",         "Camera Entity failed to be created")
+    camera_component_added =   ("Camera component was added to entity",       "Camera component failed to be added to entity")
+    camera_component_check =   ("Entity has a Camera component",              "Entity failed to find Camera component")
+    creation_undo =            ("UNDO Entity creation success",               "UNDO Entity creation failed")
+    creation_redo =            ("REDO Entity creation success",               "REDO Entity creation failed")
+    physical_sky_creation =    ("Physical Sky Entity successfully created",   "Physical Sky Entity failed to be created")
+    physical_sky_component =   ("Entity has a Physical Sky component",        "Entity failed to find Physical Sky component")
+    enter_game_mode =          ("Entered game mode",                          "Failed to enter game mode")
+    exit_game_mode =           ("Exited game mode",                           "Couldn't exit game mode")
+    is_visible =               ("Entity is visible",                          "Entity was not visible")
+    is_hidden =                ("Entity is hidden",                           "Entity was not hidden")
+    entity_deleted =           ("Entity deleted",                             "Entity was not deleted")
+    deletion_undo =            ("UNDO deletion success",                      "UNDO deletion failed")
+    deletion_redo =            ("REDO deletion success",                      "REDO deletion failed")
+    no_error_occurred =        ("No errors detected",                         "Errors were detected")
+# fmt: on
+
+
+def AtomEditorComponents_PhysicalSky_AddedToEntity():
+    """
+    Summary:
+    Tests the Physical Sky component can be added to an entity and has the expected functionality.
+
+    Test setup:
+    - Wait for Editor idle loop.
+    - Open the "Base" level.
+
+    Expected Behavior:
+    The component can be added, used in game mode, hidden/shown, deleted, and has accurate required components.
+    Creation and deletion undo/redo should also work.
+
+    Test Steps:
+    1) Create a Physical Sky entity with no components.
+    2) Add Physical Sky component to Physical Sky entity.
+    3) UNDO the entity creation and component addition.
+    4) REDO the entity creation and component addition.
+    5) Enter/Exit game mode.
+    6) Test IsHidden.
+    7) Test IsVisible.
+    8) Delete Physical Sky entity.
+    9) UNDO deletion.
+    10) REDO deletion.
+    11) Look for errors.
+
+    :return: None
+    """
+
+    import azlmbr.legacy.general as general
+    import azlmbr.math as math
+
+    from editor_python_test_tools.editor_entity_utils import EditorEntity
+    from editor_python_test_tools.utils import Report, Tracer, TestHelper as helper
+
+    with Tracer() as error_tracer:
+        # Test setup begins.
+        # Setup: Wait for Editor idle loop before executing Python hydra scripts then open "Base" level.
+        helper.init_idle()
+        helper.open_level("", "Base")
+
+        # Test steps begin.
+        # 1. Create a Physical Sky entity with no components.
+        physical_sky_name = "Physical Sky"
+        physical_sky_entity = EditorEntity.create_editor_entity_at(math.Vector3(512.0, 512.0, 34.0), physical_sky_name)
+        Report.critical_result(Tests.physical_sky_creation, physical_sky_entity.exists())
+
+        # 2. Add Physical Sky component to Physical Sky entity.
+        physical_sky_entity.add_component(physical_sky_name)
+        Report.critical_result(Tests.physical_sky_component, physical_sky_entity.has_component(physical_sky_name))
+
+        # 3. UNDO the entity creation and component addition.
+        # -> UNDO component addition.
+        general.undo()
+        # -> UNDO naming entity.
+        general.undo()
+        # -> UNDO selecting entity.
+        general.undo()
+        # -> UNDO entity creation.
+        general.undo()
+        general.idle_wait_frames(1)
+        Report.result(Tests.creation_undo, not physical_sky_entity.exists())
+
+        # 4. REDO the entity creation and component addition.
+        # -> REDO entity creation.
+        general.redo()
+        # -> REDO selecting entity.
+        general.redo()
+        # -> REDO naming entity.
+        general.redo()
+        # -> REDO component addition.
+        general.redo()
+        general.idle_wait_frames(1)
+        Report.result(Tests.creation_redo, physical_sky_entity.exists())
+
+        # 5. Enter/Exit game mode.
+        helper.enter_game_mode(Tests.enter_game_mode)
+        general.idle_wait_frames(1)
+        helper.exit_game_mode(Tests.exit_game_mode)
+
+        # 6. Test IsHidden.
+        physical_sky_entity.set_visibility_state(False)
+        Report.result(Tests.is_hidden, physical_sky_entity.is_hidden() is True)
+
+        # 7. Test IsVisible.
+        physical_sky_entity.set_visibility_state(True)
+        general.idle_wait_frames(1)
+        Report.result(Tests.is_visible, physical_sky_entity.is_visible() is True)
+
+        # 8. Delete Physical Sky entity.
+        physical_sky_entity.delete()
+        Report.result(Tests.entity_deleted, not physical_sky_entity.exists())
+
+        # 9. UNDO deletion.
+        general.undo()
+        Report.result(Tests.deletion_undo, physical_sky_entity.exists())
+
+        # 10. REDO deletion.
+        general.redo()
+        Report.result(Tests.deletion_redo, not physical_sky_entity.exists())
+
+        # 11. Look for errors.
+        helper.wait_for_condition(lambda: error_tracer.has_errors, 1.0)
+        Report.result(Tests.no_error_occurred, not error_tracer.has_errors)
+
+
+if __name__ == "__main__":
+    from editor_python_test_tools.utils import Report
+    Report.start_test(AtomEditorComponents_PhysicalSky_AddedToEntity)

AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_PostFXRadiusWeightModifierAdded.py

@@ -0,0 +1,138 @@
+"""
+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
+"""
+
+# fmt: off
+class Tests:
+    camera_creation =                  ("Camera Entity successfully created",                         "Camera Entity failed to be created")
+    camera_component_added =           ("Camera component was added to entity",                       "Camera component failed to be added to entity")
+    camera_component_check =           ("Entity has a Camera component",                              "Entity failed to find Camera component")
+    creation_undo =                    ("UNDO Entity creation success",                               "UNDO Entity creation failed")
+    creation_redo =                    ("REDO Entity creation success",                               "REDO Entity creation failed")
+    postfx_radius_weight_creation =    ("PostFX Radius Weight Modifier Entity successfully created",  "PostFX Radius Weight Modifier Entity failed to be created")
+    postfx_radius_weight_component =   ("Entity has a PostFX Radius Weight Modifier component",       "Entity failed to find PostFX Radius Weight Modifier component")
+    enter_game_mode =                  ("Entered game mode",                                          "Failed to enter game mode")
+    exit_game_mode =                   ("Exited game mode",                                           "Couldn't exit game mode")
+    is_visible =                       ("Entity is visible",                                          "Entity was not visible")
+    is_hidden =                        ("Entity is hidden",                                           "Entity was not hidden")
+    entity_deleted =                   ("Entity deleted",                                             "Entity was not deleted")
+    deletion_undo =                    ("UNDO deletion success",                                      "UNDO deletion failed")
+    deletion_redo =                    ("REDO deletion success",                                      "REDO deletion failed")
+    no_error_occurred =                ("No errors detected",                                         "Errors were detected")
+# fmt: on
+
+
+def AtomEditorComponents_PostFXRadiusWeightModifier_AddedToEntity():
+    """
+    Summary:
+    Tests the PostFX Radius Weight Modifier component can be added to an entity and has the expected functionality.
+
+    Test setup:
+    - Wait for Editor idle loop.
+    - Open the "Base" level.
+
+    Expected Behavior:
+    The component can be added, used in game mode, hidden/shown, deleted, and has accurate required components.
+    Creation and deletion undo/redo should also work.
+
+    Test Steps:
+    1) Create a Post FX Radius Weight Modifier entity with no components.
+    2) Add Post FX Radius Weight Modifier component to Post FX Radius Weight Modifier entity.
+    3) UNDO the entity creation and component addition.
+    4) REDO the entity creation and component addition.
+    5) Enter/Exit game mode.
+    6) Test IsHidden.
+    7) Test IsVisible.
+    8) Delete PostFX Radius Weight Modifier entity.
+    9) UNDO deletion.
+    10) REDO deletion.
+    11) Look for errors.
+
+    :return: None
+    """
+
+    import azlmbr.legacy.general as general
+    import azlmbr.math as math
+
+    from editor_python_test_tools.editor_entity_utils import EditorEntity
+    from editor_python_test_tools.utils import Report, Tracer, TestHelper as helper
+
+    with Tracer() as error_tracer:
+        # Test setup begins.
+        # Setup: Wait for Editor idle loop before executing Python hydra scripts then open "Base" level.
+        helper.init_idle()
+        helper.open_level("", "Base")
+
+        # Test steps begin.
+        # 1. Create a Post FX Radius Weight Modifier entity with no components.
+        postfx_radius_weight_name = "PostFX Radius Weight Modifier"
+        postfx_radius_weight_entity = EditorEntity.create_editor_entity_at(
+            math.Vector3(512.0, 512.0, 34.0), postfx_radius_weight_name)
+        Report.critical_result(Tests.postfx_radius_weight_creation, postfx_radius_weight_entity.exists())
+
+        # 2. Add Post FX Radius Weight Modifier component to Post FX Radius Weight Modifier entity.
+        postfx_radius_weight_entity.add_component(postfx_radius_weight_name)
+        Report.critical_result(
+            Tests.postfx_radius_weight_component, postfx_radius_weight_entity.has_component(postfx_radius_weight_name))
+
+        # 3. UNDO the entity creation and component addition.
+        # -> UNDO component addition.
+        general.undo()
+        # -> UNDO naming entity.
+        general.undo()
+        # -> UNDO selecting entity.
+        general.undo()
+        # -> UNDO entity creation.
+        general.undo()
+        general.idle_wait_frames(1)
+        Report.result(Tests.creation_undo, not postfx_radius_weight_entity.exists())
+
+        # 4. REDO the entity creation and component addition.
+        # -> REDO entity creation.
+        general.redo()
+        # -> REDO selecting entity.
+        general.redo()
+        # -> REDO naming entity.
+        general.redo()
+        # -> REDO component addition.
+        general.redo()
+        general.idle_wait_frames(1)
+        Report.result(Tests.creation_redo, postfx_radius_weight_entity.exists())
+
+        # 5. Enter/Exit game mode.
+        helper.enter_game_mode(Tests.enter_game_mode)
+        general.idle_wait_frames(1)
+        helper.exit_game_mode(Tests.exit_game_mode)
+
+        # 6. Test IsHidden.
+        postfx_radius_weight_entity.set_visibility_state(False)
+        Report.result(Tests.is_hidden, postfx_radius_weight_entity.is_hidden() is True)
+
+        # 7. Test IsVisible.
+        postfx_radius_weight_entity.set_visibility_state(True)
+        general.idle_wait_frames(1)
+        Report.result(Tests.is_visible, postfx_radius_weight_entity.is_visible() is True)
+
+        # 8. Delete PostFX Radius Weight Modifier entity.
+        postfx_radius_weight_entity.delete()
+        Report.result(Tests.entity_deleted, not postfx_radius_weight_entity.exists())
+
+        # 9. UNDO deletion.
+        general.undo()
+        Report.result(Tests.deletion_undo, postfx_radius_weight_entity.exists())
+
+        # 10. REDO deletion.
+        general.redo()
+        Report.result(Tests.deletion_redo, not postfx_radius_weight_entity.exists())
+
+        # 11. Look for errors.
+        helper.wait_for_condition(lambda: error_tracer.has_errors, 1.0)
+        Report.result(Tests.no_error_occurred, not error_tracer.has_errors)
+
+
+if __name__ == "__main__":
+    from editor_python_test_tools.utils import Report
+    Report.start_test(AtomEditorComponents_PostFXRadiusWeightModifier_AddedToEntity)

AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomMaterialEditor_BasicTests.py

@@ -0,0 +1,192 @@
+"""
+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
+"""
+
+# import azlmbr.materialeditor will fail with a ModuleNotFound error when using this script with Editor.exe
+# This is because azlmbr.materialeditor only binds to MaterialEditor.exe and not Editor.exe
+# You need to launch this script with MaterialEditor.exe in order for azlmbr.materialeditor to appear.
+
+import os
+import sys
+import time
+
+import azlmbr.math as math
+import azlmbr.paths
+
+sys.path.append(os.path.join(azlmbr.paths.devassets, "Gem", "PythonTests"))
+
+import Atom.atom_utils.material_editor_utils as material_editor
+
+NEW_MATERIAL = "test_material.material"
+NEW_MATERIAL_1 = "test_material_1.material"
+NEW_MATERIAL_2 = "test_material_2.material"
+TEST_MATERIAL_1 = "001_DefaultWhite.material"
+TEST_MATERIAL_2 = "002_BaseColorLerp.material"
+TEST_MATERIAL_3 = "003_MetalMatte.material"
+TEST_DATA_PATH = os.path.join(
+    azlmbr.paths.devroot, "Gems", "Atom", "TestData", "TestData", "Materials", "StandardPbrTestCases"
+)
+MATERIAL_TYPE_PATH = os.path.join(
+    azlmbr.paths.devroot, "Gems", "Atom", "Feature", "Common", "Assets",
+    "Materials", "Types", "StandardPBR.materialtype",
+)
+CACHE_FILE_EXTENSION = ".azmaterial"
+
+
+def run():
+    """
+    Summary:
+    Material Editor basic tests including the below
+    1. Opening an Existing Asset
+    2. Creating a New Asset
+    3. Closing Selected Material
+    4. Closing All Materials
+    5. Closing all but Selected Material
+    6. Saving Material
+    7. Saving as a New Material
+    8. Saving as a Child Material
+    9. Saving all Open Materials
+
+    Expected Result:
+    All the above functions work as expected in Material Editor.
+
+    :return: None
+    """
+
+    # 1) Test Case: Opening an Existing Asset
+    document_id = material_editor.open_material(MATERIAL_TYPE_PATH)
+    print(f"Material opened: {material_editor.is_open(document_id)}")
+
+    # Verify if the test material exists initially
+    target_path = os.path.join(azlmbr.paths.devroot, "AutomatedTesting", "Materials", NEW_MATERIAL)
+    print(f"Test asset doesn't exist initially: {not os.path.exists(target_path)}")
+
+    # 2) Test Case: Creating a New Material Using Existing One
+    material_editor.save_document_as_child(document_id, target_path)
+    material_editor.wait_for_condition(lambda: os.path.exists(target_path), 2.0)
+    print(f"New asset created: {os.path.exists(target_path)}")
+    time.sleep(2.0)
+
+    # Verify if the newly created document is open
+    new_document_id = material_editor.open_material(target_path)
+    material_editor.wait_for_condition(lambda: material_editor.is_open(new_document_id))
+    print(f"New Material opened: {material_editor.is_open(new_document_id)}")
+
+    # 3) Test Case: Closing Selected Material
+    print(f"Material closed: {material_editor.close_document(new_document_id)}")
+
+    # Open materials initially
+    document1_id, document2_id, document3_id = (
+        material_editor.open_material(os.path.join(TEST_DATA_PATH, material))
+        for material in [TEST_MATERIAL_1, TEST_MATERIAL_2, TEST_MATERIAL_3]
+    )
+
+    # 4) Test Case: Closing All Materials
+    print(f"All documents closed: {material_editor.close_all_documents()}")
+
+    # 5) Test Case: Closing all but Selected Material
+    document1_id, document2_id, document3_id = (
+        material_editor.open_material(os.path.join(TEST_DATA_PATH, material))
+        for material in [TEST_MATERIAL_1, TEST_MATERIAL_2, TEST_MATERIAL_3]
+    )
+    result = material_editor.close_all_except_selected(document1_id)
+    print(f"Close All Except Selected worked as expected: {result and material_editor.is_open(document1_id)}")
+
+    # 6) Test Case: Saving Material
+    document_id = material_editor.open_material(os.path.join(TEST_DATA_PATH, TEST_MATERIAL_1))
+    property_name = azlmbr.name.Name("baseColor.color")
+    initial_color = material_editor.get_property(document_id, property_name)
+    # Assign new color to the material file and save the actual material
+    expected_color = math.Color(0.25, 0.25, 0.25, 1.0)
+    material_editor.set_property(document_id, property_name, expected_color)
+    material_editor.save_document(document_id)
+    time.sleep(2.0)
+
+    # 7) Test Case: Saving as a New Material
+    # Assign new color to the material file and save the document as copy
+    expected_color_1 = math.Color(0.5, 0.5, 0.5, 1.0)
+    material_editor.set_property(document_id, property_name, expected_color_1)
+    target_path_1 = os.path.join(azlmbr.paths.devroot, "AutomatedTesting", "Materials", NEW_MATERIAL_1)
+    cache_file_name_1 = os.path.splitext(NEW_MATERIAL_1)  # Example output: ('test_material_1', '.material')
+    cache_file_1 = f"{cache_file_name_1[0]}{CACHE_FILE_EXTENSION}"
+    target_path_1_cache = os.path.join(azlmbr.paths.devassets, "Cache", "pc", "materials", cache_file_1)
+    material_editor.save_document_as_copy(document_id, target_path_1)
+    material_editor.wait_for_condition(lambda: os.path.exists(target_path_1_cache), 4.0)
+
+    # 8) Test Case: Saving as a Child Material
+    # Assign new color to the material file save the document as child
+    expected_color_2 = math.Color(0.75, 0.75, 0.75, 1.0)
+    material_editor.set_property(document_id, property_name, expected_color_2)
+    target_path_2 = os.path.join(azlmbr.paths.devroot, "AutomatedTesting", "Materials", NEW_MATERIAL_2)
+    cache_file_name_2 = os.path.splitext(NEW_MATERIAL_1)  # Example output: ('test_material_2', '.material')
+    cache_file_2 = f"{cache_file_name_2[0]}{CACHE_FILE_EXTENSION}"
+    target_path_2_cache = os.path.join(azlmbr.paths.devassets, "Cache", "pc", "materials", cache_file_2)
+    material_editor.save_document_as_child(document_id, target_path_2)
+    material_editor.wait_for_condition(lambda: os.path.exists(target_path_2_cache), 4.0)
+
+    # Close/Reopen documents
+    material_editor.close_all_documents()
+    document_id = material_editor.open_material(os.path.join(TEST_DATA_PATH, TEST_MATERIAL_1))
+    document1_id = material_editor.open_material(target_path_1)
+    document2_id = material_editor.open_material(target_path_2)
+
+    # Verify if the changes are saved in the actual document
+    actual_color = material_editor.get_property(document_id, property_name)
+    print(f"Actual Document saved with changes: {material_editor.compare_colors(actual_color, expected_color)}")
+
+    # Verify if the changes are saved in the document saved as copy
+    actual_color = material_editor.get_property(document1_id, property_name)
+    result_copy = material_editor.compare_colors(actual_color, expected_color_1)
+    print(f"Document saved as copy is saved with changes: {result_copy}")
+
+    # Verify if the changes are saved in the document saved as child
+    actual_color = material_editor.get_property(document2_id, property_name)
+    result_child = material_editor.compare_colors(actual_color, expected_color_2)
+    print(f"Document saved as child is saved with changes: {result_child}")
+
+    # Revert back the changes in the actual document
+    material_editor.set_property(document_id, property_name, initial_color)
+    material_editor.save_document(document_id)
+    material_editor.close_all_documents()
+
+    # 9) Test Case: Saving all Open Materials
+    # Open first material and make change to the values
+    document1_id = material_editor.open_material(os.path.join(TEST_DATA_PATH, TEST_MATERIAL_1))
+    property1_name = azlmbr.name.Name("metallic.factor")
+    initial_metallic_factor = material_editor.get_property(document1_id, property1_name)
+    expected_metallic_factor = 0.444
+    material_editor.set_property(document1_id, property1_name, expected_metallic_factor)
+
+    # Open second material and make change to the values
+    document2_id = material_editor.open_material(os.path.join(TEST_DATA_PATH, TEST_MATERIAL_2))
+    property2_name = azlmbr.name.Name("baseColor.color")
+    initial_color = material_editor.get_property(document2_id, property2_name)
+    expected_color = math.Color(0.4156, 0.0196, 0.6862, 1.0)
+    material_editor.set_property(document2_id, property2_name, expected_color)
+
+    # Save all and close all documents
+    material_editor.save_all()
+    material_editor.close_all_documents()
+
+    # Reopen materials and verify values
+    document1_id = material_editor.open_material(os.path.join(TEST_DATA_PATH, TEST_MATERIAL_1))
+    result = material_editor.is_close(
+        material_editor.get_property(document1_id, property1_name), expected_metallic_factor, 0.00001
+    )
+    document2_id = material_editor.open_material(os.path.join(TEST_DATA_PATH, TEST_MATERIAL_2))
+    result = result and material_editor.compare_colors(
+        expected_color, material_editor.get_property(document2_id, property2_name))
+    print(f"Save All worked as expected: {result}")
+
+    # Revert the changes made
+    material_editor.set_property(document1_id, property1_name, initial_metallic_factor)
+    material_editor.set_property(document2_id, property2_name, initial_color)
+    material_editor.save_all()
+    material_editor.close_all_documents()
+
+
+if __name__ == "__main__":
+    run()

AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_GPUTest_AtomFeatureIntegrationBenchmark.py

@@ -0,0 +1,98 @@
+"""
+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
+"""
+
+import os
+import sys
+
+import azlmbr.legacy.general as general
+
+sys.path.append(os.path.join(azlmbr.paths.devroot, "AutomatedTesting", "Gem", "PythonTests"))
+
+import editor_python_test_tools.hydra_editor_utils as hydra
+from editor_python_test_tools.editor_test_helper import EditorTestHelper
+from Atom.atom_utils.benchmark_utils import BenchmarkHelper
+
+SCREEN_WIDTH = 1280
+SCREEN_HEIGHT = 720
+DEGREE_RADIAN_FACTOR = 0.0174533
+
+helper = EditorTestHelper(log_prefix="Test_Atom_BasicLevelSetup")
+
+
+def run():
+    """
+    1. View -> Layouts -> Restore Default Layout, sets the viewport to ratio 16:9 @ 1280 x 720
+    2. Runs console command r_DisplayInfo = 0
+    3. Opens AtomFeatureIntegrationBenchmark level
+    4. Initializes benchmark helper with benchmark name to capture benchmark metadata.
+    5. Idles for 100 frames, then collects pass timings for 100 frames.
+    :return: None
+    """
+    def initial_viewport_setup(screen_width, screen_height):
+        general.set_viewport_size(screen_width, screen_height)
+        general.update_viewport()
+        helper.wait_for_condition(
+            function=lambda: helper.isclose(a=general.get_viewport_size().x, b=SCREEN_WIDTH, rel_tol=0.1)
+            and helper.isclose(a=general.get_viewport_size().y, b=SCREEN_HEIGHT, rel_tol=0.1),
+            timeout_in_seconds=4.0
+        )
+        result = helper.isclose(a=general.get_viewport_size().x, b=SCREEN_WIDTH, rel_tol=0.1) and helper.isclose(
+            a=general.get_viewport_size().y, b=SCREEN_HEIGHT, rel_tol=0.1)
+        general.log(general.get_viewport_size().x)
+        general.log(general.get_viewport_size().y)
+        general.log(general.get_viewport_size().z)
+        general.log(f"Viewport is set to the expected size: {result}")
+        general.run_console("r_DisplayInfo = 0")
+
+    def after_level_load():
+        """Function to call after creating/opening a level to ensure it loads."""
+        # Give everything a second to initialize.
+        general.idle_enable(True)
+        general.idle_wait(1.0)
+        general.update_viewport()
+        general.idle_wait(0.5)  # half a second is more than enough for updating the viewport.
+
+        # Close out problematic windows, FPS meters, and anti-aliasing.
+        if general.is_helpers_shown():  # Turn off the helper gizmos if visible
+            general.toggle_helpers()
+            general.idle_wait(1.0)
+        if general.is_pane_visible("Error Report"):  # Close Error Report windows that block focus.
+            general.close_pane("Error Report")
+        if general.is_pane_visible("Error Log"):  # Close Error Log windows that block focus.
+            general.close_pane("Error Log")
+        general.idle_wait(1.0)
+        general.run_console("r_displayInfo=0")
+        general.run_console("r_antialiasingmode=0")
+        general.idle_wait(1.0)
+
+        return True
+
+    # Wait for Editor idle loop before executing Python hydra scripts.
+    general.idle_enable(True)
+
+    general.open_level_no_prompt("AtomFeatureIntegrationBenchmark")
+
+    # Basic setup after opening level.
+    after_level_load()
+    initial_viewport_setup(SCREEN_WIDTH, SCREEN_HEIGHT)
+
+    general.enter_game_mode()
+    general.idle_wait(1.0)
+    helper.wait_for_condition(function=lambda: general.is_in_game_mode(), timeout_in_seconds=2.0)
+    benchmarker = BenchmarkHelper("AtomFeatureIntegrationBenchmark")
+    benchmarker.capture_benchmark_metadata()
+    general.idle_wait_frames(100)
+    for i in range(1, 101):
+        benchmarker.capture_pass_timestamp(i)
+        benchmarker.capture_cpu_frame_time(i)
+    general.exit_game_mode()
+    helper.wait_for_condition(function=lambda: not general.is_in_game_mode(), timeout_in_seconds=2.0)
+    general.log("Capturing complete.")
+
+
+if __name__ == "__main__":
+    run()

AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_GPUTest_BasicLevelSetup.py

@@ -0,0 +1,223 @@
+"""
+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
+"""
+
+import os
+import sys
+
+import azlmbr.asset as asset
+import azlmbr.bus as bus
+import azlmbr.camera
+import azlmbr.entity as entity
+import azlmbr.legacy.general as general
+import azlmbr.math as math
+import azlmbr.paths
+import azlmbr.editor as editor
+
+sys.path.append(os.path.join(azlmbr.paths.devroot, "AutomatedTesting", "Gem", "PythonTests"))
+
+import editor_python_test_tools.hydra_editor_utils as hydra
+from editor_python_test_tools.editor_test_helper import EditorTestHelper
+from Atom.atom_utils.screenshot_utils import ScreenshotHelper
+
+SCREEN_WIDTH = 1280
+SCREEN_HEIGHT = 720
+DEGREE_RADIAN_FACTOR = 0.0174533
+
+helper = EditorTestHelper(log_prefix="Test_Atom_BasicLevelSetup")
+
+
+def run():
+    """
+    1. View -> Layouts -> Restore Default Layout, sets the viewport to ratio 16:9 @ 1280 x 720
+    2. Runs console command r_DisplayInfo = 0
+    3. Deletes all entities currently present in the level.
+    4. Creates a "default_level" entity to hold all other entities, setting the translate values to x:0, y:0, z:0
+    5. Adds a Grid component to the "default_level" & updates its Grid Spacing to 1.0m
+    6. Adds a "global_skylight" entity to "default_level", attaching an HDRi Skybox w/ a Cubemap Texture.
+    7. Adds a Global Skylight (IBL) component w/ diffuse image and specular image to "global_skylight" entity.
+    8. Adds a "ground_plane" entity to "default_level", attaching a Mesh component & Material component.
+    9. Adds a "directional_light" entity to "default_level" & adds a Directional Light component.
+    10. Adds a "sphere" entity to "default_level" & adds a Mesh component with a Material component to it.
+    11. Adds a "camera" entity to "default_level" & adds a Camera component with 80 degree FOV and Transform values:
+        Translate - x:5.5m, y:-12.0m, z:9.0m
+        Rotate - x:-27.0, y:-12.0, z:25.0
+    12. Finally enters game mode, takes a screenshot, exits game mode, & saves the level.
+    :return: None
+    """
+    def initial_viewport_setup(screen_width, screen_height):
+        general.set_viewport_size(screen_width, screen_height)
+        general.update_viewport()
+        helper.wait_for_condition(
+            function=lambda: helper.isclose(a=general.get_viewport_size().x, b=SCREEN_WIDTH, rel_tol=0.1)
+            and helper.isclose(a=general.get_viewport_size().y, b=SCREEN_HEIGHT, rel_tol=0.1),
+            timeout_in_seconds=4.0
+        )
+        result = helper.isclose(a=general.get_viewport_size().x, b=SCREEN_WIDTH, rel_tol=0.1) and helper.isclose(
+            a=general.get_viewport_size().y, b=SCREEN_HEIGHT, rel_tol=0.1)
+        general.log(general.get_viewport_size().x)
+        general.log(general.get_viewport_size().y)
+        general.log(general.get_viewport_size().z)
+        general.log(f"Viewport is set to the expected size: {result}")
+        general.run_console("r_DisplayInfo = 0")
+
+    def after_level_load():
+        """Function to call after creating/opening a level to ensure it loads."""
+        # Give everything a second to initialize.
+        general.idle_enable(True)
+        general.idle_wait(1.0)
+        general.update_viewport()
+        general.idle_wait(0.5)  # half a second is more than enough for updating the viewport.
+
+        # Close out problematic windows, FPS meters, and anti-aliasing.
+        if general.is_helpers_shown():  # Turn off the helper gizmos if visible
+            general.toggle_helpers()
+            general.idle_wait(1.0)
+        if general.is_pane_visible("Error Report"):  # Close Error Report windows that block focus.
+            general.close_pane("Error Report")
+        if general.is_pane_visible("Error Log"):  # Close Error Log windows that block focus.
+            general.close_pane("Error Log")
+        general.idle_wait(1.0)
+        general.run_console("r_displayInfo=0")
+        general.run_console("r_antialiasingmode=0")
+        general.idle_wait(1.0)
+
+        return True
+
+    # Wait for Editor idle loop before executing Python hydra scripts.
+    general.idle_enable(True)
+
+    # Open the auto_test level.
+    new_level_name = "auto_test"  # Specified in class TestAllComponentsIndepthTests()
+    heightmap_resolution = 512
+    heightmap_meters_per_pixel = 1
+    terrain_texture_resolution = 412
+    use_terrain = False
+
+    # Return codes are ECreateLevelResult defined in CryEdit.h
+    return_code = general.create_level_no_prompt(
+        new_level_name, heightmap_resolution, heightmap_meters_per_pixel, terrain_texture_resolution, use_terrain)
+    if return_code == 1:
+        general.log(f"{new_level_name} level already exists")
+    elif return_code == 2:
+        general.log("Failed to create directory")
+    elif return_code == 3:
+        general.log("Directory length is too long")
+    elif return_code != 0:
+        general.log("Unknown error, failed to create level")
+    else:
+        general.log(f"{new_level_name} level created successfully")
+
+    # Basic setup for newly created level.
+    after_level_load()
+    initial_viewport_setup(SCREEN_WIDTH, SCREEN_HEIGHT)
+
+    # Create default_level entity
+    search_filter = azlmbr.entity.SearchFilter()
+    all_entities = entity.SearchBus(azlmbr.bus.Broadcast, "SearchEntities", search_filter)
+    editor.ToolsApplicationRequestBus(bus.Broadcast, "DeleteEntities", all_entities)
+
+    default_level = hydra.Entity("default_level")
+    position = math.Vector3(0.0, 0.0, 0.0)
+    default_level.create_entity(position, ["Grid"])
+    default_level.get_set_test(0, "Controller|Configuration|Secondary Grid Spacing", 1.0)
+
+    # Create global_skylight entity and set the properties
+    global_skylight = hydra.Entity("global_skylight")
+    global_skylight.create_entity(
+        entity_position=math.Vector3(0.0, 0.0, 0.0),
+        components=["HDRi Skybox", "Global Skylight (IBL)"],
+        parent_id=default_level.id
+    )
+    global_skylight_image_asset_path = os.path.join(
+        "LightingPresets", "greenwich_park_02_4k_iblskyboxcm_iblspecular.exr.streamingimage")
+    global_skylight_image_asset = asset.AssetCatalogRequestBus(
+        bus.Broadcast, "GetAssetIdByPath", global_skylight_image_asset_path, math.Uuid(), False)
+    global_skylight.get_set_test(0, "Controller|Configuration|Cubemap Texture", global_skylight_image_asset)
+    hydra.get_set_test(global_skylight, 1, "Controller|Configuration|Diffuse Image", global_skylight_image_asset)
+    hydra.get_set_test(global_skylight, 1, "Controller|Configuration|Specular Image", global_skylight_image_asset)
+
+    # Create ground_plane entity and set the properties
+    ground_plane = hydra.Entity("ground_plane")
+    ground_plane.create_entity(
+        entity_position=math.Vector3(0.0, 0.0, 0.0),
+        components=["Material"],
+        parent_id=default_level.id
+    )
+    azlmbr.components.TransformBus(azlmbr.bus.Event, "SetLocalUniformScale", ground_plane.id, 32.0)
+    ground_plane_material_asset_path = os.path.join("Materials", "Presets", "PBR", "metal_chrome.azmaterial")
+    ground_plane_material_asset = asset.AssetCatalogRequestBus(
+        bus.Broadcast, "GetAssetIdByPath", ground_plane_material_asset_path, math.Uuid(), False)
+    ground_plane.get_set_test(0, "Default Material|Material Asset", ground_plane_material_asset)
+    # Work around to add the correct Atom Mesh component
+    mesh_type_id = azlmbr.globals.property.EditorMeshComponentTypeId
+    ground_plane.components.append(
+        editor.EditorComponentAPIBus(
+            bus.Broadcast, "AddComponentsOfType", ground_plane.id, [mesh_type_id]
+        ).GetValue()[0]
+    )
+    ground_plane_mesh_asset_path = os.path.join("Objects", "plane.azmodel")
+    ground_plane_mesh_asset = asset.AssetCatalogRequestBus(
+        bus.Broadcast, "GetAssetIdByPath", ground_plane_mesh_asset_path, math.Uuid(), False)
+    hydra.get_set_test(ground_plane, 1, "Controller|Configuration|Mesh Asset", ground_plane_mesh_asset)
+
+    # Create directional_light entity and set the properties
+    directional_light = hydra.Entity("directional_light")
+    directional_light.create_entity(
+        entity_position=math.Vector3(0.0, 0.0, 10.0),
+        components=["Directional Light"],
+        parent_id=default_level.id
+    )
+    rotation = math.Vector3(DEGREE_RADIAN_FACTOR * -90.0, 0.0, 0.0)
+    azlmbr.components.TransformBus(azlmbr.bus.Event, "SetLocalRotation", directional_light.id, rotation)
+
+    # Create sphere entity and set the properties
+    sphere = hydra.Entity("sphere")
+    sphere.create_entity(
+        entity_position=math.Vector3(0.0, 0.0, 1.0),
+        components=["Material"],
+        parent_id=default_level.id
+    )
+    sphere_material_asset_path = os.path.join("Materials", "Presets", "PBR", "metal_brass_polished.azmaterial")
+    sphere_material_asset = asset.AssetCatalogRequestBus(
+        bus.Broadcast, "GetAssetIdByPath", sphere_material_asset_path, math.Uuid(), False)
+    sphere.get_set_test(0, "Default Material|Material Asset", sphere_material_asset)
+    # Work around to add the correct Atom Mesh component
+    sphere.components.append(
+        editor.EditorComponentAPIBus(
+            bus.Broadcast, "AddComponentsOfType", sphere.id, [mesh_type_id]
+        ).GetValue()[0]
+    )
+    sphere_mesh_asset_path = os.path.join("Models", "sphere.azmodel")
+    sphere_mesh_asset = asset.AssetCatalogRequestBus(
+        bus.Broadcast, "GetAssetIdByPath", sphere_mesh_asset_path, math.Uuid(), False)
+    hydra.get_set_test(sphere, 1, "Controller|Configuration|Mesh Asset", sphere_mesh_asset)
+
+    # Create camera component and set the properties
+    camera_entity = hydra.Entity("camera")
+    position = math.Vector3(5.5, -12.0, 9.0)
+    camera_entity.create_entity(components=["Camera"], entity_position=position, parent_id=default_level.id)
+    rotation = math.Vector3(
+        DEGREE_RADIAN_FACTOR * -27.0, DEGREE_RADIAN_FACTOR * -12.0, DEGREE_RADIAN_FACTOR * 25.0
+    )
+    azlmbr.components.TransformBus(azlmbr.bus.Event, "SetLocalRotation", camera_entity.id, rotation)
+    camera_entity.get_set_test(0, "Controller|Configuration|Field of view", 60.0)
+    azlmbr.camera.EditorCameraViewRequestBus(azlmbr.bus.Event, "ToggleCameraAsActiveView", camera_entity.id)
+
+    # Save level, enter game mode, take screenshot, & exit game mode.
+    general.save_level()
+    general.idle_wait(0.5)
+    general.enter_game_mode()
+    general.idle_wait(1.0)
+    helper.wait_for_condition(function=lambda: general.is_in_game_mode(), timeout_in_seconds=2.0)
+    ScreenshotHelper(general.idle_wait_frames).capture_screenshot_blocking(f"{'AtomBasicLevelSetup'}.ppm")
+    general.exit_game_mode()
+    helper.wait_for_condition(function=lambda: not general.is_in_game_mode(), timeout_in_seconds=2.0)
+    general.log("Basic level created")
+
+
+if __name__ == "__main__":
+    run()

AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_GPUTest_LightComponent.py

@@ -0,0 +1,261 @@
+"""
+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
+"""
+import os
+import sys
+
+import azlmbr.asset as asset
+import azlmbr.bus as bus
+import azlmbr.editor as editor
+import azlmbr.math as math
+import azlmbr.paths
+import azlmbr.legacy.general as general
+
+sys.path.append(os.path.join(azlmbr.paths.devroot, "AutomatedTesting", "Gem", "PythonTests"))
+
+import editor_python_test_tools.hydra_editor_utils as hydra
+from Atom.atom_utils import atom_component_helper, atom_constants, screenshot_utils
+from editor_python_test_tools.editor_test_helper import EditorTestHelper
+
+helper = EditorTestHelper(log_prefix="Atom_EditorTestHelper")
+
+LEVEL_NAME = "auto_test"
+LIGHT_COMPONENT = "Light"
+LIGHT_TYPE_PROPERTY = 'Controller|Configuration|Light type'
+DEGREE_RADIAN_FACTOR = 0.0174533
+
+
+def run():
+    """
+    Sets up the tests by making sure the required level is created & setup correctly.
+    It then executes 2 test cases - see each associated test function's docstring for more info.
+
+    Finally prints the string "Light component tests completed" after completion
+
+    Tests will fail immediately if any of these log lines are found:
+    1. Trace::Assert
+    2. Trace::Error
+    3. Traceback (most recent call last):
+
+    :return: None
+    """
+    atom_component_helper.create_basic_atom_level(level_name=LEVEL_NAME)
+
+    # Run tests.
+    area_light_test()
+    spot_light_test()
+    general.log("Light component tests completed.")
+
+
+def area_light_test():
+    """
+    Basic test for the "Light" component attached to an "area_light" entity.
+
+    Test Case - Light Component: Capsule, Spot (disk), and Point (sphere):
+    1. Creates "area_light" entity w/ a Light component that has a Capsule Light type w/ the color set to 255, 0, 0
+    2. Enters game mode to take a screenshot for comparison, then exits game mode.
+    3. Sets the Light component Intensity Mode to Lumens (default).
+    4. Ensures the Light component Mode is Automatic (default).
+    5. Sets the Intensity value of the Light component to 0.0
+    6. Enters game mode again, takes another screenshot for comparison, then exits game mode.
+    7. Updates the Intensity value of the Light component to 1000.0
+    8. Enters game mode again, takes another screenshot for comparison, then exits game mode.
+    9. Swaps the Capsule light type option to Spot (disk) light type on the Light component
+    10. Updates "area_light" entity Transform rotate value to x: 90.0, y:0.0, z:0.0
+    11. Enters game mode again, takes another screenshot for comparison, then exits game mode.
+    12. Swaps the Spot (disk) light type for the Point (sphere) light type in the Light component.
+    13. Enters game mode again, takes another screenshot for comparison, then exits game mode.
+    14. Deletes the Light component from the "area_light" entity and verifies its successful.
+    """
+    # Create an "area_light" entity with "Light" component using Light type of "Capsule"
+    area_light_entity_name = "area_light"
+    area_light = hydra.Entity(area_light_entity_name)
+    area_light.create_entity(math.Vector3(-1.0, -2.0, 3.0), [LIGHT_COMPONENT])
+    general.log(
+        f"{area_light_entity_name}_test: Component added to the entity: "
+        f"{hydra.has_components(area_light.id, [LIGHT_COMPONENT])}")
+    light_component_id_pair = hydra.attach_component_to_entity(area_light.id, LIGHT_COMPONENT)
+
+    # Select the "Capsule" light type option.
+    azlmbr.editor.EditorComponentAPIBus(
+        azlmbr.bus.Broadcast,
+        'SetComponentProperty',
+        light_component_id_pair,
+        LIGHT_TYPE_PROPERTY,
+        atom_constants.LIGHT_TYPES['capsule']
+    )
+
+    # Update color and take screenshot in game mode
+    color = math.Color(255.0, 0.0, 0.0, 0.0)
+    area_light.get_set_test(0, "Controller|Configuration|Color", color)
+    general.idle_wait(1.0)
+    screenshot_utils.take_screenshot_game_mode("AreaLight_1", area_light_entity_name)
+
+    # Update intensity value to 0.0 and take screenshot in game mode
+    area_light.get_set_test(0, "Controller|Configuration|Attenuation Radius|Mode", 1)
+    area_light.get_set_test(0, "Controller|Configuration|Intensity", 0.0)
+    general.idle_wait(1.0)
+    screenshot_utils.take_screenshot_game_mode("AreaLight_2", area_light_entity_name)
+
+    # Update intensity value to 1000.0 and take screenshot in game mode
+    area_light.get_set_test(0, "Controller|Configuration|Intensity", 1000.0)
+    general.idle_wait(1.0)
+    screenshot_utils.take_screenshot_game_mode("AreaLight_3", area_light_entity_name)
+
+    # Swap the "Capsule" light type option to "Spot (disk)" light type
+    azlmbr.editor.EditorComponentAPIBus(
+        azlmbr.bus.Broadcast,
+        'SetComponentProperty',
+        light_component_id_pair,
+        LIGHT_TYPE_PROPERTY,
+        atom_constants.LIGHT_TYPES['spot_disk']
+    )
+    area_light_rotation = math.Vector3(DEGREE_RADIAN_FACTOR * 90.0, 0.0, 0.0)
+    azlmbr.components.TransformBus(azlmbr.bus.Event, "SetLocalRotation", area_light.id, area_light_rotation)
+    general.idle_wait(1.0)
+    screenshot_utils.take_screenshot_game_mode("AreaLight_4", area_light_entity_name)
+
+    # Swap the "Spot (disk)" light type to the "Point (sphere)" light type and take screenshot.
+    azlmbr.editor.EditorComponentAPIBus(
+        azlmbr.bus.Broadcast,
+        'SetComponentProperty',
+        light_component_id_pair,
+        LIGHT_TYPE_PROPERTY,
+        atom_constants.LIGHT_TYPES['sphere']
+    )
+    general.idle_wait(1.0)
+    screenshot_utils.take_screenshot_game_mode("AreaLight_5", area_light_entity_name)
+
+    editor.ToolsApplicationRequestBus(bus.Broadcast, "DeleteEntityById", area_light.id)
+
+
+def spot_light_test():
+    """
+    Basic test for the Light component attached to a "spot_light" entity.
+
+    Test Case - Light Component: Spot (disk) with shadows & colors:
+    1. Creates "spot_light" entity w/ a Light component attached to it.
+    2. Selects the "directional_light" entity already present in the level and disables it.
+    3. Selects the "global_skylight" entity already present in the level and disables the HDRi Skybox component,
+        as well as the Global Skylight (IBL) component.
+    4. Enters game mode to take a screenshot for comparison, then exits game mode.
+    5. Selects the "ground_plane" entity and changes updates the material to a new material.
+    6. Enters game mode to take a screenshot for comparison, then exits game mode.
+    7. Selects the "spot_light" entity and increases the Light component Intensity to 800 lm
+    8. Enters game mode to take a screenshot for comparison, then exits game mode.
+    9. Selects the "spot_light" entity and sets the Light component Color to 47, 75, 37
+    10. Enters game mode to take a screenshot for comparison, then exits game mode.
+    11. Selects the "spot_light" entity and modifies the Shutter controls to the following values:
+        - Enable shutters: True
+        - Inner Angle: 60.0
+        - Outer Angle: 75.0
+    12. Enters game mode to take a screenshot for comparison, then exits game mode.
+    13. Selects the "spot_light" entity and modifies the Shadow controls to the following values:
+        - Enable Shadow: True
+        - ShadowmapSize: 256
+    14. Modifies the world translate position of the "spot_light" entity to 0.7, -2.0, 1.9 (for casting shadows better)
+    15. Enters game mode to take a screenshot for comparison, then exits game mode.
+    """
+    # Disable "Directional Light" component for the "directional_light" entity
+    # "directional_light" entity is created by the create_basic_atom_level() function by default.
+    directional_light_entity_id = hydra.find_entity_by_name("directional_light")
+    directional_light = hydra.Entity(name='directional_light', id=directional_light_entity_id)
+    directional_light_component_type = azlmbr.editor.EditorComponentAPIBus(
+        azlmbr.bus.Broadcast, 'FindComponentTypeIdsByEntityType', ["Directional Light"], 0)[0]
+    directional_light_component = azlmbr.editor.EditorComponentAPIBus(
+        azlmbr.bus.Broadcast, 'GetComponentOfType', directional_light.id, directional_light_component_type
+    ).GetValue()
+    editor.EditorComponentAPIBus(bus.Broadcast, "DisableComponents", [directional_light_component])
+    general.idle_wait(0.5)
+
+    # Disable "Global Skylight (IBL)" and "HDRi Skybox" components for the "global_skylight" entity
+    global_skylight_entity_id = hydra.find_entity_by_name("global_skylight")
+    global_skylight = hydra.Entity(name='global_skylight', id=global_skylight_entity_id)
+    global_skylight_component_type = azlmbr.editor.EditorComponentAPIBus(
+        azlmbr.bus.Broadcast, 'FindComponentTypeIdsByEntityType', ["Global Skylight (IBL)"], 0)[0]
+    global_skylight_component = azlmbr.editor.EditorComponentAPIBus(
+        azlmbr.bus.Broadcast, 'GetComponentOfType', global_skylight.id, global_skylight_component_type
+    ).GetValue()
+    editor.EditorComponentAPIBus(bus.Broadcast, "DisableComponents", [global_skylight_component])
+    hdri_skybox_component_type = azlmbr.editor.EditorComponentAPIBus(
+        azlmbr.bus.Broadcast, 'FindComponentTypeIdsByEntityType', ["HDRi Skybox"], 0)[0]
+    hdri_skybox_component = azlmbr.editor.EditorComponentAPIBus(
+        azlmbr.bus.Broadcast, 'GetComponentOfType', global_skylight.id, hdri_skybox_component_type
+    ).GetValue()
+    editor.EditorComponentAPIBus(bus.Broadcast, "DisableComponents", [hdri_skybox_component])
+    general.idle_wait(0.5)
+
+    # Create a "spot_light" entity with "Light" component using Light Type of "Spot (disk)"
+    spot_light_entity_name = "spot_light"
+    spot_light = hydra.Entity(spot_light_entity_name)
+    spot_light.create_entity(math.Vector3(0.7, -2.0, 1.0), [LIGHT_COMPONENT])
+    general.log(
+        f"{spot_light_entity_name}_test: Component added to the entity: "
+        f"{hydra.has_components(spot_light.id, [LIGHT_COMPONENT])}")
+    rotation = math.Vector3(DEGREE_RADIAN_FACTOR * 300.0, 0.0, 0.0)
+    azlmbr.components.TransformBus(azlmbr.bus.Event, "SetLocalRotation", spot_light.id, rotation)
+    light_component_type = hydra.attach_component_to_entity(spot_light.id, LIGHT_COMPONENT)
+    editor.EditorComponentAPIBus(
+        azlmbr.bus.Broadcast,
+        'SetComponentProperty',
+        light_component_type,
+        LIGHT_TYPE_PROPERTY,
+        atom_constants.LIGHT_TYPES['spot_disk']
+    )
+
+    general.idle_wait(1.0)
+    screenshot_utils.take_screenshot_game_mode("SpotLight_1", spot_light_entity_name)
+
+    # Change default material of ground plane entity and take screenshot
+    ground_plane_entity_id = hydra.find_entity_by_name("ground_plane")
+    ground_plane = hydra.Entity(name='ground_plane', id=ground_plane_entity_id)
+    ground_plane_asset_path = os.path.join("Materials", "Presets", "MacBeth", "22_neutral_5-0_0-70d.azmaterial")
+    ground_plane_asset_value = asset.AssetCatalogRequestBus(
+        bus.Broadcast, "GetAssetIdByPath", ground_plane_asset_path, math.Uuid(), False)
+    material_property_path = "Default Material|Material Asset"
+    material_component_type = azlmbr.editor.EditorComponentAPIBus(
+        azlmbr.bus.Broadcast, 'FindComponentTypeIdsByEntityType', ["Material"], 0)[0]
+    material_component = azlmbr.editor.EditorComponentAPIBus(
+        azlmbr.bus.Broadcast, 'GetComponentOfType', ground_plane.id, material_component_type).GetValue()
+    editor.EditorComponentAPIBus(
+        azlmbr.bus.Broadcast,
+        'SetComponentProperty',
+        material_component,
+        material_property_path,
+        ground_plane_asset_value
+    )
+    general.idle_wait(1.0)
+    screenshot_utils.take_screenshot_game_mode("SpotLight_2", spot_light_entity_name)
+
+    # Increase intensity value of the Spot light and take screenshot in game mode
+    spot_light.get_set_test(0, "Controller|Configuration|Intensity", 800.0)
+    general.idle_wait(1.0)
+    screenshot_utils.take_screenshot_game_mode("SpotLight_3", spot_light_entity_name)
+
+    # Update the Spot light color and take screenshot in game mode
+    color_value = math.Color(47.0 / 255.0, 75.0 / 255.0, 37.0 / 255.0, 255.0 / 255.0)
+    spot_light.get_set_test(0, "Controller|Configuration|Color", color_value)
+    general.idle_wait(1.0)
+    screenshot_utils.take_screenshot_game_mode("SpotLight_4", spot_light_entity_name)
+
+    # Update the Shutter controls of the Light component and take screenshot
+    spot_light.get_set_test(0, "Controller|Configuration|Shutters|Enable shutters", True)
+    spot_light.get_set_test(0, "Controller|Configuration|Shutters|Inner angle", 60.0)
+    spot_light.get_set_test(0, "Controller|Configuration|Shutters|Outer angle", 75.0)
+    general.idle_wait(1.0)
+    screenshot_utils.take_screenshot_game_mode("SpotLight_5", spot_light_entity_name)
+
+    # Update the Shadow controls, move the spot_light entity world translate position and take screenshot
+    spot_light.get_set_test(0, "Controller|Configuration|Shadows|Enable shadow", True)
+    spot_light.get_set_test(0, "Controller|Configuration|Shadows|Shadowmap size", 256.0)
+    azlmbr.components.TransformBus(
+        azlmbr.bus.Event, "SetWorldTranslation", spot_light.id, math.Vector3(0.7, -2.0, 1.9))
+    general.idle_wait(1.0)
+    screenshot_utils.take_screenshot_game_mode("SpotLight_6", spot_light_entity_name)
+
+
+if __name__ == "__main__":
+    run()

AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_ShaderAssetBuilder_RecompilesShaderAsChainOfDependenciesChanges.py

@@ -0,0 +1,187 @@
+"""
+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
+"""
+
+# fmt: off
+class Tests():
+    azshader_was_removed =          ("azshader was removed",        "Failed to remove azshader")
+    azshader_was_compiled =         ("azshader was compiled",       "Failed to compile azshader")
+    no_error_occurred =             ("No errors detected",          "Errors were detected")
+# fmt: on
+
+
+def ShaderAssetBuilder_RecompilesShaderAsChainOfDependenciesChanges():
+    """
+    This test validates: "Shader Builders May Fail When Multiple New Files Are Added"
+    It creates source assets to compile a particular shader.
+    1- The first phase generates the source assets out of order and slowly. The AP should
+       wakeup each time one of the source dependencies appears but will fail each time. Only when the
+       last dependency appears then the shader should build successfully. 
+    2- The second phase is similar as above, except that all source assets will be created
+       at once and We also expect that in the end the shader is built successfully.
+    """
+    import os
+    import shutil
+
+    import azlmbr.asset as azasset
+    import azlmbr.bus as azbus
+    import azlmbr.legacy.general as general
+    import azlmbr.math as azmath
+
+    from editor_python_test_tools.utils import TestHelper as helper
+    from editor_python_test_tools.utils import Tracer
+    import ly_test_tools.environment.file_system as fs
+
+    def _copy_file(src_file, src_path, target_file, target_path):
+        # type: (str, str, str, str) -> None
+        """
+        Copies the [src_file] located in [src_path] to the [target_file] located at [target_path].
+        Leaves the [target_file] unlocked for reading and writing privileges
+        :param src_file: The source file to copy (file name)
+        :param src_path: The source file's path
+        :param target_file: The target file to copy into (file name)
+        :param target_path: The target file's path
+        :return: None
+        """
+        target_file_path = os.path.join(target_path, target_file)
+        src_file_path = os.path.join(src_path, src_file)
+        if os.path.exists(target_file_path):
+            fs.unlock_file(target_file_path)
+        shutil.copyfile(src_file_path, target_file_path)
+
+    def _copy_tmp_files_in_order(src_directory, file_list, dst_directory, wait_time_in_between=0.0):
+        # type: (str, list, str, float) -> None
+        """
+        This function assumes that for each file name listed in @file_list
+        there's file named "@filename.txt" which the original source file
+        but they will be copied with just the @filename (.txt removed).
+        """
+        for filename in file_list:
+            src_name = f"{filename}.txt"
+            _copy_file(src_name, src_directory, filename, dst_directory)
+            if wait_time_in_between > 0.0:
+                print(f"Created {filename} in {dst_directory}")
+                general.idle_wait(wait_time_in_between)
+
+    def _remove_file(src_file, src_path):
+        # type: (str, str) -> None
+        """
+        Removes the [src_file] located in [src_path].
+        :param src_file: The source file to copy (file name)
+        :param src_path: The source file's path
+        :return: None
+        """
+        src_file_path = os.path.join(src_path, src_file)
+        if os.path.exists(src_file_path):
+            fs.unlock_file(src_file_path)
+            os.remove(src_file_path)
+
+    def _remove_files(directory, file_list):
+        for filename in file_list:
+            _remove_file(filename, directory)
+
+    def _asset_exists(cache_relative_path):
+        asset_id = azasset.AssetCatalogRequestBus(azbus.Broadcast, "GetAssetIdByPath", cache_relative_path,
+                                                  azmath.Uuid(), False)
+        return asset_id.is_valid()
+
+    # Required for automated tests
+    helper.init_idle()
+
+    game_root_path = os.path.normpath(general.get_game_folder())
+    game_asset_path = os.path.join(game_root_path, "Assets")
+
+    base_dir = os.path.dirname(__file__)
+    src_assets_subdir = os.path.join(base_dir, "TestAssets", "ShaderAssetBuilder") 
+
+    with Tracer() as error_tracer:
+        # The script drives the execution of the test, to return the flow back to the editor,
+        # we will tick it one time
+        general.idle_wait_frames(1)
+ 
+        # This is the order in which the source assets should be deployed
+        # to avoid source dependency issues with the old MCPP-based CreateJobs. 
+        file_list = [
+            "Test2Color.azsli",
+            "Test3Color.azsli",
+            "Test1Color.azsli",
+            "DependencyValidation.azsl",
+            "DependencyValidation.shader"
+        ]
+
+        reverse_file_list = file_list[::-1]
+
+        # Remove files in reverse order
+        _remove_files(game_asset_path, reverse_file_list)
+
+        # Wait here until the azshader doesn't exist anymore.
+        azshader_name = "assets/dependencyvalidation.azshader"
+        helper.wait_for_condition(lambda: not _asset_exists(azshader_name), 5.0)
+
+        Report.critical_result(Tests.azshader_was_removed, not _asset_exists(azshader_name))
+
+        _copy_tmp_files_in_order(src_assets_subdir, file_list, game_asset_path, 1.0)
+
+        # Give enough time to AP to compile the shader
+        helper.wait_for_condition(lambda: _asset_exists(azshader_name), 60.0)
+
+        Report.critical_result(Tests.azshader_was_compiled, _asset_exists(azshader_name))
+
+        # The first part was about compiling the shader under normal conditions.
+        # Let's remove the files from the previous phase and will proceed
+        # to make the source files visible to the AP in reverse order. The
+        # ShaderAssetBuilder will only succeed when the last file becomes visible.
+        _remove_files(game_asset_path, reverse_file_list)
+        helper.wait_for_condition(lambda: not _asset_exists(azshader_name), 5.0)
+        Report.critical_result(Tests.azshader_was_removed, not _asset_exists(azshader_name))
+
+        # Remark, if you are running this test manually from the Editor with "pyRunFile",
+        # You'll notice how the AP issues notifications that it fails to compile the shader
+        # as the source files are being copied to the "Assets" subfolder.
+        # Those errors are OK and also expected because We need the AP to wake up as each
+        # reported source dependency exists. Once the last file is copied then all source
+        # dependencies are fully satisfied and the shader should compile successfully.
+        # And this summarizes the importance of this Test: The previous version
+        # of ShaderAssetBuilder::CreateJobs was incapable of compiling the shader under the conditions
+        # presented in this test, but with the new version of ShaderAssetBuilder::CreateJobs, which
+        # doesn't use MCPP for #include files discovery, it should eventually compile the shader
+        # once all the source files are in place.
+        _copy_tmp_files_in_order(src_assets_subdir, reverse_file_list, game_asset_path, 3.0)
+
+        # Give enough time to AP to compile the shader
+        helper.wait_for_condition(lambda: _asset_exists(azshader_name), 60.0)
+
+        Report.critical_result(Tests.azshader_was_compiled, _asset_exists(azshader_name))
+
+        # The last phase of the test puts stress on potential race conditions
+        # when all required files appear as soon as possible.
+
+        # First Clean up.
+        # Remove left over files.
+        _remove_files(game_asset_path, reverse_file_list)
+        helper.wait_for_condition(lambda: not _asset_exists(azshader_name), 5.0)
+        Report.critical_result(Tests.azshader_was_removed, not _asset_exists(azshader_name))
+
+        # Now let's copy all the source files to the "Assets" folder as fast as possible.
+        _copy_tmp_files_in_order(src_assets_subdir, reverse_file_list, game_asset_path)
+
+        # Give enough time to AP to compile the shader
+        helper.wait_for_condition(lambda: _asset_exists(azshader_name), 60.0)
+
+        Report.critical_result(Tests.azshader_was_compiled, _asset_exists(azshader_name))
+
+        # All good, let's cleanup leftover files before closing the test.
+        _remove_files(game_asset_path, reverse_file_list)
+        helper.wait_for_condition(lambda: not _asset_exists(azshader_name), 5.0)
+
+        # Look for errors to raise.
+        helper.wait_for_condition(lambda: error_tracer.has_errors, 1.0)
+        Report.result(Tests.no_error_occurred, not error_tracer.has_errors)
+
+
+if __name__ == "__main__":
+    from editor_python_test_tools.utils import Report
+    Report.start_test(ShaderAssetBuilder_RecompilesShaderAsChainOfDependenciesChanges)