Merge branch 'main' into ftue_auto_register

AutomatedTesting/Gem/PythonTests/PythonAssetBuilder/AssetBuilder_test.py

@@ -31,13 +31,13 @@ class TestPythonAssetProcessing(object):
         unexpected_lines = []
         expected_lines = [
             'Mock asset exists',
-            'Expected subId for asset (gem/pythontests/pythonassetbuilder/geom_group_fbx_cube_100cm_z_positive_1.azmodel) found',
-            'Expected subId for asset (gem/pythontests/pythonassetbuilder/geom_group_fbx_cube_100cm_z_negative_1.azmodel) found',
-            'Expected subId for asset (gem/pythontests/pythonassetbuilder/geom_group_fbx_cube_100cm_y_positive_1.azmodel) found',
-            'Expected subId for asset (gem/pythontests/pythonassetbuilder/geom_group_fbx_cube_100cm_y_negative_1.azmodel) found',
-            'Expected subId for asset (gem/pythontests/pythonassetbuilder/geom_group_fbx_cube_100cm_x_positive_1.azmodel) found',
-            'Expected subId for asset (gem/pythontests/pythonassetbuilder/geom_group_fbx_cube_100cm_x_negative_1.azmodel) found',
-            'Expected subId for asset (gem/pythontests/pythonassetbuilder/geom_group_fbx_cube_100cm_center_1.azmodel) found'
+            'Expected subId for asset (gem/pythontests/pythonassetbuilder/geom_group_fbx_cube_100cm_z_positive.azmodel) found',
+            'Expected subId for asset (gem/pythontests/pythonassetbuilder/geom_group_fbx_cube_100cm_z_negative.azmodel) found',
+            'Expected subId for asset (gem/pythontests/pythonassetbuilder/geom_group_fbx_cube_100cm_y_positive.azmodel) found',
+            'Expected subId for asset (gem/pythontests/pythonassetbuilder/geom_group_fbx_cube_100cm_y_negative.azmodel) found',
+            'Expected subId for asset (gem/pythontests/pythonassetbuilder/geom_group_fbx_cube_100cm_x_positive.azmodel) found',
+            'Expected subId for asset (gem/pythontests/pythonassetbuilder/geom_group_fbx_cube_100cm_x_negative.azmodel) found',
+            'Expected subId for asset (gem/pythontests/pythonassetbuilder/geom_group_fbx_cube_100cm_center.azmodel) found'
         ]
         timeout = 180
         halt_on_unexpected = False

AutomatedTesting/Gem/PythonTests/PythonAssetBuilder/AssetBuilder_test_case.py

@@ -38,16 +38,16 @@ def test_azmodel_product(generatedModelAssetPath, expectedSubId):
     assetId = azlmbr.asset.AssetCatalogRequestBus(azlmbr.bus.Broadcast, 'GetAssetIdByPath', generatedModelAssetPath, azModelAssetType, False)
     assetIdString = assetId.to_string()
     if (assetIdString.endswith(':' + expectedSubId) is False):
-        raise_and_stop(f'Asset has unexpected asset ID ({assetIdString}) for ({generatedModelAssetPath})!')
+        raise_and_stop(f'Asset at path {generatedModelAssetPath} has unexpected asset ID ({assetIdString}) for ({generatedModelAssetPath}), expected {expectedSubId}!')
     else:
         print(f'Expected subId for asset ({generatedModelAssetPath}) found')
 
-test_azmodel_product('gem/pythontests/pythonassetbuilder/geom_group_fbx_cube_100cm_z_positive_1.azmodel', '10315ae0')
-test_azmodel_product('gem/pythontests/pythonassetbuilder/geom_group_fbx_cube_100cm_z_negative_1.azmodel', '10661093')
-test_azmodel_product('gem/pythontests/pythonassetbuilder/geom_group_fbx_cube_100cm_y_positive_1.azmodel', '10af8810')
-test_azmodel_product('gem/pythontests/pythonassetbuilder/geom_group_fbx_cube_100cm_y_negative_1.azmodel', '10f8c263')
-test_azmodel_product('gem/pythontests/pythonassetbuilder/geom_group_fbx_cube_100cm_x_positive_1.azmodel', '100ac47f')
-test_azmodel_product('gem/pythontests/pythonassetbuilder/geom_group_fbx_cube_100cm_x_negative_1.azmodel', '105d8e0c')
-test_azmodel_product('gem/pythontests/pythonassetbuilder/geom_group_fbx_cube_100cm_center_1.azmodel', '1002d464')
+test_azmodel_product('gem/pythontests/pythonassetbuilder/geom_group_fbx_cube_100cm_z_positive.azmodel', '1024be55')
+test_azmodel_product('gem/pythontests/pythonassetbuilder/geom_group_fbx_cube_100cm_z_negative.azmodel', '1052c94e')
+test_azmodel_product('gem/pythontests/pythonassetbuilder/geom_group_fbx_cube_100cm_y_positive.azmodel', '10130556')
+test_azmodel_product('gem/pythontests/pythonassetbuilder/geom_group_fbx_cube_100cm_y_negative.azmodel', '1065724d')
+test_azmodel_product('gem/pythontests/pythonassetbuilder/geom_group_fbx_cube_100cm_x_positive.azmodel', '10d16e68')
+test_azmodel_product('gem/pythontests/pythonassetbuilder/geom_group_fbx_cube_100cm_x_negative.azmodel', '10a71973')
+test_azmodel_product('gem/pythontests/pythonassetbuilder/geom_group_fbx_cube_100cm_center.azmodel', '10412075')
 
 azlmbr.editor.EditorToolsApplicationRequestBus(azlmbr.bus.Broadcast, 'ExitNoPrompt')

AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SurfaceMaskFilter_BasicSurfaceTagCreation.py

@@ -23,6 +23,25 @@ class TestSurfaceMaskFilter_BasicSurfaceTagCreation(EditorTestHelper):
         EditorTestHelper.__init__(self, log_prefix="TestSurfaceMaskFilter_BasicSurfaceTagCreation", args=["level"])
         
     def run_test(self):
+        """
+        Summary:
+        Verifies basic surface tag value equality
+
+        Expected Behavior:
+        Surface tags of the same name are equal, and different names aren't.
+
+        Test Steps:
+         1) Open level
+         2) Create 2 new surface tags of identical names and verify they resolve as equal.
+         3) Create another new tag of a different name and verify they resolve as different.
+
+        Note:
+        - This test file must be called from the Open 3D Engine Editor command terminal
+        - Any passed and failed tests are written to the Editor.log file.
+                Parsing the file or running a log_monitor are required to observe the test results.
+
+        :return: None
+        """
         self.log("SurfaceTag test started")
         
         # Create a level

AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/VegetationInstances_DespawnWhenOutOfRange.py

@@ -33,6 +33,25 @@ class TestVegetationInstances_DespawnWhenOutOfRange(EditorTestHelper):
         EditorTestHelper.__init__(self, log_prefix='VegetationInstances_DespawnWhenOutOfRange', args=['level'])
 
     def run_test(self):
+        """
+        Summary:
+        Verifies that vegetation instances properly spawn/despawn based on camera range.
+
+        Expected Behavior:
+        Vegetation instances despawn when out of camera range.
+
+        Test Steps:
+         1) Create a new level
+         2) Create a simple vegetation area, and set the view position near the spawner. Verify instances plant.
+         3) Move the view position away from the spawner. Verify instances despawn.
+
+        Note:
+        - This test file must be called from the Open 3D Engine Editor command terminal
+        - Any passed and failed tests are written to the Editor.log file.
+                Parsing the file or running a log_monitor are required to observe the test results.
+
+        :return: None
+        """
 
         # Create a new level
         self.test_success = self.create_level(

AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientGenerators_Incompatibilities.py

@@ -28,8 +28,21 @@ class TestGradientGeneratorIncompatibilities(EditorTestHelper):
     def run_test(self):
         """
         Summary:
-        Verify that Entities are not active when a Gradient Generator and incompatible component are both present
-        on the same Entity.
+        This test verifies that components are disabled when conflicting components are present on the same entity.
+
+        Expected Behavior:
+        Gradient Generator components are incompatible with Vegetation area components.
+
+        Test Steps:
+         1) Create a new level
+         2) Create a new entity in the level
+         3) Add each Gradient Generator component to an entity, and add a Vegetation Area component to the same entity
+         4) Verify that components are only enabled when entity is free of a conflicting component
+
+        Note:
+        - This test file must be called from the Open 3D Engine Editor command terminal
+        - Any passed and failed tests are written to the Editor.log file.
+                Parsing the file or running a log_monitor are required to observe the test results.
 
         :return: None
         """

AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientModifiers_Incompatibilities.py

@@ -28,8 +28,21 @@ class TestGradientModifiersIncompatibilities(EditorTestHelper):
     def run_test(self):
         """
         Summary:
-        Verify that Entities are not active when a Gradient Modifier and incompatible component are both present
-        on the same Entity.
+        This test verifies that components are disabled when conflicting components are present on the same entity.
+
+        Expected Behavior:
+        Gradient Modifier components are incompatible with Vegetation area components.
+
+        Test Steps:
+         1) Create a new level
+         2) Create a new entity in the level
+         3) Add each Gradient Modifier component to an entity, and add a Vegetation Area component to the same entity
+         4) Verify that components are only enabled when entity is free of a conflicting component
+
+        Note:
+        - This test file must be called from the Open 3D Engine Editor command terminal
+        - Any passed and failed tests are written to the Editor.log file.
+                Parsing the file or running a log_monitor are required to observe the test results.
 
         :return: None
         """

AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientPreviewSettings_ClearingPinnedEntitySetsPreviewToOrigin.py

@@ -9,19 +9,6 @@ remove or modify any license notices. This file is distributed on an "AS IS" BAS
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 """
 
-"""
-The below cases are combined in this script
-C2676829
-C3961326
-C3980659
-C3980664
-C3980669
-C3416548
-C2676823
-C3961321
-C2676826
-"""
-
 import os
 import sys
 

AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientPreviewSettings_DefaultPinnedEntityIsSelf.py

@@ -44,7 +44,21 @@ class TestGradientPreviewSettings(EditorTestHelper):
     def run_test(self):
         """
         Summary:
-        Verify if the current entity is set to the pin preview to shape entity by default for several components.
+        This test verifies default values for the pinned entity for Gradient Preview settings.
+
+        Expected Behavior:
+        Pinned entity is self for all gradient generator/modifiers.
+
+        Test Steps:
+         1) Create a new level
+         2) Create a new entity in the level
+         3) Add each Gradient Generator component to an entity, and verify the Pin Preview to Shape property is set to
+         self
+
+        Note:
+        - This test file must be called from the Open 3D Engine Editor command terminal
+        - Any passed and failed tests are written to the Editor.log file.
+                Parsing the file or running a log_monitor are required to observe the test results.
 
         :return: None
         """

AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientSurfaceTagEmitter_ComponentDependencies.py

@@ -31,11 +31,21 @@ class TestGradientSurfaceTagEmitterDependencies(EditorTestHelper):
     def run_test(self):
         """
         Summary:
-        Component has a dependency on a Gradient component
+        This test verifies that the Gradient Surface Tag Emitter component is dependent on a gradient component.
 
         Expected Result:
-        Component is disabled until a Gradient Generator, Modifier or Gradient Reference component
-        (and any sub-dependencies) is added to the entity.
+        Gradient Surface Tag Emitter component is disabled until a Gradient Generator, Modifier or Gradient Reference
+        component (and any sub-dependencies) is added to the entity.
+
+        Test Steps:
+         1) Open level
+         2) Create a new entity with a Gradient Surface Tag Emitter component
+         3) Verify the component is disabled until a dependent component is also added to the entity
+
+        Note:
+        - This test file must be called from the Open 3D Engine Editor command terminal
+        - Any passed and failed tests are written to the Editor.log file.
+                Parsing the file or running a log_monitor are required to observe the test results.
 
         :return: None
         """

AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientTransform_RequiresShape.py

@@ -28,8 +28,20 @@ class TestGradientTransformRequiresShape(EditorTestHelper):
     def run_test(self):
         """
         Summary:
-        Verify that Gradient Transform Modifier component requires a
-        Shape component before the Entity can become active.
+        This test verifies that the Gradient Transform Modifier component is dependent on a shape component.
+
+        Expected Result:
+        Gradient Transform Modifier component is disabled until a shape component is added to the entity.
+
+        Test Steps:
+         1) Open level
+         2) Create a new entity with a Gradient Transform Modifier component
+         3) Verify the component is disabled until a shape component is also added to the entity
+
+        Note:
+        - This test file must be called from the Open 3D Engine Editor command terminal
+        - Any passed and failed tests are written to the Editor.log file.
+                Parsing the file or running a log_monitor are required to observe the test results.
 
         :return: None
         """

AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/ImageGradient_RequiresShape.py

@@ -28,8 +28,20 @@ class TestImageGradientRequiresShape(EditorTestHelper):
     def run_test(self):
         """
         Summary:
-        Verify that Image Gradient component requires a
-        Shape component before the Entity can become active.
+        This test verifies that the Image Gradient component is dependent on a shape component.
+
+        Expected Result:
+        Gradient Transform Modifier component is disabled until a shape component is added to the entity.
+
+        Test Steps:
+         1) Open level
+         2) Create a new entity with a Image Gradient component
+         3) Verify the component is disabled until a shape component is also added to the entity
+
+        Note:
+        - This test file must be called from the Open 3D Engine Editor command terminal
+        - Any passed and failed tests are written to the Editor.log file.
+                Parsing the file or running a log_monitor are required to observe the test results.
 
         :return: None
         """

AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/AreaNodes_DependentComponentsAdded.py

@@ -33,6 +33,26 @@ class TestAreaNodeComponentDependency(EditorTestHelper):
         EditorTestHelper.__init__(self, log_prefix="AreaNodeComponentDependency", args=["level"])
 
     def run_test(self):
+        """
+        Summary:
+        This test verifies that the Landscape Canvas nodes can be added to a graph, and correctly create entities with
+        proper dependent components.
+
+        Expected Behavior:
+        All expected component dependencies are met when adding an area node to a graph.
+
+        Test Steps:
+         1) Create a new level
+         2) Open Landscape Canvas and create a new graph
+         3) Drag each of the area nodes to the graph area, and ensure the proper dependent components are added
+
+        Note:
+        - This test file must be called from the Open 3D Engine Editor command terminal
+        - Any passed and failed tests are written to the Editor.log file.
+                Parsing the file or running a log_monitor are required to observe the test results.
+
+        :return: None
+        """
 
         def onEntityCreated(parameters):
             global newEntityId

AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/AreaNodes_EntityCreatedOnNodeAdd.py

@@ -33,7 +33,25 @@ class TestGradientNodeEntityCreate(EditorTestHelper):
         EditorTestHelper.__init__(self, log_prefix="AreaNodeEntityCreate", args=["level"])
 
     def run_test(self):
+        """
+        Summary:
+        This test verifies that the Landscape Canvas nodes can be added to a graph, and correctly create entities.
 
+        Expected Behavior:
+        New entities are created when dragging area nodes to graph area.
+
+        Test Steps:
+         1) Create a new level
+         2) Open Landscape Canvas and create a new graph
+         3) Drag each of the area nodes to the graph area, and ensure a new entity is created
+
+        Note:
+        - This test file must be called from the Open 3D Engine Editor command terminal
+        - Any passed and failed tests are written to the Editor.log file.
+                Parsing the file or running a log_monitor are required to observe the test results.
+
+        :return: None
+        """
         def onEntityCreated(parameters):
             global newEntityId
             newEntityId = parameters[0]

AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/AreaNodes_EntityRemovedOnNodeDelete.py

@@ -34,7 +34,26 @@ class TestAreaNodeEntityDelete(EditorTestHelper):
         EditorTestHelper.__init__(self, log_prefix="AreaNodeEntityDelete", args=["level"])
 
     def run_test(self):
+        """
+        Summary:
+        This test verifies that the Landscape Canvas node deletion properly cleans up entities in the Editor.
 
+        Expected Behavior:
+        Entities are removed when area nodes are deleted from a graph.
+
+        Test Steps:
+         1) Create a new level
+         2) Open Landscape Canvas and create a new graph
+         3) Drag each of the area nodes to the graph area, and ensure a new entity is created
+         4) Delete the nodes, and ensure the newly created entities are removed
+
+        Note:
+        - This test file must be called from the Open 3D Engine Editor command terminal
+        - Any passed and failed tests are written to the Editor.log file.
+                Parsing the file or running a log_monitor are required to observe the test results.
+
+        :return: None
+        """
         def onEntityCreated(parameters):
             global createdEntityId
             createdEntityId = parameters[0]

AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/ComponentUpdates_UpdateGraph.py

@@ -9,24 +9,6 @@ remove or modify any license notices. This file is distributed on an "AS IS" BAS
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 """
 
-
-"""
-C22602072 - Graph is updated when underlying components are added/removed
-
-1. Open Level.
-2. Find LandscapeCanvas named entity.
-3. Ensure Vegetation Distribution Component is present on the BushSpawner entity.
-4. Open graph and ensure Distribution Filter wrapped node is present.
-5. Delete the Vegetation Distribution Filter component from the BushSpawner entity via Entity Inspector.
-6. Ensure the Vegetation Distribution Filter component was deleted from the BushSpawner entity and node is no longer 
-present in the graph.
-7. Add Vegetation Altitude Filter to the BushSpawner entity through Entity Inspector.
-8. Ensure Altitude Filter was added to the BushSpawner node in the open graph.
-9. Add a new entity with unique name as a child of the Landscape Canvas entity.
-10. Add a Box Shape component to the new child entity.
-11. Ensure Box Shape node is present on the open graph.
-"""
-
 import os
 import sys
 
@@ -50,6 +32,36 @@ class TestComponentUpdatesUpdateGraph(EditorTestHelper):
         EditorTestHelper.__init__(self, log_prefix="ComponentUpdatesUpdateGraph", args=["level"])
 
     def run_test(self):
+        """
+        Summary:
+        This test verifies that the Landscape Canvas graphs update properly when components are added/removed outside of
+        Landscape Canvas.
+
+        Expected Behavior:
+        Graphs properly reflect component changes made to entities outside of Landscape Canvas.
+
+        Test Steps:
+            1. Open Level
+            2. Find LandscapeCanvas named entity
+            3. Ensure Vegetation Distribution Component is present on the BushSpawner entity
+            4. Open graph and ensure Distribution Filter wrapped node is present
+            5. Delete the Vegetation Distribution Filter component from the BushSpawner entity via Entity Inspector
+            6. Ensure the Vegetation Distribution Filter component was deleted from the BushSpawner entity and node is
+            no longer present in the graph
+            7. Add Vegetation Altitude Filter to the BushSpawner entity through Entity Inspector
+            8. Ensure Altitude Filter was added to the BushSpawner node in the open graph
+            9. Add a new entity with unique name as a child of the Landscape Canvas entity
+            10. Add a Box Shape component to the new child entity
+            11. Ensure Box Shape node is present on the open graph
+
+        Note:
+        - This test file must be called from the Open 3D Engine Editor command terminal
+        - Any passed and failed tests are written to the Editor.log file.
+                Parsing the file or running a log_monitor are required to observe the test results.
+
+        :return: None
+        """
+
         # Create a new empty level and instantiate LC_BushFlowerBlender.slice
         self.test_success = self.create_level(
             self.args["level"],

AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/CreateNewGraph.py

@@ -37,6 +37,25 @@ class TestCreateNewGraph(EditorTestHelper):
         print("New root entity created")
 
     def run_test(self):
+        """
+        Summary:
+        This test verifies that new graphs can be created in Landscape Canvas.
+
+        Expected Behavior:
+        New graphs can be created, and proper entity is created to hold graph data with a Landscape Canvas component.
+
+        Test Steps:
+         1) Create a new level
+         2) Open Landscape Canvas and create a new graph
+         3) Ensures the root entity created contains a Landscape Canvas component
+
+        Note:
+        - This test file must be called from the Open 3D Engine Editor command terminal
+        - Any passed and failed tests are written to the Editor.log file.
+                Parsing the file or running a log_monitor are required to observe the test results.
+
+        :return: None
+        """
         self.test_success = self.create_level(
             self.args["level"],
             heightmap_resolution=128,

AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/Edit_DisabledNodeDuplication.py

@@ -33,7 +33,25 @@ class TestDisabledNodeDuplication(EditorTestHelper):
         EditorTestHelper.__init__(self, log_prefix="DisabledNodeDuplication", args=["level"])
 
     def run_test(self):
+        """
+        Summary:
+        This test verifies Editor stability after duplicating disabled Landscape Canvas nodes.
 
+        Expected Behavior:
+        Editor remains stable and free of crashes.
+
+        Test Steps:
+         1) Create a new level
+         2) Open Landscape Canvas and create a new graph
+         3) Create several new nodes, disable the nodes via disabling/deleting components, and duplicate the nodes
+
+        Note:
+        - This test file must be called from the Open 3D Engine Editor command terminal
+        - Any passed and failed tests are written to the Editor.log file.
+                Parsing the file or running a log_monitor are required to observe the test results.
+
+        :return: None
+        """
         def onEntityCreated(parameters):
             global newEntityId
             newEntityId = parameters[0]

AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/Edit_UndoNodeDelete_SliceEntity.py

@@ -9,17 +9,6 @@ remove or modify any license notices. This file is distributed on an "AS IS" BAS
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 """
 
-
-"""
-C30813586 - Editor remains stable after Undoing deletion of a node on a slice entity
-
-1. Open level with instantiated slice.
-2. Open the graph.
-3. Find the BushSpawner's Vegetation Layer Spawner node.
-4. Delete the node.
-5. Undo to restore the node.
-"""
-
 import os
 import sys
 
@@ -44,7 +33,26 @@ class TestUndoNodeDeleteSlice(EditorTestHelper):
         EditorTestHelper.__init__(self, log_prefix="UndoNodeDeleteSlice", args=["level"])
 
     def run_test(self):
+        """
+        Summary:
+        This test verifies Editor stability after undoing the deletion of nodes on a slice entity.
 
+        Expected Behavior:
+        Editor remains stable and free of crashes.
+
+        Test Steps:
+         1) Create a new level
+         2) Instantiate a slice with a Landscape Canvas setup
+         3) Find a specific node on the graph, and delete it
+         4) Restore the node with Undo
+
+        Note:
+        - This test file must be called from the Open 3D Engine Editor command terminal
+        - Any passed and failed tests are written to the Editor.log file.
+                Parsing the file or running a log_monitor are required to observe the test results.
+
+        :return: None
+        """
         # Create a new empty level and instantiate LC_BushFlowerBlender.slice
         self.test_success = self.create_level(
             self.args["level"],

AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientMixer_NodeConstruction.py

@@ -34,6 +34,27 @@ class TestGradientMixerNodeConstruction(EditorTestHelper):
         EditorTestHelper.__init__(self, log_prefix="GradientMixerNodeConstruction", args=["level"])
 
     def run_test(self):
+        """
+        Summary:
+        This test verifies a Gradient Mixer vegetation setup can be constructed through Landscape Canvas.
+
+        Expected Behavior:
+        Entities contain all required components and component references after creating nodes and setting connections
+        on a Landscape Canvas graph.
+
+        Test Steps:
+         1) Create a new level
+         2) Open Landscape Canvas and create a new graph
+         3) Add all necessary nodes to the graph and set connections to form a Gradient Mixer setup
+         4) Verify all components and component references were properly set during graph construction
+
+        Note:
+        - This test file must be called from the Open 3D Engine Editor command terminal
+        - Any passed and failed tests are written to the Editor.log file.
+                Parsing the file or running a log_monitor are required to observe the test results.
+
+        :return: None
+        """
 
         def onEntityCreated(parameters):
             global newEntityId

AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientModifierNodes_EntityCreatedOnNodeAdd.py

@@ -33,6 +33,25 @@ class TestGradientModifierNodeEntityCreate(EditorTestHelper):
         EditorTestHelper.__init__(self, log_prefix="GradientModifierNodeEntityCreate", args=["level"])
 
     def run_test(self):
+        """
+        Summary:
+        This test verifies that the Landscape Canvas nodes can be added to a graph, and correctly create entities.
+
+        Expected Behavior:
+        New entities are created when dragging Gradient Modifier nodes to graph area.
+
+        Test Steps:
+         1) Create a new level
+         2) Open Landscape Canvas and create a new graph
+         3) Drag each of the Gradient Modifier nodes to the graph area, and ensure a new entity is created
+
+        Note:
+        - This test file must be called from the Open 3D Engine Editor command terminal
+        - Any passed and failed tests are written to the Editor.log file.
+                Parsing the file or running a log_monitor are required to observe the test results.
+
+        :return: None
+        """
 
         def onEntityCreated(parameters):
             global newEntityId

AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientModifierNodes_EntityRemovedOnNodeDelete.py

@@ -34,7 +34,26 @@ class TestGradientModifierNodeEntityDelete(EditorTestHelper):
         EditorTestHelper.__init__(self, log_prefix="GradientModifierNodeEntityDelete", args=["level"])
 
     def run_test(self):
+        """
+        Summary:
+        This test verifies that the Landscape Canvas node deletion properly cleans up entities in the Editor.
 
+        Expected Behavior:
+        Entities are removed when Gradient Modifier nodes are deleted from a graph.
+
+        Test Steps:
+         1) Create a new level
+         2) Open Landscape Canvas and create a new graph
+         3) Drag each of the Gradient Modifier nodes to the graph area, and ensure a new entity is created
+         4) Delete the nodes, and ensure the newly created entities are removed
+
+        Note:
+        - This test file must be called from the Open 3D Engine Editor command terminal
+        - Any passed and failed tests are written to the Editor.log file.
+                Parsing the file or running a log_monitor are required to observe the test results.
+
+        :return: None
+        """
         def onEntityCreated(parameters):
             global createdEntityId
             createdEntityId = parameters[0]

AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientNodes_DependentComponentsAdded.py

@@ -33,6 +33,27 @@ class TestGradientNodeComponentDependency(EditorTestHelper):
         EditorTestHelper.__init__(self, log_prefix="GradientNodeComponentDependency", args=["level"])
 
     def run_test(self):
+        """
+        Summary:
+        This test verifies that the Landscape Canvas nodes can be added to a graph, and correctly create entities with
+        proper dependent components.
+
+        Expected Behavior:
+        All expected component dependencies are met when adding a Gradient Modifier node to a graph.
+
+        Test Steps:
+         1) Create a new level
+         2) Open Landscape Canvas and create a new graph
+         3) Drag each of the Gradient Modifier nodes to the graph area, and ensure the proper dependent components are
+         added
+
+        Note:
+        - This test file must be called from the Open 3D Engine Editor command terminal
+        - Any passed and failed tests are written to the Editor.log file.
+                Parsing the file or running a log_monitor are required to observe the test results.
+
+        :return: None
+        """
 
         def onEntityCreated(parameters):
             global newEntityId

AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientNodes_EntityCreatedOnNodeAdd.py

@@ -32,6 +32,25 @@ class TestGradientNodeEntityCreate(EditorTestHelper):
         EditorTestHelper.__init__(self, log_prefix="GradientNodeEntityCreate", args=["level"])
 
     def run_test(self):
+        """
+        Summary:
+        This test verifies that the Landscape Canvas nodes can be added to a graph, and correctly create entities.
+
+        Expected Behavior:
+        New entities are created when dragging Gradient nodes to graph area.
+
+        Test Steps:
+         1) Create a new level
+         2) Open Landscape Canvas and create a new graph
+         3) Drag each of the Gradient nodes to the graph area, and ensure a new entity is created
+
+        Note:
+        - This test file must be called from the Open 3D Engine Editor command terminal
+        - Any passed and failed tests are written to the Editor.log file.
+                Parsing the file or running a log_monitor are required to observe the test results.
+
+        :return: None
+        """
 
         def onEntityCreated(parameters):
             global newEntityId

AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientNodes_EntityRemovedOnNodeDelete.py

@@ -34,6 +34,26 @@ class TestGradientNodeEntityDelete(EditorTestHelper):
         EditorTestHelper.__init__(self, log_prefix="GradientNodeEntityDelete", args=["level"])
 
     def run_test(self):
+        """
+        Summary:
+        This test verifies that the Landscape Canvas node deletion properly cleans up entities in the Editor.
+
+        Expected Behavior:
+        Entities are removed when Gradient nodes are deleted from a graph.
+
+        Test Steps:
+         1) Create a new level
+         2) Open Landscape Canvas and create a new graph
+         3) Drag each of the Gradient nodes to the graph area, and ensure a new entity is created
+         4) Delete the nodes, and ensure the newly created entities are removed
+
+        Note:
+        - This test file must be called from the Open 3D Engine Editor command terminal
+        - Any passed and failed tests are written to the Editor.log file.
+                Parsing the file or running a log_monitor are required to observe the test results.
+
+        :return: None
+        """
 
         def onEntityCreated(parameters):
             global createdEntityId

AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GraphClosed_OnEntityDelete.py

@@ -31,6 +31,26 @@ class TestGraphClosedOnEntityDelete(EditorTestHelper):
         EditorTestHelper.__init__(self, log_prefix="GraphClosedOnEntityDelete", args=["level"])
 
     def run_test(self):
+        """
+        Summary:
+        This test verifies that Landscape Canvas graphs are auto-closed when the corresponding entity is deleted.
+
+        Expected Behavior:
+        When a Landscape Canvas root entity is deleted, the corresponding graph automatically closes.
+
+        Test Steps:
+         1) Create a new level
+         2) Open Landscape Canvas and create a new graph
+         3) Delete the automatically created entity
+         4) Verify the open graph is closed
+
+        Note:
+        - This test file must be called from the Open 3D Engine Editor command terminal
+        - Any passed and failed tests are written to the Editor.log file.
+                Parsing the file or running a log_monitor are required to observe the test results.
+
+        :return: None
+        """
 
         def onEntityCreated(parameters):
             global newRootEntityId

AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GraphClosed_OnLevelChange.py

@@ -29,7 +29,26 @@ class TestGraphClosedOnLevelChange(EditorTestHelper):
         EditorTestHelper.__init__(self, log_prefix="GraphClosedOnLevelChange", args=["level"])
 
     def run_test(self):
+        """
+        Summary:
+        This test verifies that Landscape Canvas graphs are auto-closed when the currently open level changes.
 
+        Expected Behavior:
+        When a new level is loaded in the Editor, open Landscape Canvas graphs are automatically closed.
+
+        Test Steps:
+         1) Create a new level
+         2) Open Landscape Canvas and create a new graph
+         3) Open a different level
+         4) Verify the open graph is closed
+
+        Note:
+        - This test file must be called from the Open 3D Engine Editor command terminal
+        - Any passed and failed tests are written to the Editor.log file.
+                Parsing the file or running a log_monitor are required to observe the test results.
+
+        :return: None
+        """
         # Create a new empty level
         self.test_success = self.create_level(
             self.args["level"],

AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GraphClosed_TabbedGraph.py

@@ -29,6 +29,26 @@ class TestGraphClosedTabbedGraph(EditorTestHelper):
         EditorTestHelper.__init__(self, log_prefix="GraphClosedTabbedGraph", args=["level"])
 
     def run_test(self):
+        """
+        Summary:
+        This test verifies that Landscape Canvas tabbed graphs can be independently closed.
+
+        Expected Behavior:
+        Closing a tabbed graph only closes the appropriate graph.
+
+        Test Steps:
+         1) Create a new level
+         2) Open Landscape Canvas and create several new graphs
+         3) Close one of the open graphs
+         4) Ensure the graph properly closed, and other open graphs remain open
+
+        Note:
+        - This test file must be called from the Open 3D Engine Editor command terminal
+        - Any passed and failed tests are written to the Editor.log file.
+                Parsing the file or running a log_monitor are required to observe the test results.
+
+        :return: None
+        """
 
         # Create a new empty level
         self.test_success = self.create_level(

AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GraphUpdates_UpdateComponents.py

@@ -9,21 +9,6 @@ remove or modify any license notices. This file is distributed on an "AS IS" BAS
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 """
 
-
-"""
-C22715182 - Components are updated when nodes are added/removed/updated
-
-1. Open Level.
-2. Open the graph on LC_BushFlowerBlender.slice
-3. Find the Rotation Modifier node on the BushSpawner entity
-4. Delete the Rotation Modifier node
-5. Ensure the Vegetation Rotation Modifier component is removed from the BushSpawner entity
-6. Delete the Vegetation Layer Spawner node from the graph
-7. Ensure BushSpawner entity is deleted
-8. Change connection from second Rotation Modifier node to a different Gradient
-9. Ensure Gradient reference on component is updated
-"""
-
 import os
 import sys
 
@@ -50,6 +35,31 @@ class TestGraphUpdatesUpdateComponents(EditorTestHelper):
         EditorTestHelper.__init__(self, log_prefix="GraphUpdatesUpdateComponents", args=["level"])
 
     def run_test(self):
+        """
+        Summary:
+        This test verifies that components are properly updated as nodes are added/removed/updated.
+
+        Expected Behavior:
+        Landscape Canvas node CRUD properly updates component entities.
+
+        Test Steps:
+            1. Open Level.
+            2. Open the graph on LC_BushFlowerBlender.slice
+            3. Find the Rotation Modifier node on the BushSpawner entity
+            4. Delete the Rotation Modifier node
+            5. Ensure the Vegetation Rotation Modifier component is removed from the BushSpawner entity
+            6. Delete the Vegetation Layer Spawner node from the graph
+            7. Ensure BushSpawner entity is deleted
+            8. Change connection from second Rotation Modifier node to a different Gradient
+            9. Ensure Gradient reference on component is updated
+
+        Note:
+        - This test file must be called from the Open 3D Engine Editor command terminal
+        - Any passed and failed tests are written to the Editor.log file.
+                Parsing the file or running a log_monitor are required to observe the test results.
+
+        :return: None
+        """
         # Create a new empty level and instantiate LC_BushFlowerBlender.slice
         self.test_success = self.create_level(
             self.args["level"],

AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/LandscapeCanvasComponent_AddedRemoved.py

@@ -30,6 +30,26 @@ class TestLandscapeCanvasComponentAddedRemoved(EditorTestHelper):
         EditorTestHelper.__init__(self, log_prefix="LandscapeCanvasComponentAddedRemoved", args=["level"])
 
     def run_test(self):
+        """
+        Summary:
+        This test verifies that the Landscape Canvas component can be added to/removed from an entity.
+
+        Expected Behavior:
+        Closing a tabbed graph only closes the appropriate graph.
+
+        Test Steps:
+         1) Create a new level
+         2) Create a new entity
+         3) Add a Landscape Canvas component to the entity
+         4) Remove the Landscape Canvas component from the entity
+
+        Note:
+        - This test file must be called from the Open 3D Engine Editor command terminal
+        - Any passed and failed tests are written to the Editor.log file.
+                Parsing the file or running a log_monitor are required to observe the test results.
+
+        :return: None
+        """
 
         # Create a new empty level
         self.test_success = self.create_level(

AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/LandscapeCanvas_SliceCreateInstantiate.py

@@ -30,12 +30,21 @@ class TestLandscapeCanvasSliceCreateInstantiate(EditorTestHelper):
     def run_test(self):
         """
         Summary:
-        C22602016 A slice containing the LandscapeCanvas component can be created/instantiated.
+        A slice containing the LandscapeCanvas component can be created/instantiated.
 
         Expected Result:
-        Slice is created and processed successfully and free of errors/warnings.
-        Another copy of the slice is instantiated.
+        Slice is created/processed/instantiated successfully and free of errors/warnings.
 
+        Test Steps:
+         1) Create a new level
+         2) Create a new entity with a Landscape Canvas component
+         3) Create a slice of the new entity
+         4) Instantiate a new copy of the slice
+
+         Note:
+        - This test file must be called from the Open 3D Engine Editor command terminal
+        - Any passed and failed tests are written to the Editor.log file.
+                Parsing the file or running a log_monitor are required to observe the test results.
         :return: None
         """
 

AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/LayerBlender_NodeConstruction.py

@@ -34,6 +34,27 @@ class TestLayerBlenderNodeConstruction(EditorTestHelper):
         EditorTestHelper.__init__(self, log_prefix="LayerBlenderNodeConstruction", args=["level"])
 
     def run_test(self):
+        """
+        Summary:
+        This test verifies a Layer Blender vegetation setup can be constructed through Landscape Canvas.
+
+        Expected Behavior:
+        Entities contain all required components and component references after creating nodes and setting connections
+        on a Landscape Canvas graph.
+
+        Test Steps:
+         1) Create a new level
+         2) Open Landscape Canvas and create a new graph
+         3) Add all necessary nodes to the graph and set connections to form a Layer Blender setup
+         4) Verify all components and component references were properly set during graph construction
+
+        Note:
+        - This test file must be called from the Open 3D Engine Editor command terminal
+        - Any passed and failed tests are written to the Editor.log file.
+                Parsing the file or running a log_monitor are required to observe the test results.
+
+        :return: None
+        """
 
         def onEntityCreated(parameters):
             global newEntityId

AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/LayerExtenderNodes_ComponentEntitySync.py

@@ -34,6 +34,25 @@ class TestLayerExtenderNodeComponentEntitySync(EditorTestHelper):
         EditorTestHelper.__init__(self, log_prefix="LayerExtenderNodeComponentEntitySync", args=["level"])
 
     def run_test(self):
+        """
+        Summary:
+        This test verifies that all wrapped nodes can be successfully added to/removed from parent nodes.
+
+        Expected Behavior:
+        All wrapped extender nodes can be added to/removed from appropriate parent nodes.
+
+        Test Steps:
+         1) Create a new level
+         2) Open Landscape Canvas and create a new graph
+         3) Add Area Blender and Layer Spawner nodes to the graph, and add/remove each extender node to/from each
+
+        Note:
+        - This test file must be called from the Open 3D Engine Editor command terminal
+        - Any passed and failed tests are written to the Editor.log file.
+                Parsing the file or running a log_monitor are required to observe the test results.
+
+        :return: None
+        """
 
         def onEntityCreated(parameters):
             global newEntityId

AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/ShapeNodes_EntityCreatedOnNodeAdd.py

@@ -33,6 +33,25 @@ class TestShapeNodeEntityCreate(EditorTestHelper):
         EditorTestHelper.__init__(self, log_prefix="ShapeNodeEntityCreate", args=["level"])
 
     def run_test(self):
+        """
+        Summary:
+        This test verifies that the Landscape Canvas nodes can be added to a graph, and correctly create entities.
+
+        Expected Behavior:
+        New entities are created when dragging shape nodes to graph area.
+
+        Test Steps:
+         1) Create a new level
+         2) Open Landscape Canvas and create a new graph
+         3) Drag each of the shape nodes to the graph area, and ensure a new entity is created
+
+        Note:
+        - This test file must be called from the Open 3D Engine Editor command terminal
+        - Any passed and failed tests are written to the Editor.log file.
+                Parsing the file or running a log_monitor are required to observe the test results.
+
+        :return: None
+        """
 
         def onEntityCreated(parameters):
             global newEntityId

AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/ShapeNodes_EntityRemovedOnNodeDelete.py

@@ -34,7 +34,27 @@ class TestShapeNodeEntityDelete(EditorTestHelper):
         EditorTestHelper.__init__(self, log_prefix="ShapeNodeEntityDelete", args=["level"])
 
     def run_test(self):
-        
+        """
+        Summary:
+        This test verifies that the Landscape Canvas node deletion properly cleans up entities in the Editor.
+
+        Expected Behavior:
+        Entities are removed when shape nodes are deleted from a graph.
+
+        Test Steps:
+         1) Create a new level
+         2) Open Landscape Canvas and create a new graph
+         3) Drag each of the shape nodes to the graph area, and ensure a new entity is created
+         4) Delete the nodes, and ensure the newly created entities are removed
+
+        Note:
+        - This test file must be called from the Open 3D Engine Editor command terminal
+        - Any passed and failed tests are written to the Editor.log file.
+                Parsing the file or running a log_monitor are required to observe the test results.
+
+        :return: None
+        """
+
         def onEntityCreated(parameters):
             global createdEntityId
             createdEntityId = parameters[0]

AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/SlotConnections_UpdateComponentReferences.py

@@ -33,6 +33,27 @@ class TestSlotConnectionsUpdateComponents(EditorTestHelper):
         EditorTestHelper.__init__(self, log_prefix="SlotConnectionsUpdateComponents", args=["level"])
 
     def run_test(self):
+        """
+        Summary:
+        This test verifies that the Landscape Canvas slot connections properly update component references.
+
+        Expected Behavior:
+        A reference created through slot connections in Landscape Canvas is reflected in the Entity Inspector.
+
+        Test Steps:
+         1) Create a new level
+         2) Open Landscape Canvas and create a new graph
+         3) Several nodes are added to a graph, and connections are set between the nodes
+         4) Component references are verified via Entity Inspector
+
+        Note:
+        - This test file must be called from the Open 3D Engine Editor command terminal
+        - Any passed and failed tests are written to the Editor.log file.
+                Parsing the file or running a log_monitor are required to observe the test results.
+
+        :return: None
+        """
+
         # Retrieve the proper component TypeIds per component name
         componentNames = [
             'Random Noise Gradient',

Code/Framework/AzCore/AzCore/PlatformId/PlatformDefaults.cpp

@@ -35,7 +35,7 @@ namespace AZ
                 return "Android";
             case AZ::IOS:
                 return "iOS";
-            case AZ::MAC:
+            case AZ::MAC_ID:
                 return "Mac";
             case AZ::PROVO:
                 return "Provo";
@@ -213,7 +213,7 @@ namespace AZ
             case PlatformId::IOS:
                 platformCodes.emplace_back(PlatformCodeNameiOS);
                 break;
-            case PlatformId::MAC:
+            case PlatformId::MAC_ID:
                 platformCodes.emplace_back(PlatformCodeNameMac);
                 break;
             case PlatformId::PROVO:

Code/Framework/AzCore/AzCore/PlatformId/PlatformDefaults.h

@@ -56,7 +56,7 @@ namespace AZ
             PC,
             ANDROID_ID,
             IOS,
-            MAC,
+            MAC_ID,
             PROVO,
             SALEM,
             JASPER,
@@ -75,7 +75,7 @@ namespace AZ
             Platform_PC = 1 << PlatformId::PC,
             Platform_ANDROID = 1 << PlatformId::ANDROID_ID,
             Platform_IOS = 1 << PlatformId::IOS,
-            Platform_MAC = 1 << PlatformId::MAC,
+            Platform_MAC = 1 << PlatformId::MAC_ID,
             Platform_PROVO = 1 << PlatformId::PROVO,
             Platform_SALEM = 1 << PlatformId::SALEM,
             Platform_JASPER = 1 << PlatformId::JASPER,

Code/Framework/AzCore/Platform/Mac/AzCore/PlatformId/PlatformId_Mac.h

@@ -13,5 +13,5 @@
 
 namespace AZ
 {
-    static const PlatformID g_currentPlatform = PlatformID::PLATFORM_APPLE_OSX;
+    static const PlatformID g_currentPlatform = PlatformID::PLATFORM_APPLE_MAC;
 }

Code/Framework/AzFramework/AzFramework/Archive/Archive.cpp

@@ -2008,13 +2008,12 @@ namespace AZ::IO
         // if no bind root is specified, compute one:
         strBindRoot = !bindRoot.empty() ? bindRoot : szFullPath->ParentPath().Native();
 
-        // Check if archive file disk exist on disk or inside of pak.
-        bool bFileExists = IsFileExist(szFullPath->Native());
-
-        if (!bFileExists && (nFactoryFlags & ZipDir::CacheFactory::FLAGS_READ_ONLY))
+        // Check if archive file disk exist on disk.
+        const bool pakOnDisk = FileIOBase::GetDirectInstance()->Exists(szFullPath->c_str());
+        if (!pakOnDisk && (nFactoryFlags & ZipDir::CacheFactory::FLAGS_READ_ONLY))
         {
             // Archive file not found.
-            AZ_TracePrintf("Archive", "Cannot open Archive file %s\n", szFullPath->c_str());
+            AZ_TracePrintf("Archive", "Archive file %s does not exist\n", szFullPath->c_str());
             return nullptr;
         }
 
@@ -2492,8 +2491,6 @@ namespace AZ::IO
 
     void Archive::FindCompressionInfo(bool& found, AZ::IO::CompressionInfo& info, const AZStd::string_view filename)
     {
-        constexpr uint32_t s_compressionTag = static_cast<uint32_t>('Z') << 24 | static_cast<uint32_t>('C') << 16 | static_cast<uint32_t>('R') << 8 | static_cast<uint32_t>('Y');
-
         if (!found)
         {
             auto correctedFilename = AZ::IO::FileIOBase::GetDirectInstance()->ResolvePath(filename);
@@ -2519,7 +2516,6 @@ namespace AZ::IO
                 found = true;
 
                 info.m_archiveFilename.InitFromRelativePath(archive->GetFilePath());
-                info.m_compressionTag.m_code = s_compressionTag;
                 info.m_offset = pFileData->GetFileDataOffset();
                 info.m_compressedSize = entry->desc.lSizeCompressed;
                 info.m_uncompressedSize = entry->desc.lSizeUncompressed;
@@ -2539,9 +2535,8 @@ namespace AZ::IO
                     break;
                 }
 
-                info.m_decompressor = [&s_compressionTag]([[maybe_unused]] const AZ::IO::CompressionInfo& info, const void* compressed, size_t compressedSize, void* uncompressed, size_t uncompressedBufferSize)->bool
+                info.m_decompressor = []([[maybe_unused]] const AZ::IO::CompressionInfo& info, const void* compressed, size_t compressedSize, void* uncompressed, size_t uncompressedBufferSize)->bool
                 {
-                    AZ_Assert(info.m_compressionTag.m_code == s_compressionTag, "Provided compression info isn't supported by this decompressor.");
                     size_t nSizeUncompressed = uncompressedBufferSize;
                     return ZipDir::ZipRawUncompress(uncompressed, &nSizeUncompressed, compressed, compressedSize) == 0;
                 };

Code/Framework/AzFramework/AzFramework/Archive/ArchiveFindData.cpp

@@ -50,6 +50,7 @@ namespace AZ::IO
         , tWrite{ writeTime }
     {
     }
+
     ArchiveFileIterator::ArchiveFileIterator(FindData* findData, AZStd::string_view filename, const FileDesc& fileDesc)
         : m_findData{ findData }
         , m_filename{ filename }
@@ -108,13 +109,10 @@ namespace AZ::IO
             AZ::StringFunc::Path::GetFullPath(directory.c_str(), searchDirectory);
             AZ::StringFunc::Path::GetFullFileName(directory.c_str(), pattern);
         }
-
         AZ::IO::FileIOBase::GetDirectInstance()->FindFiles(searchDirectory.c_str(), pattern.c_str(), [&](const char* filePath) -> bool
         {
             AZ::IO::FileDesc fileDesc;
-
-            AZStd::string fullFilePath;
-            AZ::StringFunc::Path::GetFullFileName(filePath, fullFilePath);
+            AZStd::string filePathEntry{filePath};
 
             if (AZ::IO::FileIOBase::GetDirectInstance()->IsDirectory(filePath))
             {
@@ -135,9 +133,8 @@ namespace AZ::IO
                 fileDesc.tAccess = fileDesc.tWrite;
                 fileDesc.tCreate = fileDesc.tWrite;
             }
-            [[maybe_unused]] auto result = m_mapFiles.emplace(AZStd::move(fullFilePath), fileDesc);
-            AZ_Assert(result.second, "Failed to insert FindData entry for %s", fullFilePath.c_str());
-
+            [[maybe_unused]] auto result = m_mapFiles.emplace(AZStd::move(filePathEntry), fileDesc);
+            AZ_Assert(result.second, "Failed to insert FindData entry for filePath %s", filePath);
             return true;
         });
     }
@@ -273,7 +270,9 @@ namespace AZ::IO
         }
 
         auto pakFileIter = m_mapFiles.begin();
-        fileIterator.m_filename = pakFileIter->first;
+        AZStd::string fullFilePath;
+        AZ::StringFunc::Path::GetFullFileName(pakFileIter->first.c_str(), fullFilePath);
+        fileIterator.m_filename = AZStd::move(fullFilePath);
         fileIterator.m_fileDesc = pakFileIter->second;
         fileIterator.m_lastFetchValid = true;
 

Code/Framework/AzFramework/AzFramework/Physics/Ragdoll.h

@@ -102,7 +102,7 @@ namespace Physics
 
         /// Is the ragdoll currently simulated?
         /// @result True in case the ragdoll is simulated, false if not.
-        virtual bool IsSimulated() = 0;
+        virtual bool IsSimulated() const = 0;
 
         /// Writes the state for all of the bodies in the ragdoll to the provided output.
         /// The caller owns the output state and can safely manipulate it without affecting the physics simulation.

Code/Framework/AzToolsFramework/AzToolsFramework/Entity/PrefabEditorEntityOwnershipInterface.h

@@ -57,6 +57,6 @@ namespace AzToolsFramework
         virtual void StartPlayInEditor() = 0;
         virtual void StopPlayInEditor() = 0;
 
-        virtual void CreateNewLevelPrefab(AZStd::string_view filename) = 0;
+        virtual void CreateNewLevelPrefab(AZStd::string_view filename, const AZStd::string& templateFilename) = 0;
     };
 }

Code/Framework/AzToolsFramework/AzToolsFramework/Entity/PrefabEditorEntityOwnershipService.cpp

@@ -265,7 +265,7 @@ namespace AzToolsFramework
         return false;
     }
 
-    void PrefabEditorEntityOwnershipService::CreateNewLevelPrefab(AZStd::string_view filename)
+    void PrefabEditorEntityOwnershipService::CreateNewLevelPrefab(AZStd::string_view filename, const AZStd::string& templateFilename)
     {
         AZ::IO::Path relativePath = m_loaderInterface->GetRelativePathToProject(filename);
         AzToolsFramework::Prefab::TemplateId templateId = m_prefabSystemComponent->GetTemplateIdFromFilePath(relativePath);
@@ -276,7 +276,7 @@ namespace AzToolsFramework
         AZ::Data::AssetInfo assetInfo;
         bool sourceInfoFound = false;
         AzToolsFramework::AssetSystemRequestBus::BroadcastResult(
-            sourceInfoFound, &AzToolsFramework::AssetSystemRequestBus::Events::GetSourceInfoBySourcePath, DefaultLevelTemplateName,
+            sourceInfoFound, &AzToolsFramework::AssetSystemRequestBus::Events::GetSourceInfoBySourcePath, templateFilename.c_str(),
             assetInfo, watchFolder);
 
         if (sourceInfoFound)
@@ -292,7 +292,7 @@ namespace AzToolsFramework
             levelDefaultDom.CopyFrom(dom, levelDefaultDom.GetAllocator());
 
             Prefab::PrefabDomPath sourcePath("/Source");
-            sourcePath.Set(levelDefaultDom, assetInfo.m_relativePath.c_str());
+            sourcePath.Set(levelDefaultDom, relativePath.c_str());
 
             templateId = m_prefabSystemComponent->AddTemplate(relativePath, AZStd::move(levelDefaultDom));
         }

Code/Framework/AzToolsFramework/AzToolsFramework/Entity/PrefabEditorEntityOwnershipService.h

@@ -170,7 +170,7 @@ namespace AzToolsFramework
         void StartPlayInEditor() override;
         void StopPlayInEditor() override;
 
-        void CreateNewLevelPrefab(AZStd::string_view filename) override;
+        void CreateNewLevelPrefab(AZStd::string_view filename, const AZStd::string& templateFilename) override;
 
     protected:
 
@@ -218,7 +218,5 @@ namespace AzToolsFramework
         Prefab::PrefabLoaderInterface* m_loaderInterface;
         AzFramework::EntityContextId m_entityContextId;
         AZ::SerializeContext m_serializeContext;
-
-        static inline constexpr const char* DefaultLevelTemplateName = "Prefabs/Default_Level.prefab";
     };
 }

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/LineSegmentSelectionManipulator.cpp

@@ -31,7 +31,7 @@ namespace AzToolsFramework
             rayProportion, lineSegmentProportion, worldClosestPositionRay, worldClosestPositionLineSegment);
 
         AZ::Transform worldFromLocalNormalized = worldFromLocal;
-        const AZ::Vector3 scale = worldFromLocalNormalized.ExtractScale() * nonUniformScale;
+        const AZ::Vector3 scale = worldFromLocalNormalized.ExtractUniformScale() * nonUniformScale;
         const AZ::Transform localFromWorldNormalized = worldFromLocalNormalized.GetInverse();
 
         return { (localFromWorldNormalized.TransformPoint(worldClosestPositionLineSegment)) / scale };

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/LinearManipulator.cpp

@@ -59,7 +59,7 @@ namespace AzToolsFramework
             ? CalculateSnappedOffset(localTransform.GetTranslation(), axis, gridSize * scaleRecip)
             : AZ::Vector3::CreateZero();
 
-        const AZ::Vector3 localScale = localTransform.GetScale();
+        const AZ::Vector3 localScale = AZ::Vector3(localTransform.GetUniformScale());
         const AZ::Quaternion localRotation = QuaternionFromTransformNoScaling(localTransform);
         // calculate scale amount to snap, to align to round scale value
         const AZ::Vector3 scaleSnapOffset = snapping && !gridSnapAction.m_localSnapping

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/ManipulatorSnapping.h

@@ -113,7 +113,7 @@ namespace AzToolsFramework
     /// noise in the value returned when dealing with values far from the origin.
     inline float ScaleReciprocal(const AZ::Transform& transform)
     {
-        return Round3(transform.GetScale().GetReciprocal().GetMinElement());
+        return Round3(1.0f / transform.GetUniformScale());
     }
 
     /// Find the reciprocal of the non-uniform scale.

Code/Framework/AzToolsFramework/AzToolsFramework/Manipulators/ManipulatorSpace.cpp

@@ -39,7 +39,7 @@ namespace AzToolsFramework
         AZ::Transform result;
         result.SetRotation(m_space.GetRotation() * localTransform.GetRotation());
         result.SetTranslation(m_space.TransformPoint(m_nonUniformScale * localTransform.GetTranslation()));
-        result.SetScale(m_space.GetScale() * localTransform.GetScale());
+        result.SetScale(m_space.GetScale() * localTransform.GetUniformScale());
         return result;
     }
 

Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorTransformComponentSelection.cpp

@@ -809,14 +809,12 @@ namespace AzToolsFramework
         EntityIdManipulators& entityIdManipulators,
         OptionalFrame& pivotOverrideFrame,
         ViewportInteraction::KeyboardModifiers& prevModifiers,
-        bool& transformChangedInternally, SpaceCluster spaceCluster)
+        bool& transformChangedInternally, const AZStd::optional<ReferenceFrame> spaceLock)
     {
         AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
 
         entityIdManipulators.m_manipulators->SetLocalPosition(action.LocalPosition());
 
-        const ReferenceFrame referenceFrame = spaceCluster.m_spaceLock ? spaceCluster.m_currentSpace : ReferenceFrameFromModifiers(action.m_modifiers);
-
         if (action.m_modifiers.Ctrl())
         {
             // moving with ctrl - setting override
@@ -826,6 +824,8 @@ namespace AzToolsFramework
         }
         else
         {
+            const ReferenceFrame referenceFrame = spaceLock.value_or(ReferenceFrameFromModifiers(action.m_modifiers));
+
             // note: used for parent and world depending on the current reference frame
             const auto pivotOrientation =
                 ETCS::CalculateSelectionPivotOrientation(
@@ -1298,7 +1298,7 @@ namespace AzToolsFramework
         {
             UpdateTranslationManipulator(
                 action, manipulatorEntityIds->m_entityIds, m_entityIdManipulators, m_pivotOverrideFrame, prevModifiers,
-                    m_transformChangedInternally, m_spaceCluster);
+                    m_transformChangedInternally, m_spaceCluster.m_spaceLock);
         });
 
         translationManipulators->InstallLinearManipulatorMouseUpCallback(
@@ -1329,7 +1329,7 @@ namespace AzToolsFramework
         {
             UpdateTranslationManipulator(
                 action, manipulatorEntityIds->m_entityIds, m_entityIdManipulators, m_pivotOverrideFrame, prevModifiers,
-                    m_transformChangedInternally, m_spaceCluster);
+                    m_transformChangedInternally, m_spaceCluster.m_spaceLock);
         });
 
         translationManipulators->InstallPlanarManipulatorMouseUpCallback(
@@ -1359,7 +1359,7 @@ namespace AzToolsFramework
         {
             UpdateTranslationManipulator(
                 action, manipulatorEntityIds->m_entityIds, m_entityIdManipulators, m_pivotOverrideFrame, prevModifiers,
-                    m_transformChangedInternally, m_spaceCluster);
+                    m_transformChangedInternally, m_spaceCluster.m_spaceLock);
         });
 
         translationManipulators->InstallSurfaceManipulatorMouseUpCallback(
@@ -1437,8 +1437,7 @@ namespace AzToolsFramework
             [this, prevModifiers, sharedRotationState]
             (const AngularManipulator::Action& action) mutable -> void
         {
-            const ReferenceFrame referenceFrame = m_spaceCluster.m_spaceLock ? m_spaceCluster.m_currentSpace : ReferenceFrameFromModifiers(action.m_modifiers);
-
+            const ReferenceFrame referenceFrame = m_spaceCluster.m_spaceLock.value_or(ReferenceFrameFromModifiers(action.m_modifiers));
             const AZ::Quaternion manipulatorOrientation = action.m_start.m_rotation * action.m_current.m_delta;
             // store the pivot override frame when positioning the manipulator manually (ctrl)
             // so we don't lose the orientation when adding/removing entities from the selection
@@ -2605,40 +2604,37 @@ namespace AzToolsFramework
             if (buttonId == m_spaceCluster.m_localButtonId)
             {
                 // Unlock
-                if (m_spaceCluster.m_spaceLock && m_spaceCluster.m_currentSpace == ReferenceFrame::Local)
+                if (m_spaceCluster.m_spaceLock.has_value() && m_spaceCluster.m_spaceLock.value() == ReferenceFrame::Local)
                 {
-                    m_spaceCluster.m_spaceLock = false;
+                    m_spaceCluster.m_spaceLock = AZStd::nullopt;
                 }
                 else
                 {
-                    m_spaceCluster.m_spaceLock = true;
-                    m_spaceCluster.m_currentSpace = ReferenceFrame::Local;
+                    m_spaceCluster.m_spaceLock = ReferenceFrame::Local;
                 }
             }
             else if (buttonId == m_spaceCluster.m_parentButtonId)
             {
                 // Unlock
-                if (m_spaceCluster.m_spaceLock && m_spaceCluster.m_currentSpace == ReferenceFrame::Parent)
+                if (m_spaceCluster.m_spaceLock.has_value() && m_spaceCluster.m_spaceLock.value() == ReferenceFrame::Parent)
                 {
-                    m_spaceCluster.m_spaceLock = false;
+                    m_spaceCluster.m_spaceLock = AZStd::nullopt;
                 }
                 else
                 {
-                    m_spaceCluster.m_spaceLock = true;
-                    m_spaceCluster.m_currentSpace = ReferenceFrame::Parent;
+                    m_spaceCluster.m_spaceLock = ReferenceFrame::Parent;
                 }
             }
             else if (buttonId == m_spaceCluster.m_worldButtonId)
             {
                 // Unlock
-                if (m_spaceCluster.m_spaceLock && m_spaceCluster.m_currentSpace == ReferenceFrame::World)
+                if (m_spaceCluster.m_spaceLock.has_value() && m_spaceCluster.m_spaceLock.value() == ReferenceFrame::World)
                 {
-                    m_spaceCluster.m_spaceLock = false;
+                    m_spaceCluster.m_spaceLock = AZStd::nullopt;
                 }
                 else
                 {
-                    m_spaceCluster.m_spaceLock = true;
-                    m_spaceCluster.m_currentSpace = ReferenceFrame::World;
+                    m_spaceCluster.m_spaceLock = ReferenceFrame::World;
                 }
             }
         };
@@ -3361,8 +3357,7 @@ namespace AzToolsFramework
             ViewportInteraction::BuildMouseButtons(
                 QGuiApplication::mouseButtons()), m_boxSelect.Active());
 
-        const ReferenceFrame referenceFrame =
-            m_spaceCluster.m_spaceLock ? m_spaceCluster.m_currentSpace : ReferenceFrameFromModifiers(modifiers);
+        const ReferenceFrame referenceFrame = m_spaceCluster.m_spaceLock.value_or(ReferenceFrameFromModifiers(modifiers));
 
         UpdateSpaceCluster(referenceFrame);
 

Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorTransformComponentSelection.h

@@ -106,15 +106,20 @@ namespace AzToolsFramework
         World, //!< World space (space aligned to world axes - identity).
     };
 
+    //! Grouping of viewport ui related state for controlling the current reference space of the Editor.
     struct SpaceCluster
     {
-        ViewportUi::ClusterId m_spaceClusterId;
-        ViewportUi::ButtonId m_localButtonId;
-        ViewportUi::ButtonId m_parentButtonId;
-        ViewportUi::ButtonId m_worldButtonId;
-        AZ::Event<ViewportUi::ButtonId>::Handler m_spaceSelectionHandler;
-        ReferenceFrame m_currentSpace = ReferenceFrame::Parent;
-        bool m_spaceLock = false;
+        SpaceCluster() = default;
+        // disable copying and moving (implicit)
+        SpaceCluster(const SpaceCluster&) = delete;
+        SpaceCluster& operator=(const SpaceCluster&) = delete;
+
+        ViewportUi::ClusterId m_spaceClusterId; //!< The id identifying the reference space cluster.
+        ViewportUi::ButtonId m_localButtonId; //!< Local reference space button id.
+        ViewportUi::ButtonId m_parentButtonId; //!< Parent reference space button id.
+        ViewportUi::ButtonId m_worldButtonId; //!< World reference space button id.
+        AZ::Event<ViewportUi::ButtonId>::Handler m_spaceSelectionHandler; //!< Callback for when a space cluster button is pressed.
+        AZStd::optional<ReferenceFrame> m_spaceLock; //!< Locked reference frame to use if set.
     };
 
     //! Entity selection/interaction handling.
@@ -265,6 +270,9 @@ namespace AzToolsFramework
         void SetEntityLocalScale(AZ::EntityId entityId, float localScale);
         void SetEntityLocalRotation(AZ::EntityId entityId, const AZ::Vector3& localRotation);
 
+        // Responsible for keeping the space cluster in sync with the current reference frame.
+        void UpdateSpaceCluster(ReferenceFrame referenceFrame);
+
         AZ::EntityId m_hoveredEntityId; //!< What EntityId is the mouse currently hovering over (if any).
         AZ::EntityId m_cachedEntityIdUnderCursor; //!< Store the EntityId on each mouse move for use in Display.
         AZ::EntityId m_editorCameraComponentEntityId; //!< The EditorCameraComponent EntityId if it is set.
@@ -297,9 +305,7 @@ namespace AzToolsFramework
         AZ::Event<ViewportUi::ButtonId>::Handler m_transformModeSelectionHandler; //!< Event handler for the Viewport UI cluster.
         AzFramework::ClickDetector m_clickDetector; //!< Detect different types of mouse click.
         AzFramework::CursorState m_cursorState; //!< Track the mouse position and delta movement each frame.
-
-        SpaceCluster m_spaceCluster;
-        void UpdateSpaceCluster(ReferenceFrame referenceFrame);
+        SpaceCluster m_spaceCluster; //!< Related viewport ui state for controlling the current reference space.
     };
 
     //! The ETCS (EntityTransformComponentSelection) namespace contains functions and data used exclusively by

Code/Sandbox/Editor/CMakeLists.txt

@@ -173,6 +173,7 @@ ly_add_target(
     RUNTIME_DEPENDENCIES
         Legacy::CrySystem
         Legacy::EditorLib
+        ProjectManager
 )
 ly_add_translations(
     TARGETS Editor

Code/Sandbox/Editor/CryEdit.cpp

@@ -3111,7 +3111,7 @@ CCryEditApp::ECreateLevelResult CCryEditApp::CreateLevel(const QString& levelNam
         auto* service = AZ::Interface<AzToolsFramework::PrefabEditorEntityOwnershipInterface>::Get();
         if (service)
         {
-            service->CreateNewLevelPrefab((const char*)fullyQualifiedLevelName.toUtf8());
+            service->CreateNewLevelPrefab(fullyQualifiedLevelName.toUtf8().constData(), DefaultLevelTemplateName);
         }
     }
 

Code/Sandbox/Editor/CryEdit.h

@@ -358,6 +358,8 @@ AZ_PUSH_DISABLE_DLL_EXPORT_MEMBER_WARNING
 AZ_POP_DISABLE_DLL_EXPORT_MEMBER_WARNING 
 
 private:
+    static inline constexpr const char* DefaultLevelTemplateName = "Prefabs/Default_Level.prefab";
+
     struct PythonOutputHandler;
     AZ_PUSH_DISABLE_DLL_EXPORT_MEMBER_WARNING
     AZStd::shared_ptr<PythonOutputHandler> m_pythonOutputHandler;

Code/Sandbox/Editor/res/o3de_editor.ico

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:c042fce57915fc749abc7b37de765fd697c3c4d7de045a3d44805aa0ce29901a
-size 107016
+oid sha256:d717f77fe01f45df934a61bbc215e5322447d21e16f3cebcf2a02f148178f266
+size 106449

Code/Sandbox/Plugins/EditorAssetImporter/AssetImporterPlugin.cpp

@@ -14,6 +14,7 @@
 #include <AssetImporterPlugin.h>
 #include <AssetImporterWindow.h>
 #include <QtViewPaneManager.h>
+#include <SceneAPI/SceneCore/Events/AssetImportRequest.h>
 #include <SceneAPI/SceneCore/Utilities/Reporting.h>
 #include <LyViewPaneNames.h>
 #include <AzToolsFramework/API/ToolsApplicationAPI.h>
@@ -37,6 +38,10 @@ AssetImporterPlugin::AssetImporterPlugin(IEditor* editor)
     opt.showInMenu = false; // this view pane is used to display scene settings, but the user never opens it directly through the Tools menu
     opt.saveKeyName = "Scene Settings (PREVIEW)"; // user settings for this pane were originally saved with PREVIEW, so ensure that's how they are loaded as well, even after the PREVIEW is removed from the name
     AzToolsFramework::RegisterViewPane<AssetImporterWindow>(m_toolName.c_str(), LyViewPane::CategoryTools, opt);
+
+    AzToolsFramework::ToolsApplicationRequestBus::Broadcast(
+        &AzToolsFramework::ToolsApplicationRequests::CreateAndAddEntityFromComponentTags,
+        AZStd::vector<AZ::Crc32>({ AZ::SceneAPI::Events::AssetImportRequest::GetAssetImportRequestComponentTag() }), "AssetImportersEntity");
 }
 
 void AssetImporterPlugin::Release()

Code/Tools/AssetProcessor/native/utilities/ApplicationManager.cpp

@@ -622,13 +622,14 @@ bool ApplicationManager::Activate()
 {
     if (!AssetUtilities::ComputeAssetRoot(m_systemRoot))
     {
+        AZ_Error(AssetProcessor::ConsoleChannel, false, "Unable to compute the asset root for the project, this application cannot launch until this is fixed.");
         return false;
     }
 
     auto projectName = AssetUtilities::ComputeProjectName();
     if (projectName.isEmpty())
     {
-        AZ_Error(AssetProcessor::ConsoleChannel, false, "Unable to detect name of current game project.  Is bootstrap.cfg appropriately configured?");
+        AZ_Error(AssetProcessor::ConsoleChannel, false, "Unable to detect name of current game project. Configure your game project name to launch this application.");
         return false;
     }
 

Code/Tools/AssetProcessor/native/utilities/ApplicationManagerBase.cpp

@@ -1191,6 +1191,7 @@ bool ApplicationManagerBase::Activate()
     QDir projectCache;
     if (!AssetUtilities::ComputeProjectCacheRoot(projectCache))
     {
+        AZ_Error("AssetProcessor", false, "Could not compute project cache root, please configure your project correctly to launch Asset Processor.");
         return false;
     }
 
@@ -1200,22 +1201,27 @@ bool ApplicationManagerBase::Activate()
     // Shutdown if the disk has less than 128MB of free space
     if (!CheckSufficientDiskSpace(projectCache.absolutePath(), 128 * 1024 * 1024, true))
     {
+        // CheckSufficientDiskSpace reports an error if disk space is low.
         return false;
     }
 
     bool appInited = InitApplicationServer();
     if (!appInited)
     {
+        AZ_Error(
+            "AssetProcessor", false, "InitApplicationServer failed, something internal to Asset Processor has failed, please report this to support if you encounter this error.");
         return false;
     }
 
     if (!InitAssetDatabase())
     {
+        // AssetDatabaseConnection::OpenDatabase reports any errors it encounters.
         return false;
     }
 
     if (!ApplicationManager::Activate())
     {
+        // ApplicationManager::Activate() reports any errors it encounters.
         return false;
     }
 
@@ -1230,6 +1236,7 @@ bool ApplicationManagerBase::Activate()
     m_isCurrentlyLoadingGems = true;
     if (!ActivateModules())
     {
+        // ActivateModules reports any errors it encounters.
         m_isCurrentlyLoadingGems = false;
         return false;
     }
@@ -1299,6 +1306,7 @@ bool ApplicationManagerBase::Activate()
     {
         if (!m_applicationServer->startListening())
         {
+            // startListening reports any errors it encounters.
             return false;
         }
     }

Code/Tools/ProjectManager/Resources/o3de_editor.ico

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:c042fce57915fc749abc7b37de765fd697c3c4d7de045a3d44805aa0ce29901a
-size 107016
+oid sha256:d717f77fe01f45df934a61bbc215e5322447d21e16f3cebcf2a02f148178f266
+size 106449

Code/Tools/SceneAPI/FbxSceneBuilder/DllMain.cpp

@@ -38,21 +38,8 @@ namespace AZ
     {
         namespace FbxSceneBuilder
         {
-            static AZ::SceneAPI::FbxSceneImporter::FbxImportRequestHandler* g_fbxImporter = nullptr;
             static AZStd::vector<AZ::ComponentDescriptor*> g_componentDescriptors;
 
-            void Initialize()
-            {
-                // Currently it's still needed to explicitly create an instance of this instead of letting
-                //      it be a normal component. This is because ResourceCompilerScene needs to return
-                //      the list of available extensions before it can start the application.
-                if (!g_fbxImporter)
-                {
-                    g_fbxImporter = aznew AZ::SceneAPI::FbxSceneImporter::FbxImportRequestHandler();
-                    g_fbxImporter->Activate();
-                }
-            }
-
             void Reflect(AZ::SerializeContext* /*context*/)
             {
                 // Descriptor registration is done in Reflect instead of Initialize because the ResourceCompilerScene initializes the libraries before
@@ -64,6 +51,7 @@ namespace AZ
                 {
                     // Global importer and behavior
                     g_componentDescriptors.push_back(FbxSceneBuilder::FbxImporter::CreateDescriptor());
+                    g_componentDescriptors.push_back(FbxSceneImporter::FbxImportRequestHandler::CreateDescriptor());
 
                     // Node and attribute importers
                     g_componentDescriptors.push_back(AssImpBitangentStreamImporter::CreateDescriptor());
@@ -110,13 +98,6 @@ namespace AZ
                     g_componentDescriptors.clear();
                     g_componentDescriptors.shrink_to_fit();
                 }
-
-                if (g_fbxImporter)
-                {
-                    g_fbxImporter->Deactivate();
-                    delete g_fbxImporter;
-                    g_fbxImporter = nullptr;
-                }
             }
         } // namespace FbxSceneBuilder
     } // namespace SceneAPI
@@ -125,7 +106,6 @@ namespace AZ
 extern "C" AZ_DLL_EXPORT void InitializeDynamicModule(void* env)
 {
     AZ::Environment::Attach(static_cast<AZ::EnvironmentInstance>(env));
-    AZ::SceneAPI::FbxSceneBuilder::Initialize();
 }
 extern "C" AZ_DLL_EXPORT void Reflect(AZ::SerializeContext* context)
 {

Code/Tools/SceneAPI/FbxSceneBuilder/FbxImportRequestHandler.cpp

@@ -10,12 +10,16 @@
 *
 */
 
+#include <AssetProcessor/AssetBuilderSDK/AssetBuilderSDK/AssetBuilderSDK.h>
+#include <AzCore/Serialization/EditContextConstants.inl>
 #include <AzCore/Serialization/SerializeContext.h>
-#include <AzFramework/StringFunc/StringFunc.h>
+#include <AzCore/Serialization/Json/JsonSerialization.h>
+#include <AzCore/Settings/SettingsRegistry.h>
+#include <AzCore/StringFunc/StringFunc.h>
+#include <SceneAPI/FbxSceneBuilder/FbxImportRequestHandler.h>
 #include <SceneAPI/SceneCore/Containers/Scene.h>
 #include <SceneAPI/SceneCore/Events/CallProcessorBus.h>
 #include <SceneAPI/SceneCore/Events/ImportEventContext.h>
-#include <SceneAPI/FbxSceneBuilder/FbxImportRequestHandler.h>
 
 namespace AZ
 {
@@ -23,10 +27,23 @@ namespace AZ
     {
         namespace FbxSceneImporter
         {
-            const char* FbxImportRequestHandler::s_extension = ".fbx";
+            void SceneImporterSettings::Reflect(AZ::ReflectContext* context)
+            {
+                if (auto serializeContext = azrtti_cast<AZ::SerializeContext*>(context); serializeContext)
+                {
+                    serializeContext->Class<SceneImporterSettings>()
+                                    ->Version(2)
+                                    ->Field("SupportedFileTypeExtensions", &SceneImporterSettings::m_supportedFileTypeExtensions);
+                }
+            }
 
             void FbxImportRequestHandler::Activate()
             {
+                if (auto* settingsRegistry = AZ::SettingsRegistry::Get())
+                {
+                    settingsRegistry->GetObject(m_settings, "/O3DE/SceneAPI/AssetImporter");
+                }
+
                 BusConnect();
             }
 
@@ -37,21 +54,31 @@ namespace AZ
 
             void FbxImportRequestHandler::Reflect(ReflectContext* context)
             {
+                SceneImporterSettings::Reflect(context);
+
                 SerializeContext* serializeContext = azrtti_cast<SerializeContext*>(context);
                 if (serializeContext)
                 {
-                    serializeContext->Class<FbxImportRequestHandler, SceneCore::BehaviorComponent>()->Version(1);
+                    serializeContext->Class<FbxImportRequestHandler, AZ::Component>()->Version(1)->Attribute(
+                        AZ::Edit::Attributes::SystemComponentTags,
+                        AZStd::vector<AZ::Crc32>(
+                            {AssetBuilderSDK::ComponentTags::AssetBuilder,
+                            AssetImportRequest::GetAssetImportRequestComponentTag()}));
+                    
                 }
             }
 
             void FbxImportRequestHandler::GetSupportedFileExtensions(AZStd::unordered_set<AZStd::string>& extensions)
             {
-                extensions.insert(s_extension);
+                extensions.insert(m_settings.m_supportedFileTypeExtensions.begin(), m_settings.m_supportedFileTypeExtensions.end());
             }
 
             Events::LoadingResult FbxImportRequestHandler::LoadAsset(Containers::Scene& scene, const AZStd::string& path, const Uuid& guid, [[maybe_unused]] RequestingApplication requester)
             {
-                if (!AzFramework::StringFunc::Path::IsExtension(path.c_str(), s_extension))
+                AZStd::string extension;
+                StringFunc::Path::GetExtension(path.c_str(), extension);
+                
+                if (!m_settings.m_supportedFileTypeExtensions.contains(extension))
                 {
                     return Events::LoadingResult::Ignored;
                 }
@@ -73,6 +100,11 @@ namespace AZ
                     return Events::LoadingResult::AssetFailure;
                 }
             }
+
+            void FbxImportRequestHandler::GetProvidedServices(ComponentDescriptor::DependencyArrayType& provided)
+            {
+                provided.emplace_back(AZ_CRC_CE("AssetImportRequestHandler"));
+            }
         } // namespace Import
     } // namespace SceneAPI
 } // namespace AZ

Code/Tools/SceneAPI/FbxSceneBuilder/FbxImportRequestHandler.h

@@ -21,12 +21,21 @@ namespace AZ
     {
         namespace FbxSceneImporter
         {
+            struct SceneImporterSettings
+            {
+                AZ_TYPE_INFO(SceneImporterSettings, "{8BB6C7AD-BF99-44DC-9DA1-E7AD3F03DC10}");
+                
+                static void Reflect(AZ::ReflectContext* context);
+
+                AZStd::unordered_set<AZStd::string> m_supportedFileTypeExtensions;
+            };
+
             class FbxImportRequestHandler
-                : public SceneCore::BehaviorComponent
+                : public AZ::Component
                 , public Events::AssetImportRequestBus::Handler
             {
             public:
-                AZ_COMPONENT(FbxImportRequestHandler, "{9F4B189C-0A96-4F44-A5F0-E087FF1561F8}", SceneCore::BehaviorComponent);
+                AZ_COMPONENT(FbxImportRequestHandler, "{9F4B189C-0A96-4F44-A5F0-E087FF1561F8}");
 
                 ~FbxImportRequestHandler() override = default;
 
@@ -38,8 +47,13 @@ namespace AZ
                 Events::LoadingResult LoadAsset(Containers::Scene& scene, const AZStd::string& path, const Uuid& guid,
                     RequestingApplication requester) override;
 
+                static void GetProvidedServices(ComponentDescriptor::DependencyArrayType& provided);
+
             private:
-                static const char* s_extension;
+
+                SceneImporterSettings m_settings;
+
+                static constexpr const char* SettingsFilename = "AssetImporterSettings.json";
             };
         } // namespace FbxSceneImporter
     } // namespace SceneAPI

Code/Tools/SceneAPI/FbxSceneBuilder/Importers/AssImpMeshImporter.cpp

@@ -37,7 +37,7 @@ namespace AZ
                 SerializeContext* serializeContext = azrtti_cast<SerializeContext*>(context);
                 if (serializeContext)
                 {
-                    serializeContext->Class<AssImpMeshImporter, SceneCore::LoadingComponent>()->Version(1);
+                    serializeContext->Class<AssImpMeshImporter, SceneCore::LoadingComponent>()->Version(2);
                 }
             }
 

Code/Tools/SceneAPI/SceneCore/Events/AssetImportRequest.h

@@ -71,6 +71,11 @@ namespace AZ
                 static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Multiple;
                 using MutexType = AZStd::recursive_mutex;
 
+                static AZ::Crc32 GetAssetImportRequestComponentTag()
+                {
+                    return AZ_CRC_CE("AssetImportRequest");
+                }
+                
                 virtual ~AssetImportRequest() = 0;
 
                 //! Fills the given list with all available file extensions, excluding the extension for the manifest.

Gems/Atom/Asset/Shader/Code/Source/Editor/ShaderBuilderUtility.cpp

@@ -738,7 +738,7 @@ namespace AZ
                 }
                 else if (platformIdentifier == "mac")
                 {
-                    platformId = AzFramework::PlatformId::MAC;
+                    platformId = AzFramework::PlatformId::MAC_ID;
                 }
                 else if (platformIdentifier == "android")
                 {
@@ -790,7 +790,7 @@ namespace AZ
                 }
                 else if (platform == "mac")
                 {
-                    platformId = AzFramework::PlatformId::MAC;
+                    platformId = AzFramework::PlatformId::MAC_ID;
                 }
                 else if (platform == "android")
                 {

Gems/Atom/Feature/Common/Code/Source/Decals/DecalFeatureProcessor.cpp

@@ -279,7 +279,7 @@ namespace AZ
             if (handle.IsValid())
             {
                 Quaternion orientation = world.GetRotation();
-                Vector3 scale = world.GetScale() * nonUniformScale;
+                Vector3 scale = world.GetUniformScale() * nonUniformScale;
 
                 SetDecalHalfSize(handle, scale);
                 SetDecalPosition(handle, world.GetTranslation());

Gems/Atom/Feature/Common/Code/Source/Decals/DecalTextureArrayFeatureProcessor.cpp

@@ -285,7 +285,7 @@ namespace AZ
         {
             if (handle.IsValid())
             {
-                SetDecalHalfSize(handle, nonUniformScale * world.GetScale());
+                SetDecalHalfSize(handle, nonUniformScale * world.GetUniformScale());
                 SetDecalPosition(handle, world.GetTranslation());
                 SetDecalOrientation(handle, world.GetRotation());
 

Gems/Atom/Feature/Common/Code/Source/ReflectionProbe/ReflectionProbe.cpp

@@ -209,7 +209,7 @@ namespace AZ
         void ReflectionProbe::SetTransform(const AZ::Transform& transform)
         {
             // retrieve previous scale and revert the scale on the inner/outer extents
-            AZ::Vector3 previousScale = m_transform.GetScale();
+            float previousScale = m_transform.GetUniformScale();
             m_outerExtents /= previousScale;
             m_innerExtents /= previousScale;
 
@@ -218,12 +218,12 @@ namespace AZ
 
             // avoid scaling the visualization sphere
             AZ::Transform visualizationTransform = m_transform;
-            visualizationTransform.ExtractScale();
+            visualizationTransform.ExtractUniformScale();
             m_meshFeatureProcessor->SetTransform(m_visualizationMeshHandle, visualizationTransform);
 
             // update the inner/outer extents with the new scale
-            m_outerExtents *= m_transform.GetScale();
-            m_innerExtents *= m_transform.GetScale();
+            m_outerExtents *= m_transform.GetUniformScale();
+            m_innerExtents *= m_transform.GetUniformScale();
 
             m_outerAabbWs = Aabb::CreateCenterHalfExtents(m_transform.GetTranslation(), m_outerExtents / 2.0f);
             m_innerAabbWs = Aabb::CreateCenterHalfExtents(m_transform.GetTranslation(), m_innerExtents / 2.0f);
@@ -232,14 +232,14 @@ namespace AZ
 
         void ReflectionProbe::SetOuterExtents(const AZ::Vector3& outerExtents)
         {
-            m_outerExtents = outerExtents * m_transform.GetScale();
+            m_outerExtents = outerExtents * m_transform.GetUniformScale();
             m_outerAabbWs = Aabb::CreateCenterHalfExtents(m_transform.GetTranslation(), m_outerExtents / 2.0f);
             m_updateSrg = true;
         }
 
         void ReflectionProbe::SetInnerExtents(const AZ::Vector3& innerExtents)
         {
-            m_innerExtents = innerExtents * m_transform.GetScale();
+            m_innerExtents = innerExtents * m_transform.GetUniformScale();
             m_innerAabbWs = Aabb::CreateCenterHalfExtents(m_transform.GetTranslation(), m_innerExtents / 2.0f);
             m_updateSrg = true;
         }

Gems/Atom/RHI/Code/Source/RHI.Edit/ShaderCompilerArguments.cpp

@@ -164,7 +164,7 @@ namespace AZ
                 arguments += " -Zi";  // Generate debug information
                 arguments += " -Zss"; // Compute Shader Hash considering source information
             }
-            arguments += m_dxcAdditionalFreeArguments;
+            arguments += " " + m_dxcAdditionalFreeArguments;
             return arguments;
         }
     }

Gems/Atom/RHI/Vulkan/Code/Source/RHI/NullDescriptorManager.cpp

@@ -180,6 +180,7 @@ namespace AZ
             for (uint32_t imageIndex = static_cast<uint32_t>(NullDescriptorManager::ImageTypes::General2D); imageIndex < static_cast<uint32_t>(NullDescriptorManager::ImageTypes::Count); imageIndex++)
             {
                 // different options for the images
+                imageCreateInfo.imageType = (imageIndex >= static_cast<uint32_t>(NullDescriptorManager::ImageTypes::General3D)) ? VK_IMAGE_TYPE_3D : VK_IMAGE_TYPE_2D;
                 imageCreateInfo.extent = { m_imageNullDescriptor.m_images[imageIndex].m_dimension, m_imageNullDescriptor.m_images[imageIndex].m_dimension, 1 };
                 imageCreateInfo.samples = m_imageNullDescriptor.m_images[imageIndex].m_sampleCountFlag;
                 imageCreateInfo.format = m_imageNullDescriptor.m_images[imageIndex].m_format;

Gems/Atom/RPI/Code/Source/RPI.Public/GpuQuery/Query.cpp

@@ -96,12 +96,6 @@ namespace AZ
                 return QueryResultCode::Fail;
             }
 
-            // Limit calling BeginQuery() to the first CommandList in the array.
-            if (context.GetCommandListIndex() != 0)
-            {
-                return QueryResultCode::Success;
-            }
-
             const auto rhiQueryIndices = GetRhiQueryIndicesFromCurrentFrame();
             if (!rhiQueryIndices)
             {
@@ -124,12 +118,6 @@ namespace AZ
                 return QueryResultCode::Fail;
             }
 
-            // Limit calling EndQuery() to the last CommandList in the array.
-            if (context.GetCommandListIndex() != context.GetCommandListCount() - 1)
-            {
-                return QueryResultCode::Success;
-            }
-
             // Validate that the queries are recorded for the same scope.
             if (m_cachedScopeId != context.GetScopeId())
             {

Gems/Atom/RPI/Code/Source/RPI.Public/Pass/RenderPass.cpp

@@ -522,8 +522,11 @@ namespace AZ
                 }
             };
 
-            ExecuteOnTimestampQuery(beginQuery);
-            ExecuteOnPipelineStatisticsQuery(beginQuery);
+            if (context.GetCommandListIndex() == 0)
+            {
+                ExecuteOnTimestampQuery(beginQuery);
+                ExecuteOnPipelineStatisticsQuery(beginQuery);
+            }
         }
 
         void RenderPass::EndScopeQuery(const RHI::FrameGraphExecuteContext& context)
@@ -533,8 +536,23 @@ namespace AZ
                 query->EndQuery(context);
             };
 
-            ExecuteOnTimestampQuery(endQuery);
-            ExecuteOnPipelineStatisticsQuery(endQuery);
+            // This scopy query implmentation should be replaced by
+            // [ATOM-5407] [RHI][Core] - Add GPU timestamp and pipeline statistic support for scopes
+            
+            // For timestamp query, it's okay to execute across different command lists
+            if (context.GetCommandListIndex() == context.GetCommandListCount() - 1)
+            {
+                ExecuteOnTimestampQuery(endQuery);
+            }
+            // For all the other types of queries except timestamp, the query start and end has to be in the same command list
+            // Here only tracks the PipelineStatistics for the first command list due to that we don't know how many queries are
+            // needed when AddScopeQueryToFrameGraph is called.
+            // This implementation leads to an issue that we may not get accurate pipeline statistic data
+            // for passes which were executed with more than one command list
+            if (context.GetCommandListIndex() == 0)
+            {
+                ExecuteOnPipelineStatisticsQuery(endQuery);
+            }
         }
 
         void RenderPass::ReadbackScopeQueryResults()

Gems/Atom/RPI/Code/Tests/System/GpuQueryTests.cpp

@@ -159,7 +159,9 @@ namespace UnitTest
         const uint32_t ResultSize = sizeof(uint64_t);
 
         uint64_t mockData;
-        const RHI::FrameGraphExecuteContext::Descriptor desc = {};
+        RHI::FrameGraphExecuteContext::Descriptor desc = {};
+        uint64_t dummyCommandList;
+        desc.m_commandList = reinterpret_cast<RHI::CommandList*>(&dummyCommandList);
         RHI::FrameGraphExecuteContext context(desc);
 
         RHI::Scope scope;
@@ -209,7 +211,9 @@ namespace UnitTest
         const uint32_t ResultSize = sizeof(uint64_t) * 4u;
 
         uint64_t mockData;
-        const RHI::FrameGraphExecuteContext::Descriptor desc = {};
+        RHI::FrameGraphExecuteContext::Descriptor desc = {};
+        uint64_t dummyCommandList;
+        desc.m_commandList = reinterpret_cast<RHI::CommandList*>(&dummyCommandList);
         RHI::FrameGraphExecuteContext context(desc);
 
         RHI::Scope scope;
@@ -273,7 +277,9 @@ namespace UnitTest
         const uint32_t ResultSize = sizeof(uint64_t) * 2u;
 
         uint64_t mockData;
-        const RHI::FrameGraphExecuteContext::Descriptor desc = {};
+        RHI::FrameGraphExecuteContext::Descriptor desc = {};
+        uint64_t dummyCommandList;
+        desc.m_commandList = reinterpret_cast<RHI::CommandList*>(&dummyCommandList);
         RHI::FrameGraphExecuteContext context(desc);
 
         RHI::Scope scope;

Gems/AtomLyIntegration/AtomViewportDisplayInfo/Code/Source/AtomViewportDisplayInfoSystemComponent.cpp

@@ -18,10 +18,11 @@
 
 #include <AzCore/Console/IConsole.h>
 #include <AzCore/Interface/Interface.h>
+#include <Atom/RPI.Public/Pass/ParentPass.h>
+#include <Atom/RPI.Public/RenderPipeline.h>
 #include <Atom/RPI.Public/ViewportContextBus.h>
 #include <Atom/RPI.Public/ViewportContext.h>
 #include <Atom/RPI.Public/View.h>
-#include <Atom/RPI.Public/Pass/ParentPass.h>
 #include <Atom/RHI/Factory.h>
 
 #include <CryCommon/ISystem.h>
@@ -146,7 +147,7 @@ namespace AZ::Render
 
         if (m_updateRootPassQuery)
         {
-            if (auto rootPass = AZ::RPI::PassSystemInterface::Get()->GetRootPass())
+            if (auto rootPass = viewportContext->GetCurrentPipeline()->GetRootPass())
             {
                 rootPass->SetPipelineStatisticsQueryEnabled(displayLevel != AtomBridge::ViewportInfoDisplayState::CompactInfo);
                 m_updateRootPassQuery = false;
@@ -226,7 +227,8 @@ namespace AZ::Render
 
     void AtomViewportDisplayInfoSystemComponent::DrawPassInfo()
     {
-        auto rootPass = AZ::RPI::PassSystemInterface::Get()->GetRootPass();
+        AZ::RPI::ViewportContextPtr viewportContext = GetViewportContext();
+        auto rootPass = viewportContext->GetCurrentPipeline()->GetRootPass();
         const RPI::PipelineStatisticsResult stats = rootPass->GetLatestPipelineStatisticsResult();
         AZStd::function<int(const AZ::RPI::Ptr<AZ::RPI::Pass>)> containingPassCount = [&containingPassCount](const AZ::RPI::Ptr<AZ::RPI::Pass> pass)
         {

Gems/AtomLyIntegration/CommonFeatures/Code/Source/Animation/EditorAttachmentComponent.cpp

@@ -21,18 +21,42 @@ namespace AZ
 {
     namespace Render
     {
+        bool EditorAttachmentComponentVersionConverter(AZ::SerializeContext& context, AZ::SerializeContext::DataElementNode& classElement)
+        {
+            if (classElement.GetVersion() < 2)
+            {
+                float uniformScaleOffset = 1.0f;
+
+                int scaleElementIndex = classElement.FindElement(AZ_CRC_CE("Scale Offset"));
+                if (scaleElementIndex != -1)
+                {
+                    AZ::Vector3 oldScaleValue = AZ::Vector3::CreateOne();
+                    AZ::SerializeContext::DataElementNode& dataElementNode = classElement.GetSubElement(scaleElementIndex);
+                    if (dataElementNode.GetData<AZ::Vector3>(oldScaleValue))
+                    {
+                        uniformScaleOffset = oldScaleValue.GetMaxElement();
+                    }
+                    classElement.RemoveElement(scaleElementIndex);
+                }
+
+                classElement.AddElementWithData(context, "Uniform Scale Offset", uniformScaleOffset);
+            }
+
+            return true;
+        }
+
         void EditorAttachmentComponent::Reflect(AZ::ReflectContext* context)
         {
             AZ::SerializeContext* serializeContext = azrtti_cast<AZ::SerializeContext*>(context);
             if (serializeContext)
             {
                 serializeContext->Class<EditorAttachmentComponent, EditorComponentBase>()
-                    ->Version(1)
+                    ->Version(2, &EditorAttachmentComponentVersionConverter)
                     ->Field("Target ID", &EditorAttachmentComponent::m_targetId)
                     ->Field("Target Bone Name", &EditorAttachmentComponent::m_targetBoneName)
                     ->Field("Position Offset", &EditorAttachmentComponent::m_positionOffset)
                     ->Field("Rotation Offset", &EditorAttachmentComponent::m_rotationOffset)
-                    ->Field("Scale Offset", &EditorAttachmentComponent::m_scaleOffset)
+                    ->Field("Uniform Scale Offset", &EditorAttachmentComponent::m_uniformScaleOffset)
                     ->Field("Attached Initially", &EditorAttachmentComponent::m_attachedInitially)
                     ->Field("Scale Source", &EditorAttachmentComponent::m_scaleSource);
 
@@ -70,7 +94,7 @@ namespace AZ
                         ->Attribute(AZ::Edit::Attributes::Min, -AZ::RadToDeg(AZ::Constants::TwoPi))
                         ->Attribute(AZ::Edit::Attributes::Max, AZ::RadToDeg(AZ::Constants::TwoPi))
                         ->Attribute(AZ::Edit::Attributes::ChangeNotify, &EditorAttachmentComponent::OnTargetOffsetChanged)
-                        ->DataElement(0, &EditorAttachmentComponent::m_scaleOffset, "Scale offset", "Local scale offset from target entity")
+                        ->DataElement(0, &EditorAttachmentComponent::m_uniformScaleOffset, "Scale offset", "Local scale offset from target entity")
                         ->Attribute(AZ::Edit::Attributes::Step, 0.1f)
                         ->Attribute(AZ::Edit::Attributes::Min, 0.001f)
                         ->Attribute(AZ::Edit::Attributes::ChangeNotify, &EditorAttachmentComponent::OnTargetOffsetChanged)
@@ -128,7 +152,7 @@ namespace AZ
         {
             AZ::Transform offset = AZ::ConvertEulerDegreesToTransform(m_rotationOffset);
             offset.SetTranslation(m_positionOffset);
-            offset.MultiplyByScale(m_scaleOffset);
+            offset.MultiplyByUniformScale(m_uniformScaleOffset);
             return offset;
         }
 

Gems/AtomLyIntegration/CommonFeatures/Code/Source/Animation/EditorAttachmentComponent.h

@@ -88,7 +88,7 @@ namespace AZ
             AZ::Vector3 m_rotationOffset = AZ::Vector3::CreateZero();
 
             //! Offset from target entity's scale.
-            AZ::Vector3 m_scaleOffset = AZ::Vector3::CreateOne();
+            float m_uniformScaleOffset = 1.0f;
 
             //! Observe scale information from the specified source.       
             AttachmentConfiguration::ScaleSource m_scaleSource = AttachmentConfiguration::ScaleSource::WorldScale;

Gems/AtomLyIntegration/CommonFeatures/Code/Source/CoreLights/QuadLightDelegate.cpp

@@ -76,12 +76,12 @@ namespace AZ
 
         float QuadLightDelegate::GetWidth() const
         {
-            return m_shapeBus->GetQuadWidth() * GetTransform().GetScale().GetX();
+            return m_shapeBus->GetQuadWidth() * GetTransform().GetUniformScale();
         }
 
         float QuadLightDelegate::GetHeight() const
         {
-            return m_shapeBus->GetQuadHeight() * GetTransform().GetScale().GetY();
+            return m_shapeBus->GetQuadHeight() * GetTransform().GetUniformScale();
         }
 
     } // namespace Render

Gems/AtomLyIntegration/TechnicalArt/DccScriptingInterface/3rdParty/Python/.gitignore

@@ -0,0 +1 @@
+pyside2-tools

Gems/AtomLyIntegration/TechnicalArt/DccScriptingInterface/Editor/Scripts/bootstrap.py

@@ -81,8 +81,8 @@ settings = config.get_config_settings()
 if __name__ == '__main__':
     """Run this file as main"""
 
-    _G_DEBUG = True
-    _G_TEST_PYSIDE = True
+    _G_DEBUG = False
+    _G_TEST_PYSIDE = False
     
     _config = get_dccsi_config()
     _settings = config.get_config_settings()
@@ -121,7 +121,6 @@ if __name__ == '__main__':
             import PySide2
 
         _LOGGER.info(f'PySide2: {PySide2}')
-        _LOGGER.info(f'QTFORPYTHON_PATH: {_settings.QTFORPYTHON_PATH}')
         _LOGGER.info(f'LY_BIN_PATH: {_settings.LY_BIN_PATH}')
         _LOGGER.info(f'QT_PLUGIN_PATH: {_settings.QT_PLUGIN_PATH}')
         _LOGGER.info(f'QT_QPA_PLATFORM_PLUGIN_PATH: {_settings.QT_QPA_PLATFORM_PLUGIN_PATH}')

Gems/AtomLyIntegration/TechnicalArt/DccScriptingInterface/Launchers/Windows/Env_Core.bat

@@ -68,14 +68,17 @@ IF "%DEV_REL_PATH%"=="" (set DEV_REL_PATH=..\..\..\..)
 echo     DEV_REL_PATH = %DEV_REL_PATH%
 
 :: You can define the project name
-:: if not defined we just use the DCCsi path as standin
-IF "%LY_PROJECT%"=="" (
-    for %%a in (%CD%..\..\..) do set LY_PROJECT=%%~na
+IF "%LY_PROJECT_NAME%"=="" (
+    for %%a in (%CD%..\..\..) do set LY_PROJECT_NAME=%%~na
         )
+echo     LY_PROJECT_NAME = %LY_PROJECT_NAME%
+
+:: if not defined we just use the DCCsi path as stand-in
+IF "%LY_PROJECT%"=="" (set LY_PROJECT=%CD%)
 echo     LY_PROJECT = %LY_PROJECT%
 
 :: set up the default project path (dccsi)
-:: if not set we lso use the DCCsi path as standin
+:: if not set we also use the DCCsi path as stand-in
 CD /D ..\..\
 IF "%LY_PROJECT_PATH%"=="" (set LY_PROJECT_PATH=%CD%)
 echo     LY_PROJECT_PATH = %LY_PROJECT_PATH%
@@ -88,7 +91,7 @@ pushd %ABS_PATH%
 
 :: Change to root Lumberyard dev dir
 CD /d %LY_PROJECT_PATH%\%DEV_REL_PATH%
-set LY_DEV=%CD%
+IF "%LY_DEV%"=="" (set LY_DEV=%CD%)
 echo     LY_DEV = %LY_DEV%
 :: Restore original directory
 popd

Gems/AtomLyIntegration/TechnicalArt/DccScriptingInterface/SDK/Maya/readme.txt

@@ -29,7 +29,7 @@ A general goal of the DCCsi is be self-maintained, and to not taint the users in
 So we boostrap additional access to site-packages in our userSetup.py:
 "C:\Depot\Lumberyard\Gems\AtomLyIntegration\TechnicalArt\DccScriptingInterface\SDK\Maya\Scripts\userSetup.py"
 
-We don't want users to have to install or use Python2.7 although with maya and possibly other dcc tools we don't have that control.  Maya still is on Python2.7, so instead of forcing another install of python we can just use mayapy to manage extensions.
+We don't want users to have to install or use Python2.7 although with maya and possibly other dcc tools we don't have that control.  Maya 2020 and earlier versions are still on Python2.7, so instead of forcing another install of python we can just use mayapy to manage extensions.
 
 Pip may already be installed, you can check like so (your maya install path may be different):
 

Gems/AtomLyIntegration/TechnicalArt/DccScriptingInterface/SDK/Maya/requirements.txt

@@ -4,14 +4,14 @@
 #
 #    pip-compile --generate-hashes requirements.txt
 #
-cachetools==3.1.1 \
-    --hash=sha256:428266a1c0d36dc5aca63a2d7c5942e88c2c898d72139fca0e97fdd2380517ae \
-    --hash=sha256:8ea2d3ce97850f31e4a08b0e2b5e6c34997d7216a9d2c98e0f3978630d4da69a
-    # via -r requirements.txt
 certifi==2020.6.20 \
     --hash=sha256:5930595817496dd21bb8dc35dad090f1c2cd0adfaf21204bf6732ca5d8ee34d3 \
     --hash=sha256:8fc0819f1f30ba15bdb34cceffb9ef04d99f420f68eb75d901e9560b8749fc41
     # via -r requirements.txt
+cachetools==3.1.1 \
+    --hash=sha256:428266a1c0d36dc5aca63a2d7c5942e88c2c898d72139fca0e97fdd2380517ae \
+    --hash=sha256:8ea2d3ce97850f31e4a08b0e2b5e6c34997d7216a9d2c98e0f3978630d4da69a
+    # via -r requirements.txt
 click==7.1.2 \
     --hash=sha256:d2b5255c7c6349bc1bd1e59e08cd12acbbd63ce649f2588755783aa94dfb6b1a \
     --hash=sha256:dacca89f4bfadd5de3d7489b7c8a566eee0d3676333fbb50030263894c38c0dc
@@ -68,6 +68,16 @@ unipath==1.1 \
     --hash=sha256:09839adcc72e8a24d4f76d63656f30b5a1f721fc40c9bcd79d8c67bdd8b47dae \
     --hash=sha256:e6257e508d8abbfb6ddd8ec357e33589f1f48b1599127f23b017124d90b0fff7
     # via -r requirements.txt
+qdarkstyle==3.0.2 \
+    --hash=sha256:55d149cf5f40ee297397f1818e091118cefb855a4a9c5c38566c47acd2d8c7ae \
+    --hash=sha256:7c791535cc20b3cc1e8e1bf6b88dabe53cb0615983df702be83597e73ada2558
+    # via -r c:\temp\requirements.txt
+qtpy==1.9.0 \
+    --hash=sha256:2db72c44b55d0fe1407be8fba35c838ad0d6d3bb81f23007886dc1fc0f459c8d \
+    --hash=sha256:fa0b8363b363e89b2a6f49eddc162a04c0699ae95e109a6be3bb145a913190ea
+    # via
+    #   -r c:\temp\requirements.txt
+    #   qdarkstyle
 wincertstore==0.2 \
     --hash=sha256:22d5eebb52df88a8d4014d5cf6d1b6c3a5d469e6c3b2e2854f3a003e48872356 \
     --hash=sha256:780bd1557c9185c15d9f4221ea7f905cb20b93f7151ca8ccaed9714dce4b327a

Gems/AtomLyIntegration/TechnicalArt/DccScriptingInterface/azpy/__init__.py

@@ -83,13 +83,13 @@ _LY_DEV = os.getenv(constants.ENVAR_LY_DEV,
                                                      check_stub='engine.json'))
 
 # get/set the project name
-_LY_PROJECT_TAG = os.getenv(constants.ENVAR_LY_PROJECT,
-                            config_utils.get_current_project(_LY_DEV))
+_LY_PROJECT_NAME = os.getenv(constants.ENVAR_LY_PROJECT,
+                            config_utils.get_current_project().name)
 
 # project cache log dir path
 _DCCSI_LOG_PATH = Path(os.getenv(constants.ENVAR_DCCSI_LOG_PATH,
                                  Path(_LY_DEV,
-                                      _LY_PROJECT_TAG,
+                                      _LY_PROJECT_NAME,
                                       'Cache',
                                      'pc', 'user', 'log', 'logs')))
 
@@ -223,7 +223,7 @@ if _G_DEBUG:
 _LOGGER.debug('MODULE_PATH: {}'.format(_MODULE_PATH))
 _LOGGER.debug('LY_DEV_PATH: {}'.format(_LY_DEV))
 _LOGGER.debug('DCCSI_PATH: {}'.format(_DCCSIG_PATH))
-_LOGGER.debug('LY_PROJECT_TAG: {}'.format(_LY_PROJECT_TAG))
+_LOGGER.debug('LY_PROJECT_TAG: {}'.format(_LY_PROJECT_NAME))
 _LOGGER.debug('DCCSI_LOG_PATH: {}'.format(_DCCSI_LOG_PATH))
 
 

Gems/AtomLyIntegration/TechnicalArt/DccScriptingInterface/azpy/config_utils.py

@@ -137,8 +137,9 @@ def get_dccsi_config(dccsi_dirpath=return_stub_dir()):
 
 
 # -------------------------------------------------------------------------
-def get_current_project(dev_folder=get_stub_check_path()):
-    """Uses regex in lumberyard Dev\\bootstrap.cfg to retreive project tag str"""
+def get_current_project_cfg(dev_folder=get_stub_check_path()):
+    """Uses regex in lumberyard Dev\\bootstrap.cfg to retreive project tag str
+    Note: boostrap.cfg will be deprecated.  Don't use this method anymore."""
     boostrap_filepath = Path(dev_folder, "bootstrap.cfg")
     if boostrap_filepath.exists():
         bootstrap = open(str(boostrap_filepath), "r")
@@ -153,6 +154,33 @@ def get_current_project(dev_folder=get_stub_check_path()):
 # -------------------------------------------------------------------------
 
 
+# -------------------------------------------------------------------------
+def get_current_project():
+    """Gets o3de project via .o3de data in user directory"""
+
+    from azpy.constants import PATH_USER_O3DE_BOOTSTRAP
+    from collections import OrderedDict
+    from box import Box
+    
+    bootstrap_box = None
+
+    try:
+        bootstrap_box = Box.from_json(filename=PATH_USER_O3DE_BOOTSTRAP,
+                                     encoding="utf-8",
+                                     errors="strict",
+                                     object_pairs_hook=OrderedDict)
+    except FileExistsError as e:
+        _LOGGER.error('File does not exist: {}'.format(PATH_USER_O3DE_BOOTSTRAP))
+
+    if bootstrap_box:
+        # this seems fairly hard coded - what if the data changes?
+        project_path=Path(bootstrap_box.Amazon.AzCore.Bootstrap.project_path)
+        return project_path.resolve()
+    else:
+        return None
+# -------------------------------------------------------------------------
+
+
 # -------------------------------------------------------------------------
 def bootstrap_dccsi_py_libs(dccsi_dirpath=return_stub_dir()):
     """Builds and adds local site dir libs based on py version"""
@@ -194,7 +222,11 @@ if __name__ == '__main__':
 
     _LOGGER.info('LY_DEV: {}'.format(get_stub_check_path('engine.json')))
 
-    _LOGGER.info('LY_PROJECT: {}'.format(get_current_project(get_stub_check_path('bootstrap.cfg'))))
+    # this will be deprecated and shouldn't work soon (returns None)
+    _LOGGER.info('LY_PROJECT: {}'.format(get_current_project_cfg(get_stub_check_path('bootstrap.cfg'))))
+
+    # new o3de version
+    _LOGGER.info('LY_PROJECT: {}'.format(get_current_project()))
 
     _LOGGER.info('DCCSI_PYTHON_LIB_PATH: {}'.format(bootstrap_dccsi_py_libs(return_stub_dir('dccsi_stub'))))
 

Gems/AtomLyIntegration/TechnicalArt/DccScriptingInterface/azpy/constants.py

@@ -26,6 +26,7 @@ So we can make an update here once that is used elsewhere.
 import os
 import sys
 import site
+from os.path import expanduser
 import logging as _logging
 
 # for this module to perform standalone
@@ -91,6 +92,9 @@ TAG_DIR_DCCSI_SDK = str('SDK')
 TAG_DIR_LY_BUILD = str('build')
 TAG_QT_PLUGIN_PATH = str('QT_PLUGIN_PATH')
 
+TAG_O3DE_FOLDER = str('.o3de')
+TAG_O3DE_BOOTSTRAP = str('bootstrap.setreg')
+
 # filesystem markers, stub file names.
 STUB_LY_DEV = str('engine.json')
 STUB_LY_ROOT_PROJECT = str('ly_project_stub')
@@ -221,10 +225,17 @@ TAG_DEFAULT_PY = str('Launch_pyBASE.bat')
 # config file stuff
 FILENAME_DEFAULT_CONFIG = str('DCCSI_config.json')
 
+# new o3de related paths
+PATH_USER_O3DE = str('{home}\\{o3de}').format(home=expanduser("~"),
+                                              o3de=TAG_O3DE_FOLDER)
+PATH_USER_O3DE_REGISTRY = str('{0}\\Registry').format(PATH_USER_O3DE)
+PATH_USER_O3DE_BOOTSTRAP = str('{reg}\\{file}').format(reg=PATH_USER_O3DE_REGISTRY,
+                                                       file=TAG_O3DE_BOOTSTRAP)
+
 #python and site-dir
 TAG_DCCSI_PY_VERSION_MAJOR = str(3)
 TAG_DCCSI_PY_VERSION_MINOR = str(7)
-TAG_DCCSI_PY_VERSION_RELEASE = str(5)
+TAG_DCCSI_PY_VERSION_RELEASE = str(10)
 TAG_PYTHON_EXE = str('python.exe')
 TAG_TOOLS_DIR = str('Tools\\Python')
 TAG_PLATFORM = str('windows')
@@ -314,6 +325,7 @@ if __name__ == '__main__':
     _stash_dict['QTFORPYTHON_PATH'] = Path(PATH_QTFORPYTHON_PATH)
     _stash_dict['QT_PLUGIN_PATH'] = Path(PATH_QT_PLUGIN_PATH)
     _stash_dict['SAT_INSTALL_PATH'] = Path(PATH_SAT_INSTALL_PATH)
+    _stash_dict['PATH_USER_O3DE_BOOTSTRAP'] = Path(PATH_USER_O3DE_BOOTSTRAP)
 
     # ---------------------------------------------------------------------
     # py 2 and 3 compatible iter    

Gems/AtomLyIntegration/TechnicalArt/DccScriptingInterface/azpy/shared/ui/resources/qdarkstyle/rc/arrow_down.png

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:afe9402162c5b4527f12c863d389ee9d75b53a1069b7e177497beba389d91d35
-size 525

Gems/AtomLyIntegration/TechnicalArt/DccScriptingInterface/azpy/shared/ui/resources/qdarkstyle/rc/arrow_down_disabled.png

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:dc1e37e22cb75f616d6ada02cce006bae7fb1da515b15afea0fc98fcc542a092
-size 547

Gems/AtomLyIntegration/TechnicalArt/DccScriptingInterface/azpy/shared/ui/resources/qdarkstyle/rc/arrow_down_focus.png

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:c7c9c4c8c5bdc755cc026aa23044f546010c0d1e079ecba34ceb8f0eb9e44bde
-size 530

Gems/AtomLyIntegration/TechnicalArt/DccScriptingInterface/azpy/shared/ui/resources/qdarkstyle/rc/arrow_down_pressed.png

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:6111d15f1dc946742b00317bda789a5c625333f65a362f38931dabc50afb2067
-size 518

Gems/AtomLyIntegration/TechnicalArt/DccScriptingInterface/azpy/shared/ui/resources/qdarkstyle/rc/arrow_left.png

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:8ac79e7fbd6be51465e0b685dca32c1236f95ad76ab8c5877ec73d20a1de4365
-size 546

Gems/AtomLyIntegration/TechnicalArt/DccScriptingInterface/azpy/shared/ui/resources/qdarkstyle/rc/arrow_left_disabled.png

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:a86de88cf4ee32c352776caf46d5512d27679da8b571ea7e791287495fad4514
-size 569

Gems/AtomLyIntegration/TechnicalArt/DccScriptingInterface/azpy/shared/ui/resources/qdarkstyle/rc/arrow_left_focus.png

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:5c5b8427bd1497006b8adbcbc445f11b07ec388a3398fe2997f65bdc56f2644f
-size 565

Gems/AtomLyIntegration/TechnicalArt/DccScriptingInterface/azpy/shared/ui/resources/qdarkstyle/rc/arrow_left_pressed.png

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:95ad920de52fd198f1af6d569917be20dc24a39dabdbe6c555c812d424bd9736
-size 541

Gems/AtomLyIntegration/TechnicalArt/DccScriptingInterface/azpy/shared/ui/resources/qdarkstyle/rc/arrow_right.png

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:cb5b2d9b40652764f074dcea9856d6748b0efeac57ef58f306efa999f4b411c1
-size 518

Gems/AtomLyIntegration/TechnicalArt/DccScriptingInterface/azpy/shared/ui/resources/qdarkstyle/rc/arrow_right_disabled.png

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:6a38dcd5b4078df430fa05780844af3e88e0a8e01c1fa910482e4c217354d728
-size 553

Gems/AtomLyIntegration/TechnicalArt/DccScriptingInterface/azpy/shared/ui/resources/qdarkstyle/rc/arrow_right_focus.png

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:5f60b2dfce514a6f558134b942f255ddf81ca3dc77b0d899a87f6d4cbac38e26
-size 543

Gems/AtomLyIntegration/TechnicalArt/DccScriptingInterface/azpy/shared/ui/resources/qdarkstyle/rc/arrow_right_pressed.png

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:84379a7bd6ffa75692648c6fce328616e8a009d7ea3a83c2288f82ecce37e729
-size 544

Gems/AtomLyIntegration/TechnicalArt/DccScriptingInterface/azpy/shared/ui/resources/qdarkstyle/rc/arrow_up.png

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:d7ee7bfb0c60d4687c8a0dcc38a12ee7cacaa2cbb9eb0ae24faa82b992ade445
-size 512

Gems/AtomLyIntegration/TechnicalArt/DccScriptingInterface/azpy/shared/ui/resources/qdarkstyle/rc/arrow_up_disabled.png

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:571b1afb9c2d7e01f56b75e1526dd0a3ffd49a60a4bcb7981ba34823b44a74c0
-size 538

Gems/AtomLyIntegration/TechnicalArt/DccScriptingInterface/azpy/shared/ui/resources/qdarkstyle/rc/arrow_up_focus.png

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:45d805ec94b8144bf121ba74ee96dd27f2f8c0890b2eca5e78df39cb5266f94d
-size 530

Gems/AtomLyIntegration/TechnicalArt/DccScriptingInterface/azpy/shared/ui/resources/qdarkstyle/rc/arrow_up_pressed.png

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:d49428a947ea424fabedd5a08e1d78e0bc57dc8a2d5a231b5d9ec06977870f5a
-size 518