diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SurfaceMaskFilter_BasicSurfaceTagCreation.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SurfaceMaskFilter_BasicSurfaceTagCreation.py
index 4f58a23a19..730a557a9e 100755
--- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SurfaceMaskFilter_BasicSurfaceTagCreation.py
+++ b/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
diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/VegetationInstances_DespawnWhenOutOfRange.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/VegetationInstances_DespawnWhenOutOfRange.py
index c25761d655..46c5483988 100755
--- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/VegetationInstances_DespawnWhenOutOfRange.py
+++ b/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(
diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientGenerators_Incompatibilities.py b/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientGenerators_Incompatibilities.py
index cc9a15bba0..c37bc9780f 100755
--- a/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientGenerators_Incompatibilities.py
+++ b/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
         """
diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientModifiers_Incompatibilities.py b/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientModifiers_Incompatibilities.py
index b7d12d074a..f2edc2924e 100755
--- a/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientModifiers_Incompatibilities.py
+++ b/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
         """
diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientPreviewSettings_ClearingPinnedEntitySetsPreviewToOrigin.py b/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientPreviewSettings_ClearingPinnedEntitySetsPreviewToOrigin.py
index c37ee36265..45da74d6cd 100755
--- a/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientPreviewSettings_ClearingPinnedEntitySetsPreviewToOrigin.py
+++ b/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
 
diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientPreviewSettings_DefaultPinnedEntityIsSelf.py b/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientPreviewSettings_DefaultPinnedEntityIsSelf.py
index 5a758b9d89..b8f4114d30 100755
--- a/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientPreviewSettings_DefaultPinnedEntityIsSelf.py
+++ b/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
         """
diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientSurfaceTagEmitter_ComponentDependencies.py b/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientSurfaceTagEmitter_ComponentDependencies.py
index a16e37e0fc..8e2d0611af 100755
--- a/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientSurfaceTagEmitter_ComponentDependencies.py
+++ b/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
         """
diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientTransform_RequiresShape.py b/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientTransform_RequiresShape.py
index e1e901f2f7..2311363db9 100755
--- a/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientTransform_RequiresShape.py
+++ b/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
         """
diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/ImageGradient_RequiresShape.py b/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/ImageGradient_RequiresShape.py
index dab8e6928a..a5d9632fd6 100755
--- a/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/ImageGradient_RequiresShape.py
+++ b/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
         """
diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/AreaNodes_DependentComponentsAdded.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/AreaNodes_DependentComponentsAdded.py
index d1e0b68ef4..c41d153cfa 100755
--- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/AreaNodes_DependentComponentsAdded.py
+++ b/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
diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/AreaNodes_EntityCreatedOnNodeAdd.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/AreaNodes_EntityCreatedOnNodeAdd.py
index 4e429a192b..fb977b4987 100755
--- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/AreaNodes_EntityCreatedOnNodeAdd.py
+++ b/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]
diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/AreaNodes_EntityRemovedOnNodeDelete.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/AreaNodes_EntityRemovedOnNodeDelete.py
index 38f8641b4c..57ba8fc006 100755
--- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/AreaNodes_EntityRemovedOnNodeDelete.py
+++ b/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]
diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/ComponentUpdates_UpdateGraph.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/ComponentUpdates_UpdateGraph.py
index 26062c01f8..60527b64d2 100755
--- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/ComponentUpdates_UpdateGraph.py
+++ b/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"],
diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/CreateNewGraph.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/CreateNewGraph.py
index 5fed13985d..4b5e03abbc 100755
--- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/CreateNewGraph.py
+++ b/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,
diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/Edit_DisabledNodeDuplication.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/Edit_DisabledNodeDuplication.py
index 7fd3f075e0..81e24b20e1 100755
--- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/Edit_DisabledNodeDuplication.py
+++ b/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]
diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/Edit_UndoNodeDelete_SliceEntity.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/Edit_UndoNodeDelete_SliceEntity.py
index 27ab6fded3..61c4cf9ac2 100755
--- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/Edit_UndoNodeDelete_SliceEntity.py
+++ b/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"],
diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientMixer_NodeConstruction.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientMixer_NodeConstruction.py
index ca3bc04f47..124baf9d2e 100755
--- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientMixer_NodeConstruction.py
+++ b/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
diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientModifierNodes_EntityCreatedOnNodeAdd.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientModifierNodes_EntityCreatedOnNodeAdd.py
index d40b19e7db..aa98eb3dc3 100755
--- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientModifierNodes_EntityCreatedOnNodeAdd.py
+++ b/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
diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientModifierNodes_EntityRemovedOnNodeDelete.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientModifierNodes_EntityRemovedOnNodeDelete.py
index dc263924d1..6a82b05039 100755
--- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientModifierNodes_EntityRemovedOnNodeDelete.py
+++ b/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]
diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientNodes_DependentComponentsAdded.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientNodes_DependentComponentsAdded.py
index 5e203e1892..f9360fe356 100755
--- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientNodes_DependentComponentsAdded.py
+++ b/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
diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientNodes_EntityCreatedOnNodeAdd.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientNodes_EntityCreatedOnNodeAdd.py
index 6d4a2f58a7..8aaad9b81d 100755
--- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientNodes_EntityCreatedOnNodeAdd.py
+++ b/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
diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientNodes_EntityRemovedOnNodeDelete.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientNodes_EntityRemovedOnNodeDelete.py
index 2b49e3a911..d74b86d0bf 100755
--- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientNodes_EntityRemovedOnNodeDelete.py
+++ b/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
diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GraphClosed_OnEntityDelete.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GraphClosed_OnEntityDelete.py
index d3ad5c1c1e..6aa539b554 100755
--- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GraphClosed_OnEntityDelete.py
+++ b/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
diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GraphClosed_OnLevelChange.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GraphClosed_OnLevelChange.py
index b7b0008eb2..ebc75ab621 100755
--- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GraphClosed_OnLevelChange.py
+++ b/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"],
diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GraphClosed_TabbedGraph.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GraphClosed_TabbedGraph.py
index efd1cc5a55..4b018aeb45 100755
--- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GraphClosed_TabbedGraph.py
+++ b/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(
diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GraphUpdates_UpdateComponents.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GraphUpdates_UpdateComponents.py
index f350d37178..f94a6c2e3a 100755
--- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GraphUpdates_UpdateComponents.py
+++ b/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"],
diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/LandscapeCanvasComponent_AddedRemoved.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/LandscapeCanvasComponent_AddedRemoved.py
index 176429885f..c3857e1393 100755
--- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/LandscapeCanvasComponent_AddedRemoved.py
+++ b/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(
diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/LandscapeCanvas_SliceCreateInstantiate.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/LandscapeCanvas_SliceCreateInstantiate.py
index e0f13adaa9..f174a52610 100755
--- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/LandscapeCanvas_SliceCreateInstantiate.py
+++ b/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
         """
 
diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/LayerBlender_NodeConstruction.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/LayerBlender_NodeConstruction.py
index ecc529b9b4..82a2abf5ea 100755
--- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/LayerBlender_NodeConstruction.py
+++ b/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
diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/LayerExtenderNodes_ComponentEntitySync.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/LayerExtenderNodes_ComponentEntitySync.py
index 00fcb5170c..df3c549fff 100755
--- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/LayerExtenderNodes_ComponentEntitySync.py
+++ b/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
diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/ShapeNodes_EntityCreatedOnNodeAdd.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/ShapeNodes_EntityCreatedOnNodeAdd.py
index bd10e5f4c6..cd4915ea24 100755
--- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/ShapeNodes_EntityCreatedOnNodeAdd.py
+++ b/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
diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/ShapeNodes_EntityRemovedOnNodeDelete.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/ShapeNodes_EntityRemovedOnNodeDelete.py
index f71f5ae906..fcfbe03576 100755
--- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/ShapeNodes_EntityRemovedOnNodeDelete.py
+++ b/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]
diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/SlotConnections_UpdateComponentReferences.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/SlotConnections_UpdateComponentReferences.py
index 968f39c64d..183c3f7ccb 100755
--- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/SlotConnections_UpdateComponentReferences.py
+++ b/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',
diff --git a/Code/Framework/AzCore/AzCore/PlatformId/PlatformDefaults.cpp b/Code/Framework/AzCore/AzCore/PlatformId/PlatformDefaults.cpp
index c3f6357706..e31c3b0a1e 100644
--- a/Code/Framework/AzCore/AzCore/PlatformId/PlatformDefaults.cpp
+++ b/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:
diff --git a/Code/Framework/AzCore/AzCore/PlatformId/PlatformDefaults.h b/Code/Framework/AzCore/AzCore/PlatformId/PlatformDefaults.h
index 93477ebeb9..ba8c55f5f5 100644
--- a/Code/Framework/AzCore/AzCore/PlatformId/PlatformDefaults.h
+++ b/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,
diff --git a/Code/Framework/AzCore/Platform/Mac/AzCore/PlatformId/PlatformId_Mac.h b/Code/Framework/AzCore/Platform/Mac/AzCore/PlatformId/PlatformId_Mac.h
index d361e79f05..42dcd3e2f7 100644
--- a/Code/Framework/AzCore/Platform/Mac/AzCore/PlatformId/PlatformId_Mac.h
+++ b/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;
 }
diff --git a/Code/Framework/AzFramework/AzFramework/Archive/Archive.cpp b/Code/Framework/AzFramework/AzFramework/Archive/Archive.cpp
index b0285616df..4a80db2b24 100644
--- a/Code/Framework/AzFramework/AzFramework/Archive/Archive.cpp
+++ b/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;
                 };
diff --git a/Code/Framework/AzFramework/AzFramework/Archive/ArchiveFindData.cpp b/Code/Framework/AzFramework/AzFramework/Archive/ArchiveFindData.cpp
index 678f4e40bf..1794ae90e7 100644
--- a/Code/Framework/AzFramework/AzFramework/Archive/ArchiveFindData.cpp
+++ b/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;
 
diff --git a/Code/Framework/AzManipulatorTestFramework/Include/AzManipulatorTestFramework/ViewportInteraction.h b/Code/Framework/AzManipulatorTestFramework/Include/AzManipulatorTestFramework/ViewportInteraction.h
index 884562d7e8..28971dc779 100644
--- a/Code/Framework/AzManipulatorTestFramework/Include/AzManipulatorTestFramework/ViewportInteraction.h
+++ b/Code/Framework/AzManipulatorTestFramework/Include/AzManipulatorTestFramework/ViewportInteraction.h
@@ -41,6 +41,7 @@ namespace AzManipulatorTestFramework
         AZStd::optional<AZ::Vector3> ViewportScreenToWorld(const AzFramework::ScreenPoint& screenPosition, float depth) override;
         AZStd::optional<AzToolsFramework::ViewportInteraction::ProjectedViewportRay> ViewportScreenToWorldRay(
             const AzFramework::ScreenPoint& screenPosition) override;
+        float DeviceScalingFactor() override;
     private:
         // ViewportInteractionRequestBus ...
         bool GridSnappingEnabled();
diff --git a/Code/Framework/AzManipulatorTestFramework/Source/ViewportInteraction.cpp b/Code/Framework/AzManipulatorTestFramework/Source/ViewportInteraction.cpp
index ebef9dea30..7d32187a74 100644
--- a/Code/Framework/AzManipulatorTestFramework/Source/ViewportInteraction.cpp
+++ b/Code/Framework/AzManipulatorTestFramework/Source/ViewportInteraction.cpp
@@ -127,4 +127,9 @@ namespace AzManipulatorTestFramework
     {
         return {};
     }
-} // namespace AzManipulatorTestFramework
+
+    float ViewportInteraction::DeviceScalingFactor()
+    {
+        return 1.0f;
+    }
+}// namespace AzManipulatorTestFramework
diff --git a/Code/Framework/AzTest/AzTest/Platform/Linux/AzTest_Traits_Linux.h b/Code/Framework/AzTest/AzTest/Platform/Linux/AzTest_Traits_Linux.h
index 0090ce066b..855b4fe416 100644
--- a/Code/Framework/AzTest/AzTest/Platform/Linux/AzTest_Traits_Linux.h
+++ b/Code/Framework/AzTest/AzTest/Platform/Linux/AzTest_Traits_Linux.h
@@ -39,4 +39,3 @@
 #define AZ_TRAIT_DISABLE_FAILED_EMOTION_FX_EDITOR_TESTS true
 #define AZ_TRAIT_DISABLE_FAILED_METRICS_TESTS true
 
-#define AZ_TRAIT_DISABLE_ASSET_JOB_PARALLEL_TESTS true
diff --git a/Code/Framework/AzToolsFramework/AzToolsFramework/Viewport/ViewportMessages.h b/Code/Framework/AzToolsFramework/AzToolsFramework/Viewport/ViewportMessages.h
index 8e91dc945d..91eee18cb7 100644
--- a/Code/Framework/AzToolsFramework/AzToolsFramework/Viewport/ViewportMessages.h
+++ b/Code/Framework/AzToolsFramework/AzToolsFramework/Viewport/ViewportMessages.h
@@ -165,15 +165,18 @@ namespace AzToolsFramework
             virtual bool AngleSnappingEnabled() = 0;
             /// Return the angle snapping/step size.
             virtual float AngleStep() = 0;
-            /// Transform a point in world space to screen space coordinates.
+            /// Transform a point in world space to screen space coordinates in Qt Widget space.
+            /// Multiply by DeviceScalingFactor to get the position in viewport pixel space.
             virtual AzFramework::ScreenPoint ViewportWorldToScreen(const AZ::Vector3& worldPosition) = 0;
-            /// Transform a point in screen space coordinates to a vector in world space based on clip space depth.
+            /// Transform a point from Qt widget screen space to world space based on the given clip space depth.
             /// Depth specifies a relative camera depth to project in the range of [0.f, 1.f].
             /// Returns the world space position if successful.
             virtual AZStd::optional<AZ::Vector3> ViewportScreenToWorld(const AzFramework::ScreenPoint& screenPosition, float depth) = 0;
             /// Casts a point in screen space to a ray in world space originating from the viewport camera frustum's near plane.
             /// Returns a ray containing the ray's origin and a direction normal, if successful.
             virtual AZStd::optional<ProjectedViewportRay> ViewportScreenToWorldRay(const AzFramework::ScreenPoint& screenPosition) = 0;
+            /// Gets the DPI scaling factor that translates Qt widget space into viewport pixel space.
+            virtual float DeviceScalingFactor() = 0;
 
         protected:
             ~ViewportInteractionRequests() = default;
diff --git a/Code/Sandbox/Editor/AzAssetBrowser/AzAssetBrowserRequestHandler.cpp b/Code/Sandbox/Editor/AzAssetBrowser/AzAssetBrowserRequestHandler.cpp
index c8bd157b65..e0ba106875 100644
--- a/Code/Sandbox/Editor/AzAssetBrowser/AzAssetBrowserRequestHandler.cpp
+++ b/Code/Sandbox/Editor/AzAssetBrowser/AzAssetBrowserRequestHandler.cpp
@@ -137,8 +137,20 @@ namespace AzAssetBrowserRequestHandlerPrivate
                     entityName = AZStd::string::format("Entity%d", GetIEditor()->GetObjectManager()->GetObjectCount());
                 }
 
-                AZ::Entity* newEntity = aznew AZ::Entity(entityName.c_str());
-                EditorEntityContextRequestBus::Broadcast(&EditorEntityContextRequests::AddRequiredComponents, *newEntity);
+                AZ::EntityId targetEntityId;
+                EditorRequests::Bus::BroadcastResult(targetEntityId, &EditorRequests::CreateNewEntityAtPosition, worldTransform.GetTranslation(), AZ::EntityId());
+
+                AZ::Entity* newEntity = nullptr;
+                AZ::ComponentApplicationBus::BroadcastResult(newEntity, &AZ::ComponentApplicationRequests::FindEntity, targetEntityId);
+
+                if (newEntity == nullptr)
+                {
+                    return;
+                }
+
+                newEntity->SetName(entityName);
+
+                newEntity->Deactivate();
 
                 // Create component.
                 AZ::Component* newComponent = newEntity->CreateComponent(componentTypeId);
@@ -151,15 +163,7 @@ namespace AzAssetBrowserRequestHandlerPrivate
                     newEntity->AddComponent(newComponent);
                 }
 
-                //  Set entity position.
-                auto* transformComponent = newEntity->FindComponent<Components::TransformComponent>();
-                if (transformComponent)
-                {
-                    transformComponent->SetWorldTM(worldTransform);
-                }
-
-                // Add the entity to the editor context, which activates it and creates the sandbox object.
-                EditorEntityContextRequestBus::Broadcast(&EditorEntityContextRequests::AddEditorEntity, newEntity);
+                newEntity->Activate();
 
                 // set asset after components have been activated in AddEditorEntity method
                 if (newComponent)
diff --git a/Code/Sandbox/Editor/RenderViewport.h b/Code/Sandbox/Editor/RenderViewport.h
index d70dd59b98..b45c92b1c8 100644
--- a/Code/Sandbox/Editor/RenderViewport.h
+++ b/Code/Sandbox/Editor/RenderViewport.h
@@ -200,6 +200,7 @@ public:
     {
         return {};
     }
+    float DeviceScalingFactor() override { return 1.0f; }
 
     // AzToolsFramework::ViewportFreezeRequestBus
     bool IsViewportInputFrozen() override;
diff --git a/Code/Tools/ProjectManager/Resources/ProjectManager.qss b/Code/Tools/ProjectManager/Resources/ProjectManager.qss
index 5eb92964dd..a85b911c15 100644
--- a/Code/Tools/ProjectManager/Resources/ProjectManager.qss
+++ b/Code/Tools/ProjectManager/Resources/ProjectManager.qss
@@ -336,4 +336,31 @@ QTabBar::tab:pressed
     max-width:210px;;
     min-height:278px;
     max-height:278px;
-}
\ No newline at end of file
+}
+
+/************** Gem Catalog **************/
+
+#GemCatalogTitle {
+    font-size: 18px;
+}
+
+/************** Gem Catalog (Inspector) **************/
+
+#GemCatalogInspector {
+    background-color: #444444;
+}
+
+/************** Gem Catalog (Filter/left pane) **************/
+
+#GemCatalogFilterWidget {
+    background-color: #444444;
+}
+
+#GemCatalogHeaderWidget {
+    background-color: #1E252F;
+}
+
+#GemCatalogFilterCategoryTitle {
+    font-size: 12px;
+    font-weight: 600;
+}
diff --git a/Code/Tools/ProjectManager/Source/GemCatalog/GemCatalogHeaderWidget.cpp b/Code/Tools/ProjectManager/Source/GemCatalog/GemCatalogHeaderWidget.cpp
index 6e9ad42017..6402121e4a 100644
--- a/Code/Tools/ProjectManager/Source/GemCatalog/GemCatalogHeaderWidget.cpp
+++ b/Code/Tools/ProjectManager/Source/GemCatalog/GemCatalogHeaderWidget.cpp
@@ -25,10 +25,12 @@ namespace O3DE::ProjectManager
         hLayout->setMargin(0);
         setLayout(hLayout);
 
-        setStyleSheet("background-color: #1E252F;");
+        setObjectName("GemCatalogHeaderWidget");
+
+        hLayout->addSpacing(7);
 
         QLabel* titleLabel = new QLabel(tr("Gem Catalog"));
-        titleLabel->setStyleSheet("font-size: 21px;");
+        titleLabel->setObjectName("GemCatalogTitle");
         hLayout->addWidget(titleLabel);
 
         hLayout->addSpacerItem(new QSpacerItem(0, 0, QSizePolicy::Expanding));
@@ -42,7 +44,7 @@ namespace O3DE::ProjectManager
         hLayout->addWidget(filterLineEdit);
 
         hLayout->addSpacerItem(new QSpacerItem(0, 0, QSizePolicy::Expanding));
-        hLayout->addSpacerItem(new QSpacerItem(220, 0, QSizePolicy::Fixed));
+        hLayout->addSpacerItem(new QSpacerItem(140, 0, QSizePolicy::Fixed));
         
         setFixedHeight(60);
     }
diff --git a/Code/Tools/ProjectManager/Source/GemCatalog/GemFilterWidget.cpp b/Code/Tools/ProjectManager/Source/GemCatalog/GemFilterWidget.cpp
index 3ece7760cf..a6a4e95ff9 100644
--- a/Code/Tools/ProjectManager/Source/GemCatalog/GemFilterWidget.cpp
+++ b/Code/Tools/ProjectManager/Source/GemCatalog/GemFilterWidget.cpp
@@ -43,7 +43,6 @@ namespace O3DE::ProjectManager
         m_collapseButton->setFlat(true);
         m_collapseButton->setFocusPolicy(Qt::NoFocus);
         m_collapseButton->setFixedWidth(s_collapseButtonSize);
-        m_collapseButton->setStyleSheet("border: 0px; border-radius: 0px;");
         connect(m_collapseButton, &QPushButton::clicked, this, [=]()
             {
                 UpdateCollapseState();
@@ -52,7 +51,7 @@ namespace O3DE::ProjectManager
 
         // Category title
         QLabel* headerLabel = new QLabel(header);
-        headerLabel->setStyleSheet("font-size: 11pt;");
+        headerLabel->setObjectName("GemCatalogFilterCategoryTitle");
         collapseLayout->addWidget(headerLabel);
         vLayout->addLayout(collapseLayout);
 
@@ -79,14 +78,14 @@ namespace O3DE::ProjectManager
                 elementWidget->setLayout(elementLayout);
 
                 QCheckBox* checkbox = new QCheckBox(elementNames[i]);
-                checkbox->setStyleSheet("font-size: 11pt;");
+                checkbox->setStyleSheet("font-size: 12px;");
                 m_buttonGroup->addButton(checkbox);
                 elementLayout->addWidget(checkbox);
 
                 elementLayout->addSpacerItem(new QSpacerItem(0, 0, QSizePolicy::Expanding));
 
                 QLabel* countLabel = new QLabel(QString::number(elementCounts[i]));
-                countLabel->setStyleSheet("font-size: 11pt; background-color: #333333; border-radius: 3px; color: #94D2FF;");
+                countLabel->setStyleSheet("font-size: 12px; background-color: #333333; border-radius: 3px; color: #94D2FF;");
                 elementLayout->addWidget(countLabel);
 
                 m_elementWidgets.push_back(elementWidget);
@@ -110,6 +109,8 @@ namespace O3DE::ProjectManager
             }
         }
 
+        vLayout->addSpacing(5);
+
         // Separating line
         QFrame* hLine = new QFrame();
         hLine->setFrameShape(QFrame::HLine);
@@ -181,6 +182,8 @@ namespace O3DE::ProjectManager
         : QScrollArea(parent)
         , m_filterProxyModel(filterProxyModel)
     {
+        setObjectName("GemCatalogFilterWidget");
+
         m_gemModel = m_filterProxyModel->GetSourceModel();
 
         setWidgetResizable(true);
@@ -195,7 +198,7 @@ namespace O3DE::ProjectManager
         mainWidget->setLayout(m_mainLayout);
 
         QLabel* filterByLabel = new QLabel("Filter by");
-        filterByLabel->setStyleSheet("font-size: 15pt;");
+        filterByLabel->setStyleSheet("font-size: 16px;");
         m_mainLayout->addWidget(filterByLabel);
 
         AddGemOriginFilter();
diff --git a/Code/Tools/ProjectManager/Source/GemCatalog/GemInspector.cpp b/Code/Tools/ProjectManager/Source/GemCatalog/GemInspector.cpp
index 6276ddc996..3ecc18231e 100644
--- a/Code/Tools/ProjectManager/Source/GemCatalog/GemInspector.cpp
+++ b/Code/Tools/ProjectManager/Source/GemCatalog/GemInspector.cpp
@@ -23,6 +23,7 @@ namespace O3DE::ProjectManager
         : QScrollArea(parent)
         , m_model(model)
     {
+        setObjectName("GemCatalogInspector");
         setWidgetResizable(true);
         setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
         setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
@@ -85,7 +86,7 @@ namespace O3DE::ProjectManager
     QLabel* GemInspector::CreateStyledLabel(QLayout* layout, int fontSize, const QString& colorCodeString)
     {
         QLabel* result = new QLabel();
-        result->setStyleSheet(QString("font-size: %1pt; color: %2;").arg(QString::number(fontSize), colorCodeString));
+        result->setStyleSheet(QString("font-size: %1px; color: %2;").arg(QString::number(fontSize), colorCodeString));
         layout->addWidget(result);
         return result;
     }
@@ -93,13 +94,13 @@ namespace O3DE::ProjectManager
     void GemInspector::InitMainWidget()
     {
         // Gem name, creator and summary
-        m_nameLabel = CreateStyledLabel(m_mainLayout, 17, s_headerColor);
+        m_nameLabel = CreateStyledLabel(m_mainLayout, 18, s_headerColor);
         m_creatorLabel = CreateStyledLabel(m_mainLayout, 12, s_creatorColor);
         m_mainLayout->addSpacing(5);
 
         // TODO: QLabel seems to have issues determining the right sizeHint() for our font with the given font size.
         // This results into squeezed elements in the layout in case the text is a little longer than a sentence.
-        m_summaryLabel = new QLabel();//CreateLabel(m_mainLayout, 12, s_textColor);
+        m_summaryLabel = CreateStyledLabel(m_mainLayout, 12, s_textColor);
         m_mainLayout->addWidget(m_summaryLabel);
         m_summaryLabel->setWordWrap(true);
         m_mainLayout->addSpacing(5);
@@ -146,9 +147,9 @@ namespace O3DE::ProjectManager
         QLabel* additionalInfoLabel = CreateStyledLabel(m_mainLayout, 14, s_headerColor);
         additionalInfoLabel->setText("Additional Information");
 
-        m_versionLabel = CreateStyledLabel(m_mainLayout, 11, s_textColor);
-        m_lastUpdatedLabel = CreateStyledLabel(m_mainLayout, 11, s_textColor);
-        m_binarySizeLabel = CreateStyledLabel(m_mainLayout, 11, s_textColor);
+        m_versionLabel = CreateStyledLabel(m_mainLayout, 12, s_textColor);
+        m_lastUpdatedLabel = CreateStyledLabel(m_mainLayout, 12, s_textColor);
+        m_binarySizeLabel = CreateStyledLabel(m_mainLayout, 12, s_textColor);
     }
 
     GemInspector::GemsSubWidget::GemsSubWidget(QWidget* parent)
@@ -159,8 +160,8 @@ namespace O3DE::ProjectManager
         m_layout->setMargin(0);
         setLayout(m_layout);
 
-        m_titleLabel = GemInspector::CreateStyledLabel(m_layout, 15, s_headerColor);
-        m_textLabel = GemInspector::CreateStyledLabel(m_layout, 9, s_textColor);
+        m_titleLabel = GemInspector::CreateStyledLabel(m_layout, 16, s_headerColor);
+        m_textLabel = GemInspector::CreateStyledLabel(m_layout, 10, s_textColor);
         m_textLabel->setWordWrap(true);
 
         m_tagWidget = new TagContainerWidget();
diff --git a/Code/Tools/ProjectManager/Source/GemCatalog/GemItemDelegate.cpp b/Code/Tools/ProjectManager/Source/GemCatalog/GemItemDelegate.cpp
index a40e5eb447..57200e3b36 100644
--- a/Code/Tools/ProjectManager/Source/GemCatalog/GemItemDelegate.cpp
+++ b/Code/Tools/ProjectManager/Source/GemCatalog/GemItemDelegate.cpp
@@ -49,7 +49,7 @@ namespace O3DE::ProjectManager
         painter->setRenderHint(QPainter::Antialiasing);
 
         QRect fullRect, itemRect, contentRect;
-        CalcRects(options, modelIndex, fullRect, itemRect, contentRect);
+        CalcRects(options, fullRect, itemRect, contentRect);
 
         QFont standardFont(options.font);
         standardFont.setPixelSize(s_fontSize);
@@ -99,7 +99,7 @@ namespace O3DE::ProjectManager
         painter->drawText(gemCreatorRect, Qt::TextSingleLine, gemCreator);
 
         // Gem summary
-        const QSize summarySize = QSize(contentRect.width() - s_summaryStartX - s_buttonWidth - s_itemMargins.right() * 4, contentRect.height());
+        const QSize summarySize = QSize(contentRect.width() - s_summaryStartX - s_buttonWidth - s_itemMargins.right() * 3, contentRect.height());
         const QRect summaryRect = QRect(/*topLeft=*/QPoint(contentRect.left() + s_summaryStartX, contentRect.top()), summarySize);
 
         painter->setFont(standardFont);
@@ -134,12 +134,10 @@ namespace O3DE::ProjectManager
         return QStyledItemDelegate::editorEvent(event, model, option, modelIndex);
     }
 
-    void GemItemDelegate::CalcRects(const QStyleOptionViewItem& option, const QModelIndex& modelIndex, QRect& outFullRect, QRect& outItemRect, QRect& outContentRect) const
+    void GemItemDelegate::CalcRects(const QStyleOptionViewItem& option, QRect& outFullRect, QRect& outItemRect, QRect& outContentRect) const
     {
-        const bool isFirst = modelIndex.row() == 0;
-
         outFullRect = QRect(option.rect);
-        outItemRect = QRect(outFullRect.adjusted(s_itemMargins.left(), isFirst ? s_itemMargins.top() * 2 : s_itemMargins.top(), -s_itemMargins.right(), -s_itemMargins.bottom()));
+        outItemRect = QRect(outFullRect.adjusted(s_itemMargins.left(), s_itemMargins.top(), -s_itemMargins.right(), -s_itemMargins.bottom()));
         outContentRect = QRect(outItemRect.adjusted(s_contentMargins.left(), s_contentMargins.top(), -s_contentMargins.right(), -s_contentMargins.bottom()));
     }
 
@@ -194,12 +192,12 @@ namespace O3DE::ProjectManager
             painter->setBrush(m_buttonEnabledColor);
             painter->setPen(m_buttonEnabledColor);
 
-            circleCenter = buttonRect.center() + QPoint(buttonRect.width() / 2 - s_buttonBorderRadius, 1);
+            circleCenter = buttonRect.center() + QPoint(buttonRect.width() / 2 - s_buttonBorderRadius + 1, 1);
             buttonText = "Added";
         }
         else
         {
-            circleCenter = buttonRect.center() + QPoint(-buttonRect.width() / 2 + s_buttonBorderRadius + 1, 1);
+            circleCenter = buttonRect.center() + QPoint(-buttonRect.width() / 2 + s_buttonBorderRadius, 1);
             buttonText = "Get";
         }
 
diff --git a/Code/Tools/ProjectManager/Source/GemCatalog/GemItemDelegate.h b/Code/Tools/ProjectManager/Source/GemCatalog/GemItemDelegate.h
index d43b5d15f6..48f173ec3f 100644
--- a/Code/Tools/ProjectManager/Source/GemCatalog/GemItemDelegate.h
+++ b/Code/Tools/ProjectManager/Source/GemCatalog/GemItemDelegate.h
@@ -45,25 +45,25 @@ namespace O3DE::ProjectManager
         const QColor m_buttonEnabledColor = QColor("#00B931");
 
         // Item
-        inline constexpr static int s_height = 135; // Gem item total height
-        inline constexpr static qreal s_gemNameFontSize = 16.0;
-        inline constexpr static qreal s_fontSize = 15.0;
-        inline constexpr static int s_summaryStartX = 200;
+        inline constexpr static int s_height = 105; // Gem item total height
+        inline constexpr static qreal s_gemNameFontSize = 13.0;
+        inline constexpr static qreal s_fontSize = 12.0;
+        inline constexpr static int s_summaryStartX = 150;
 
         // Margin and borders
-        inline constexpr static QMargins s_itemMargins = QMargins(/*left=*/20, /*top=*/10, /*right=*/20, /*bottom=*/10); // Item border distances
-        inline constexpr static QMargins s_contentMargins = QMargins(/*left=*/15, /*top=*/12, /*right=*/12, /*bottom=*/12); // Distances of the elements within an item to the item borders
+        inline constexpr static QMargins s_itemMargins = QMargins(/*left=*/16, /*top=*/8, /*right=*/16, /*bottom=*/8); // Item border distances
+        inline constexpr static QMargins s_contentMargins = QMargins(/*left=*/20, /*top=*/12, /*right=*/15, /*bottom=*/12); // Distances of the elements within an item to the item borders
         inline constexpr static int s_borderWidth = 4;
 
         // Button
-        inline constexpr static int s_buttonWidth = 70;
-        inline constexpr static int s_buttonHeight = 24;
-        inline constexpr static int s_buttonBorderRadius = 12;
-        inline constexpr static int s_buttonCircleRadius = s_buttonBorderRadius - 3;
-        inline constexpr static qreal s_buttonFontSize = 12.0;
+        inline constexpr static int s_buttonWidth = 55;
+        inline constexpr static int s_buttonHeight = 18;
+        inline constexpr static int s_buttonBorderRadius = 9;
+        inline constexpr static int s_buttonCircleRadius = s_buttonBorderRadius - 2;
+        inline constexpr static qreal s_buttonFontSize = 10.0;
 
     private:
-        void CalcRects(const QStyleOptionViewItem& option, const QModelIndex& modelIndex, QRect& outFullRect, QRect& outItemRect, QRect& outContentRect) const;
+        void CalcRects(const QStyleOptionViewItem& option, QRect& outFullRect, QRect& outItemRect, QRect& outContentRect) const;
         QRect GetTextRect(QFont& font, const QString& text, qreal fontSize) const;
         QRect CalcButtonRect(const QRect& contentRect) const;
         void DrawPlatformIcons(QPainter* painter, const QRect& contentRect, const QModelIndex& modelIndex) const;
@@ -73,7 +73,7 @@ namespace O3DE::ProjectManager
 
         // Platform icons
         void AddPlatformIcon(GemInfo::Platform platform, const QString& iconPath);
-        inline constexpr static int s_platformIconSize = 16;
+        inline constexpr static int s_platformIconSize = 12;
         QHash<GemInfo::Platform, QPixmap> m_platformIcons;
     };
 } // namespace O3DE::ProjectManager
diff --git a/Code/Tools/ProjectManager/Source/GemCatalog/GemListHeaderWidget.cpp b/Code/Tools/ProjectManager/Source/GemCatalog/GemListHeaderWidget.cpp
index 128fb93345..bc287e3c61 100644
--- a/Code/Tools/ProjectManager/Source/GemCatalog/GemListHeaderWidget.cpp
+++ b/Code/Tools/ProjectManager/Source/GemCatalog/GemListHeaderWidget.cpp
@@ -35,7 +35,7 @@ namespace O3DE::ProjectManager
         topLayout->addSpacerItem(new QSpacerItem(0, 0, QSizePolicy::Expanding));
 
         QLabel* showCountLabel = new QLabel();
-        showCountLabel->setStyleSheet("font-size: 11pt; font: italic;");
+        showCountLabel->setStyleSheet("font-size: 12px; font: italic;");
         topLayout->addWidget(showCountLabel);
         connect(proxyModel, &GemSortFilterProxyModel::OnInvalidated, this, [=]
             {
@@ -61,16 +61,17 @@ namespace O3DE::ProjectManager
         QHBoxLayout* columnHeaderLayout = new QHBoxLayout();
         columnHeaderLayout->setAlignment(Qt::AlignLeft);
 
-        columnHeaderLayout->addSpacing(31);
+        const int gemNameStartX = GemItemDelegate::s_itemMargins.left() + GemItemDelegate::s_contentMargins.left() - 3;
+        columnHeaderLayout->addSpacing(gemNameStartX);
 
         QLabel* gemNameLabel = new QLabel(tr("Gem Name"));
-        gemNameLabel->setStyleSheet("font-size: 11pt;");
+        gemNameLabel->setStyleSheet("font-size: 12px;");
         columnHeaderLayout->addWidget(gemNameLabel);
 
-        columnHeaderLayout->addSpacing(111);
+        columnHeaderLayout->addSpacing(77);
 
         QLabel* gemSummaryLabel = new QLabel(tr("Gem Summary"));
-        gemSummaryLabel->setStyleSheet("font-size: 11pt;");
+        gemSummaryLabel->setStyleSheet("font-size: 12px;");
         columnHeaderLayout->addWidget(gemSummaryLabel);
 
         vLayout->addLayout(columnHeaderLayout);
diff --git a/Code/Tools/ProjectManager/Source/LinkWidget.cpp b/Code/Tools/ProjectManager/Source/LinkWidget.cpp
index a6308f6c62..160d9cf7c7 100644
--- a/Code/Tools/ProjectManager/Source/LinkWidget.cpp
+++ b/Code/Tools/ProjectManager/Source/LinkWidget.cpp
@@ -37,7 +37,7 @@ namespace O3DE::ProjectManager
 
     void LinkLabel::enterEvent([[maybe_unused]] QEvent* event)
     {
-        setStyleSheet("font-size: 9pt; color: #94D2FF; text-decoration: underline;");
+        setStyleSheet("font-size: 10px; color: #94D2FF; text-decoration: underline;");
     }
 
     void LinkLabel::leaveEvent([[maybe_unused]] QEvent* event)
@@ -52,6 +52,6 @@ namespace O3DE::ProjectManager
 
     void LinkLabel::SetDefaultStyle()
     {
-        setStyleSheet("font-size: 9pt; color: #94D2FF;");
+        setStyleSheet("font-size: 10px; color: #94D2FF;");
     }
 } // namespace O3DE::ProjectManager
diff --git a/Code/Tools/ProjectManager/Source/TagWidget.cpp b/Code/Tools/ProjectManager/Source/TagWidget.cpp
index 3e80944204..628b682b95 100644
--- a/Code/Tools/ProjectManager/Source/TagWidget.cpp
+++ b/Code/Tools/ProjectManager/Source/TagWidget.cpp
@@ -18,9 +18,9 @@ namespace O3DE::ProjectManager
     TagWidget::TagWidget(const QString& text, QWidget* parent)
         : QLabel(text, parent)
     {
-        setFixedHeight(35);
+        setFixedHeight(24);
         setMargin(5);
-        setStyleSheet("font-size: 12pt; background-color: #333333; border-radius: 4px;");
+        setStyleSheet("font-size: 12px; background-color: #333333; border-radius: 3px;");
     }
 
     TagContainerWidget::TagContainerWidget(QWidget* parent)
@@ -35,7 +35,7 @@ namespace O3DE::ProjectManager
     void TagContainerWidget::Update(const QStringList& tags)
     {
         QWidget* parentWidget = qobject_cast<QWidget*>(parent());
-        int width = 250;
+        int width = 200;
         if (parentWidget)
         {
             width = parentWidget->width();
diff --git a/Gems/Atom/Asset/Shader/Code/Source/Editor/ShaderBuilderUtility.cpp b/Gems/Atom/Asset/Shader/Code/Source/Editor/ShaderBuilderUtility.cpp
index 0db53456e0..c256caac4a 100644
--- a/Gems/Atom/Asset/Shader/Code/Source/Editor/ShaderBuilderUtility.cpp
+++ b/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")
                 {
diff --git a/Gems/Atom/Feature/Common/Assets/Materials/Types/EnhancedPBR.materialtype b/Gems/Atom/Feature/Common/Assets/Materials/Types/EnhancedPBR.materialtype
index 954e01c592..4d13663aae 100644
--- a/Gems/Atom/Feature/Common/Assets/Materials/Types/EnhancedPBR.materialtype
+++ b/Gems/Atom/Feature/Common/Assets/Materials/Types/EnhancedPBR.materialtype
@@ -1,5 +1,5 @@
 {
-    "description": "Material Type with properties used to define Enhanced PBR material shading model.",
+    "description": "Material Type with properties used to define Enhanced PBR, a metallic-roughness Physically-Based Rendering (PBR) material shading model, with advanced features like subsurface scattering, transmission, and anisotropy.",
     "propertyLayout": {
         "version": 3,
         "groups": [
@@ -32,7 +32,7 @@
                 "id": "clearCoat",
                 "displayName": "Clear Coat",
                 "description": "Properties for configuring gloss clear coat"
-            },
+            }, 
             {
                 "id": "normal",
                 "displayName": "Normal",
@@ -205,6 +205,13 @@
                         "id": "m_baseColorMap"
                     }
                 },
+                {
+                    "id": "useTexture",
+                    "displayName": "Use Texture",
+                    "description": "Whether to use the texture map.",
+                    "type": "Bool",
+                    "defaultValue": true
+                },
                 {
                     "id": "textureMapUv",
                     "displayName": "UV",
@@ -228,13 +235,6 @@
                         "type": "ShaderOption",
                         "id": "o_baseColorTextureBlendMode"
                     }
-                },
-                {
-                    "id": "useTexture",
-                    "displayName": "Use Texture",
-                    "description": "Whether to use the texture map.",
-                    "type": "Bool",
-                    "defaultValue": true
                 }
             ],
             "metallic": [
@@ -261,6 +261,13 @@
                         "id": "m_metallicMap"
                     }
                 },
+                {
+                    "id": "useTexture",
+                    "displayName": "Use Texture",
+                    "description": "Whether to use the texture map, or just default to the Factor value.",
+                    "type": "Bool",
+                    "defaultValue": true
+                },
                 {
                     "id": "textureMapUv",
                     "displayName": "UV",
@@ -272,29 +279,9 @@
                         "type": "ShaderInput",
                         "id": "m_metallicMapUvIndex"
                     }
-                },
-                {
-                    "id": "useTexture",
-                    "displayName": "Use Texture",
-                    "description": "Whether to use the texture map, or just default to the Factor value.",
-                    "type": "Bool",
-                    "defaultValue": true
                 }
             ],
             "roughness": [
-                {
-                    "id": "factor",
-                    "displayName": "Factor",
-                    "description": "Strength factor for scaling the values",
-                    "type": "Float",
-                    "defaultValue": 1.0,
-                    "min": 0.0,
-                    "max": 1.0,
-                    "connection": {
-                        "type": "ShaderInput",
-                        "id": "m_roughnessFactor"
-                    }
-                },
                 {
                     "id": "textureMap",
                     "displayName": "Texture Map",
@@ -305,6 +292,13 @@
                         "id": "m_roughnessMap"
                     }
                 },
+                {
+                    "id": "useTexture",
+                    "displayName": "Use Texture",
+                    "description": "Whether to use the texture map, or just default to the Factor value.",
+                    "type": "Bool",
+                    "defaultValue": true
+                },
                 {
                     "id": "textureMapUv",
                     "displayName": "UV",
@@ -346,11 +340,18 @@
                     }
                 },
                 {
-                    "id": "useTexture",
-                    "displayName": "Use Texture",
-                    "description": "Whether to use the texture map, or just default to the Factor value.",
-                    "type": "Bool",
-                    "defaultValue": true
+                    // Note that "factor" is mutually exclusive with "lowerBound"/"upperBound". These are swapped by a lua functor.
+                    "id": "factor",
+                    "displayName": "Factor",
+                    "description": "Controls the roughness value",
+                    "type": "Float",
+                    "defaultValue": 1.0,
+                    "min": 0.0,
+                    "max": 1.0,
+                    "connection": {
+                        "type": "ShaderInput",
+                        "id": "m_roughnessFactor"
+                    }
                 }
             ],
             "anisotropy": [
@@ -416,6 +417,13 @@
                         "id": "m_specularF0Map"
                     }
                 },
+                {
+                    "id": "useTexture",
+                    "displayName": "Use Texture",
+                    "description": "Whether to use the texture map, or just default to the Factor value.",
+                    "type": "Bool",
+                    "defaultValue": true
+                },
                 {
                     "id": "textureMapUv",
                     "displayName": "UV",
@@ -428,13 +436,7 @@
                         "id": "m_specularF0MapUvIndex"
                     }
                 },
-                {
-                    "id": "useTexture",
-                    "displayName": "Use Texture",
-                    "description": "Whether to use the texture map, or just default to the Factor value.",
-                    "type": "Bool",
-                    "defaultValue": true
-                },
+                // Consider moving this to the "general" group to be consistent with StandardMultilayerPBR
                 {
                     "id": "enableMultiScatterCompensation",
                     "displayName": "Multiscattering Compensation",
@@ -452,11 +454,7 @@
                     "displayName": "Enable",
                     "description": "Enable clear coat",
                     "type": "Bool",
-                    "defaultValue": false,
-                    "connection": {
-                        "type": "ShaderOption",
-                        "id": "o_clearCoat_feature_enabled"
-                    }
+                    "defaultValue": false
                 },
                 {
                     "id": "factor",
@@ -481,6 +479,13 @@
                         "id": "m_clearCoatInfluenceMap"
                     }
                 },
+                {
+                    "id": "useInfluenceMap",
+                    "displayName": "    Use Texture",
+                    "description": "Whether to use the texture map, or just default to the Factor value.",
+                    "type": "Bool",
+                    "defaultValue": true
+                },
                 {
                     "id": "influenceMapUv",
                     "displayName": "    UV",
@@ -493,13 +498,6 @@
                         "id": "m_clearCoatInfluenceMapUvIndex"
                     }
                 },
-                {
-                    "id": "useInfluenceMap",
-                    "displayName": "    Use Texture",
-                    "description": "Whether to use the texture map, or just default to the Factor value.",
-                    "type": "Bool",
-                    "defaultValue": true
-                },
                 {
                     "id": "roughness",
                     "displayName": "Roughness",
@@ -523,6 +521,13 @@
                         "id": "m_clearCoatRoughnessMap"
                     }
                 },
+                {
+                    "id": "useRoughnessMap",
+                    "displayName": "    Use Texture",
+                    "description": "Whether to use the texture map, or just default to the roughness value.",
+                    "type": "Bool",
+                    "defaultValue": true
+                },
                 {
                     "id": "roughnessMapUv",
                     "displayName": "    UV",
@@ -535,13 +540,6 @@
                         "id": "m_clearCoatRoughnessMapUvIndex"
                     }
                 },
-                {
-                    "id": "useRoughnessMap",
-                    "displayName": "    Use Texture",
-                    "description": "Whether to use the texture map, or just default to the roughness value.",
-                    "type": "Bool",
-                    "defaultValue": true
-                },
                 {
                     "id": "normalStrength",
                     "displayName": "Normal Strength",
@@ -565,9 +563,16 @@
                         "id": "m_clearCoatNormalMap"
                     }
                 },
+                {
+                    "id": "useNormalMap",
+                    "displayName": "    Use Texture",
+                    "description": "Whether to use the normal map",
+                    "type": "Bool",
+                    "defaultValue": true
+                },
                 {
                     "id": "normalMapUv",
-                    "displayName": "UV",
+                    "displayName": "    UV",
                     "description": "Normal texture map UV set",
                     "type": "Enum",
                     "enumIsUv": true,
@@ -576,29 +581,9 @@
                         "type": "ShaderInput",
                         "id": "m_clearCoatNormalMapUvIndex"
                     }
-                },
-                {
-                    "id": "useNormalMap",
-                    "displayName": "Use Texture",
-                    "description": "Whether to use the normal map",
-                    "type": "Bool",
-                    "defaultValue": true
                 }
             ],
             "normal": [
-                {
-                    "id": "factor",
-                    "displayName": "Factor",
-                    "description": "Strength factor for scaling the values",
-                    "type": "Float",
-                    "defaultValue": 1.0,
-                    "min": 0.0,
-                    "softMax": 2.0,
-                    "connection": {
-                        "type": "ShaderInput",
-                        "id": "m_normalFactor"
-                    }
-                },
                 {
                     "id": "textureMap",
                     "displayName": "Texture Map",
@@ -609,6 +594,13 @@
                         "id": "m_normalMap"
                     }
                 },
+                {
+                    "id": "useTexture",
+                    "displayName": "Use Texture",
+                    "description": "Whether to use the texture map, or just rely on vertex normals.",
+                    "type": "Bool",
+                    "defaultValue": true
+                },
                 {
                     "id": "textureMapUv",
                     "displayName": "UV",
@@ -621,13 +613,6 @@
                         "id": "m_normalMapUvIndex"
                     }
                 },
-                {
-                    "id": "useTexture",
-                    "displayName": "Use Texture",
-                    "description": "Whether to use the texture map, or just rely on vertex normals.",
-                    "type": "Bool",
-                    "defaultValue": true
-                },
                 {
                     "id": "flipX",
                     "displayName": "Flip X Channel",
@@ -649,6 +634,19 @@
                         "type": "ShaderInput",
                         "id": "m_flipNormalY"
                     }
+                },
+                {
+                    "id": "factor",
+                    "displayName": "Factor",
+                    "description": "Strength factor for scaling the values",
+                    "type": "Float",
+                    "defaultValue": 1.0,
+                    "min": 0.0,
+                    "softMax": 2.0,
+                    "connection": {
+                        "type": "ShaderInput",
+                        "id": "m_normalFactor"
+                    }
                 }
             ],
             "opacity": [
@@ -725,7 +723,7 @@
                     "description": "Center point for scaling and rotation transformations.",
                     "type": "vector2",
                     "vectorLabels": [ "U", "V" ],
-                    "defaultValue": [ 0.0, 0.0 ]
+                    "defaultValue": [ 0.5, 0.5 ]
                 },
                 {
                     "id": "tileU",
@@ -872,18 +870,14 @@
                     "displayName": "Enable",
                     "description": "Enable the emissive group",
                     "type": "Bool",
-                    "defaultValue": false,
-                    "connection": {
-                        "type": "ShaderOption",
-                        "id": "o_emissiveEnabled"
-                    }
+                    "defaultValue": false
                 },
                 {
                     "id": "unit",
                     "displayName": "Units",
                     "description": "The photometric units of the Intensity property.",
                     "type": "Enum",
-                    "enumValues": [ "Ev100" ],
+                    "enumValues": ["Ev100"],
                     "defaultValue": "Ev100"
                 },
                 {
@@ -918,34 +912,27 @@
                         "id": "m_emissiveMap"
                     }
                 },
+                {
+                    "id": "useTexture",
+                    "displayName": "Use Texture",
+                    "description": "Whether to use the texture map.",
+                    "type": "Bool",
+                    "defaultValue": true
+                },
                 {
                     "id": "textureMapUv",
                     "displayName": "UV",
                     "description": "Emissive texture map UV set",
                     "type": "Enum",
-                    "enumValues": [ "UV0", "UV1" ],
-                    "defaultValue": "UV0",
+                    "enumIsUv": true,
+                    "defaultValue": "Tiled",
                     "connection": {
                         "type": "ShaderInput",
                         "id": "m_emissiveMapUvIndex"
                     }
-                },
-                {
-                    "id": "useTexture",
-                    "displayName": "Use Texture",
-                    "description": "Whether to use the texture map.",
-                    "type": "Bool",
-                    "defaultValue": true
                 }
             ],
             "parallax": [
-                {
-                    "id": "enable",
-                    "displayName": "Enable",
-                    "description": "Whether to enable the parallax feature.",
-                    "type": "Bool",
-                    "defaultValue": false
-                },
                 {
                     "id": "textureMap",
                     "displayName": "Texture Map",
@@ -956,13 +943,20 @@
                         "id": "m_depthMap"
                     }
                 },
+                {
+                    "id": "useTexture",
+                    "displayName": "Use Texture",
+                    "description": "Whether to use the texture map.",
+                    "type": "Bool",
+                    "defaultValue": true
+                },
                 {
                     "id": "textureMapUv",
                     "displayName": "UV",
                     "description": "Depth texture map UV set",
                     "type": "Enum",
-                    "enumValues": [ "UV0", "UV1" ],
-                    "defaultValue": "UV0",
+                    "enumIsUv": true,
+                    "defaultValue": "Tiled",
                     "connection": {
                         "type": "ShaderInput",
                         "id": "m_parallaxUvIndex"
@@ -973,7 +967,7 @@
                     "displayName": "Heightmap Scale",
                     "description": "The total height of the heightmap in local model units.",
                     "type": "Float",
-                    "defaultValue": 0.0,
+                    "defaultValue": 0.05,
                     "min": 0.0,
                     "softMax": 0.1,
                     "connection": {
@@ -1011,7 +1005,7 @@
                     "description": "Select the algorithm to use for parallax mapping.",
                     "type": "Enum",
                     "enumValues": [ "Basic", "Steep", "POM", "Relief", "ContactRefinement" ],
-                    "defaultValue": "Basic",
+                    "defaultValue": "POM",
                     "connection": {
                         "type": "ShaderOption",
                         "id": "o_parallax_algorithm"
@@ -1055,7 +1049,7 @@
             "subsurfaceScattering": [
                 {
                     "id": "enableSubsurfaceScattering",
-                    "displayName": "Enable Subsurface Scattering",
+                    "displayName": "Subsurface Scattering",
                     "description": "Enable subsurface scattering feature, this will disable metallic and parallax mapping property due to incompatibility",
                     "type": "Bool",
                     "defaultValue": false,
@@ -1069,7 +1063,7 @@
                     "displayName": "    Factor",
                     "description": "Strength factor for scaling percentage of subsurface scattering effect applied",
                     "type": "float",
-                    "defaultValue": 0.0,
+                    "defaultValue": 1.0,
                     "min": 0.0,
                     "max": 1.0,
                     "connection": {
@@ -1087,25 +1081,25 @@
                         "id": "m_subsurfaceScatteringInfluenceMap"
                     }
                 },
+                {
+                    "id": "useInfluenceMap",
+                    "displayName": "    Use Influence Map",
+                    "description": "Whether to use the texture map as influence mask.",
+                    "type": "Bool",
+                    "defaultValue": true
+                },
                 {
                     "id": "influenceMapUv",
                     "displayName": "    UV",
                     "description": "Influence map UV set",
                     "type": "Enum",
-                    "enumValues": [ "UV0", "UV1" ],
-                    "defaultValue": "UV0",
+                    "enumIsUv": true,
+                    "defaultValue": "Tiled",
                     "connection": {
                         "type": "ShaderInput",
                         "id": "m_subsurfaceScatteringInfluenceMapUvIndex"
                     }
                 },
-                {
-                    "id": "useInfluenceMap",
-                    "displayName": "    Use Influence Map",
-                    "description": "Whether to use the texture map as influence mask.",
-                    "type": "Bool",
-                    "defaultValue": true
-                },
                 {
                     "id": "scatterColor",
                     "displayName": "    Scatter color",
@@ -1136,11 +1130,16 @@
                     }
                 },
                 {
-                    "id": "enableTransmission",
-                    "displayName": "Enable Transmission",
-                    "description": "Enable transmission feature",
-                    "type": "Bool",
-                    "defaultValue": false
+                    "id": "transmissionMode",
+                    "displayName": "Transmission",
+                    "description": "Algorithm used for calculating transmission",
+                    "type": "Enum",
+                    "enumValues": [ "None", "ThickObject", "ThinObject" ],
+                    "defaultValue": "None",
+                    "connection": {
+                        "type": "ShaderOption",
+                        "id": "o_transmission_mode"
+                    }
                 },
                 {
                     "id": "thickness",
@@ -1161,25 +1160,25 @@
                         "id": "m_transmissionThicknessMap"
                     }
                 },
+                {
+                    "id": "useThicknessMap",
+                    "displayName": "    Use Thickness Map",
+                    "description": "Whether to use the thickness map",
+                    "type": "Bool",
+                    "defaultValue": true
+                },
                 {
                     "id": "thicknessMapUv",
                     "displayName": "    UV",
                     "description": "Thickness map UV set",
                     "type": "Enum",
-                    "enumValues": [ "UV0", "UV1" ],
-                    "defaultValue": "UV0",
+                    "enumIsUv": true,
+                    "defaultValue": "Tiled",
                     "connection": {
                         "type": "ShaderInput",
                         "id": "m_transmissionThicknessMapUvIndex"
                     }
                 },
-                {
-                    "id": "useThicknessMap",
-                    "displayName": "    Use Thickness Map",
-                    "description": "Whether to use the thickness map",
-                    "type": "Bool",
-                    "defaultValue": true
-                },
                 {
                     "id": "transmissionTint",
                     "displayName": "    Transmission Tint",
@@ -1187,18 +1186,6 @@
                     "type": "Color",
                     "defaultValue": [ 1.0, 0.8, 0.6 ]
                 },
-                {
-                    "id": "transmissionMode",
-                    "displayName": "    Mode",
-                    "description": "Algorithm used for calculating transmission",
-                    "type": "Enum",
-                    "enumValues": [ "None", "ThickObject", "ThinObject" ],
-                    "defaultValue": "None",
-                    "connection": {
-                        "type": "ShaderOption",
-                        "id": "o_transmission_mode"
-                    }
-                },
                 {
                     "id": "transmissionPower",
                     "displayName": "    Power",
@@ -1287,7 +1274,7 @@
                     }
                 },
                 {
-                    "id": "detailMapsMapUv",
+                    "id": "textureMapUv",
                     "displayName": "Detail Map UVs",
                     "description": "Which UV set to use for detail map texture sampling",
                     "type": "Enum",
@@ -1388,7 +1375,7 @@
                     "description": "Center point for scaling and rotation transformations.",
                     "type": "vector2",
                     "vectorLabels": [ "U", "V" ],
-                    "defaultValue": [ 0.0, 0.0 ]
+                    "defaultValue": [ 0.5, 0.5 ]
                 },
                 {
                     "id": "tileU",
@@ -1506,7 +1493,7 @@
         {
             "file": "Shaders/Depth/DepthPassTransparentMax.shader",
             "tag": "DepthPassTransparentMax"
-        }
+        }        
     ],
     "functors": [
         {
@@ -1549,26 +1536,9 @@
                 "lightUnitProperty": "emissive.unit",
                 "shaderInput": "m_emissiveIntensity",
                 "ev100Index": 0,
-                "nitIndex": 1,
-                "ev100MinMax": [ -10, 20 ],
-                "nitMinMax": [ 0.001, 100000.0 ]
-            }
-        },
-        {
-            // Enable/Disable shader based on different option.
-            "type": "ShaderEnable",
-            "args": {
-                "opacityMode": "opacity.mode",
-                "parallaxEnable": "parallax.enable",
-                "parallaxPdoEnable": "parallax.pdo",
-                "pbrShaderNoEdsIndex": 0,
-                "pbrShaderWithEdsIndex": 1,
-                "shadowShaderNoPSIndex": 2,
-                "shadowShaderWithPSIndex": 3,
-                "depthShaderNoPSIndex": 4,
-                "depthShaderWithPSIndex": 5,
-                "depthShaderTransparentMin": 8,
-                "depthShaderTransparentMax": 9
+                "nitIndex" : 1,
+                "ev100MinMax": [-10, 20],
+                "nitMinMax": [0.001, 100000.0]
             }
         },
         {
@@ -1590,120 +1560,40 @@
                 "tintThickenssShaderInput": "m_transmissionTintThickness"
             }
         },
-        { 
-            // Reads material properties to determine whether a specific texture map should be sampled at runtime, and sets a shader option accordingly.
-            // @param textureProperty    - which material property contains the texture asset reference (or maybe null)
-            // @param useTextureProperty - a boolean flag that toggles whether the texture should be sampled (if it's not null)
-            // @param shaderTags         - which shader in the 'shaders' list above is configured by this functor
-            // @param shaderOption       - the name of a shader option in the AZSL file that controls sampling of this texture
+        {
             "type": "UseTexture",
             "args": {
                 "textureProperty": "baseColor.textureMap",
-                "dependentProperties": ["baseColor.textureMapUv"],
                 "useTextureProperty": "baseColor.useTexture",
-                "shaderTags": [ 
-                    "ForwardPass",
-                    "ForwardPass_EDS"
-                ],
+                "dependentProperties": ["baseColor.textureMapUv", "baseColor.textureBlendMode"],
                 "shaderOption": "o_baseColor_useTexture"
             }
         },
         {
-            // See the comment above for details.
             "type": "UseTexture",
             "args": {
                 "textureProperty": "metallic.textureMap",
-                "dependentProperties": ["metallic.textureMapUv"],
                 "useTextureProperty": "metallic.useTexture",
-                "shaderTags": [ 
-                    "ForwardPass",
-                    "ForwardPass_EDS"
-                ],
+                "dependentProperties": ["metallic.textureMapUv"],
                 "shaderOption": "o_metallic_useTexture"
             }
         },
         {
-            // See the comment above for details.
-            "type": "UseTexture",
-            "args": {
-                "textureProperty": "roughness.textureMap",
-                "dependentProperties": ["roughness.textureMapUv"],
-                "useTextureProperty": "roughness.useTexture",
-                "shaderTags": [ 
-                    "ForwardPass",
-                    "ForwardPass_EDS"
-                ],
-                "shaderOption": "o_roughness_useTexture"
-            }
-        },
-        {
-            // See the comment above for details.
             "type": "UseTexture",
             "args": {
                 "textureProperty": "specularF0.textureMap",
-                "dependentProperties": ["specularF0.textureMapUv"],
                 "useTextureProperty": "specularF0.useTexture",
-                "shaderTags": [ 
-                    "ForwardPass",
-                    "ForwardPass_EDS"
-                ],
+                "dependentProperties": ["specularF0.textureMapUv"],
                 "shaderOption": "o_specularF0_useTexture"
             }
         },
         {
-            // See the comment above for details.
-            "type": "UseTexture",
-            "args": {
-                "textureProperty": "clearCoat.influenceMap",
-                "dependentProperties": ["clearCoat.influenceMapUv"],
-                "useTextureProperty": "clearCoat.useInfluenceMap",
-                "shaderTags": [ 
-                    "ForwardPass",
-                    "ForwardPass_EDS"
-                ],
-                "shaderOption": "o_clearCoat_factor_useTexture"
-            }
-        },
-        {
-            // See the comment above for details.
-            "type": "UseTexture",
-            "args": {
-                "textureProperty": "clearCoat.roughnessMap",
-                "dependentProperties": ["clearCoat.roughnessMapUv"],
-                "useTextureProperty": "clearCoat.useRoughnessMap",
-                "shaderTags": [ 
-                    "ForwardPass",
-                    "ForwardPass_EDS"
-                ],
-                "shaderOption": "o_clearCoat_roughness_useTexture"
-            }
-        },
-        {
-            // See the comment above for details.
-            "type": "UseTexture",
-            "args": {
-                "textureProperty": "clearCoat.normalMap",
-                "dependentProperties": ["clearCoat.normalMapUv"],
-                "useTextureProperty": "clearCoat.useNormalMap",
-                "shaderTags": [ 
-                    "ForwardPass",
-                    "ForwardPass_EDS"
-                ],
-                "shaderOption": "o_clearCoat_normal_useTexture"
-            }
-        },
-        {
-            // See the comment above for details.
             "type": "UseTexture",
             "args": {
                 "textureProperty": "normal.textureMap",
-                "dependentProperties": ["normal.textureMapUv"],
                 "useTextureProperty": "normal.useTexture",
-                "shaderTags": [ 
-                    "ForwardPass",
-                    "ForwardPass_EDS"
-                ],
-                "shaderOption": "o_normal_useTexture"
+                "dependentProperties": ["normal.textureMapUv", "normal.factor", "normal.flipX", "normal.flipY"],
+                "shaderOption": "o_normal_useTexture"    
             }
         },
         {
@@ -1725,341 +1615,39 @@
             }
         },
         {
-            // See the comment above for details.
-            "type": "UseTexture",
-            "args": {
-                "textureProperty": "emissive.textureMap",
-                "dependentProperties": ["emissive.textureMapUv"],
-                "useTextureProperty": "emissive.useTexture",
-                "shaderTags": [ 
-                    "ForwardPass",
-                    "ForwardPass_EDS"
-                ],
-                "shaderOption": "o_emissive_useTexture"
-            }
-        },
-        {
-            // See the comment above for details.
-            "type": "UseTexture",
-            "args": {
-                "textureProperty": "subsurfaceScattering.influenceMap",
-                "dependentProperties": ["subsurfaceScattering.influenceMapUv"],
-                "useTextureProperty": "subsurfaceScattering.useInfluenceMap",
-                "shaderTags": [ 
-                    "ForwardPass",
-                    "ForwardPass_EDS"
-                ],
-                "shaderOption": "o_subsurfaceScattering_useTexture"
-            }
-        },
-        {
-            // See the comment above for details.
-            "type": "UseTexture",
-            "args": {
-                "textureProperty": "subsurfaceScattering.thicknessMap",
-                "dependentProperties": ["subsurfaceScattering.thicknessMapUv"],
-                "useTextureProperty": "subsurfaceScattering.useThicknessMap",
-                "shaderTags": [ 
-                    "ForwardPass",
-                    "ForwardPass_EDS"
-                ],
-                "shaderOption": "o_transmission_useTexture"
-            }
-        },
-        {
-            // Controls visibility for properties in the editor.
-            // @param actions            - a list of actions that are executed in order. visibility will be set when triggerProperty hits the triggerValue.
-            // @param affectedProperties - the properties that are affected by actions.
-            "type": "UpdatePropertyVisibility",
-            "args": {
-                "actions": [
-                    {
-                        "triggerProperty": "emissive.enable",
-                        "triggerValue": true,
-                        "visibility": "Enabled"
-                    },
-                    {
-                        "triggerProperty": "emissive.enable",
-                        "triggerValue": false,
-                        "visibility": "Hidden"
-                    }
-                ],
-                "affectedProperties": [
-                    "emissive.color",
-                    "emissive.intensity",
-                    "emissive.useTexture",
-                    "emissive.unit"
-                ]
-            }
-        },
-        {
-            // Controls visibility for properties in the editor.
-            // @param actions            - a list of actions that are executed in order. visibility will be set when triggerProperty hits the triggerValue.
-            // @param affectedProperties - the properties that are affected by actions.
-            "type": "UpdatePropertyVisibility",
-            "args": {
-                "actions": [
-                    {
-                        "triggerProperty": "emissive.useTexture",
-                        "triggerValue": true,
-                        "visibility": "Enabled"
-                    },
-                    {
-                        "triggerProperty": "emissive.useTexture",
-                        "triggerValue": false,
-                        "visibility": "Disabled"
-                    },
-                    {
-                        "triggerProperty": "emissive.enable",
-                        "triggerValue": false,
-                        "visibility": "Hidden"
-                    }
-                ],
-                "affectedProperties": [
-                    "emissive.textureMap",
-                    "emissive.textureMapUv"
-                ]
-            }
-        },
-        {
-            "type": "UpdatePropertyVisibility",
-            "args": {
-                "actions": [
-                    {
-                        "triggerProperty": "clearCoat.useInfluenceMap",
-                        "triggerValue": true,
-                        "visibility": "Enabled"
-                    },
-                    {
-                        "triggerProperty": "clearCoat.useInfluenceMap",
-                        "triggerValue": false,
-                        "visibility": "Disabled"
-                    },
-                    {
-                        "triggerProperty": "clearCoat.enable",
-                        "triggerValue": false,
-                        "visibility": "Hidden"
-                    }
-                ],
-                "affectedProperties": [
-                    "clearCoat.influenceMap",
-                    "clearCoat.influenceMapUv"
-                ]
-            }
-        },
-        {
-            "type": "UpdatePropertyVisibility",
-            "args": {
-                "actions": [
-                    {
-                        "triggerProperty": "clearCoat.useRoughnessMap",
-                        "triggerValue": true,
-                        "visibility": "Enabled"
-                    },
-                    {
-                        "triggerProperty": "clearCoat.useRoughnessMap",
-                        "triggerValue": false,
-                        "visibility": "Disabled"
-                    },
-                    {
-                        "triggerProperty": "clearCoat.enable",
-                        "triggerValue": false,
-                        "visibility": "Hidden"
-                    }
-                ],
-                "affectedProperties": [
-                    "clearCoat.roughnessMap",
-                    "clearCoat.roughnessMapUv"
-                ]
-            }
-        },
-        {
-            "type": "UpdatePropertyVisibility",
-            "args": {
-                "actions": [
-                    {
-                        "triggerProperty": "clearCoat.useNormalMap",
-                        "triggerValue": true,
-                        "visibility": "Enabled"
-                    },
-                    {
-                        "triggerProperty": "clearCoat.useNormalMap",
-                        "triggerValue": false,
-                        "visibility": "Disabled"
-                    },
-                    {
-                        "triggerProperty": "clearCoat.enable",
-                        "triggerValue": false,
-                        "visibility": "Hidden"
-                    }
-                ],
-                "affectedProperties": [
-                    "clearCoat.normalMap",
-                    "clearCoat.normalMapUv"
-                ]
-            }
-
-        },
-        {
-            "type": "UpdatePropertyVisibility",
-            "args": {
-                "actions": [
-                    {
-                        "triggerProperty": "subsurfaceScattering.useInfluenceMap",
-                        "triggerValue": true,
-                        "visibility": "Enabled"
-                    },
-                    {
-                        "triggerProperty": "subsurfaceScattering.useInfluenceMap",
-                        "triggerValue": false,
-                        "visibility": "Disabled"
-                    },
-                    {
-                        "triggerProperty": "subsurfaceScattering.enableSubsurfaceScattering",
-                        "triggerValue": false,
-                        "visibility": "Hidden"
-                    }
-                ],
-                "affectedProperties": [
-                    "subsurfaceScattering.influenceMap",
-                    "subsurfaceScattering.influenceMapUv"
-                ]
-            }
-        },
-        {
-            "type": "UpdatePropertyVisibility",
+            "type": "Lua",
             "args": {
-                "actions": [
-                    {
-                        "triggerProperty": "subsurfaceScattering.useThicknessMap",
-                        "triggerValue": true,
-                        "visibility": "Enabled"
-                    },
-                    {
-                        "triggerProperty": "subsurfaceScattering.useThicknessMap",
-                        "triggerValue": false,
-                        "visibility": "Disabled"
-                    },
-                    {
-                        "triggerProperty": "subsurfaceScattering.enableTransmission",
-                        "triggerValue": false,
-                        "visibility": "Hidden"
-                    }
-                ],
-                "affectedProperties": [
-                    "subsurfaceScattering.thicknessMap",
-                    "subsurfaceScattering.thicknessMapUv"
-                ]
+                "file": "StandardPBR_ClearCoatState.lua"
             }
         },
         {
-            "type": "UpdatePropertyVisibility",
+            "type": "Lua",
             "args": {
-                "actions": [
-                    {
-                        "triggerProperty": "clearCoat.enable",
-                        "triggerValue": true,
-                        "visibility": "Enabled"
-                    },
-                    {
-                        "triggerProperty": "clearCoat.enable",
-                        "triggerValue": false,
-                        "visibility": "Hidden"
-                    }
-                ],
-                "affectedProperties": [
-                    "clearCoat.factor",
-                    "clearCoat.useInfluenceMap",
-                    "clearCoat.roughness",
-                    "clearCoat.useRoughnessMap",
-                    "clearCoat.useNormalMap"
-                ]
+                "file": "StandardPBR_ClearCoatEnableFeature.lua"
             }
         },
         {
-            "type": "UpdatePropertyVisibility",
+            "type": "Lua",
             "args": {
-                "actions": [
-                    {
-                        "triggerProperty": "subsurfaceScattering.transmissionMode",
-                        "triggerValue": "ThickObject",
-                        "visibility": "Enabled"
-                    },
-                    {
-                        "triggerProperty": "subsurfaceScattering.transmissionMode",
-                        "triggerValue": "None",
-                        "visibility": "Hidden"
-                    },
-                    {
-                        "triggerProperty": "subsurfaceScattering.transmissionMode",
-                        "triggerValue": "ThinObject",
-                        "visibility": "Hidden"
-                    },
-                    {
-                        "triggerProperty": "subsurfaceScattering.enableTransmission",
-                        "triggerValue": false,
-                        "visibility": "Hidden"
-                    }
-                ],
-                "affectedProperties": [
-                    "subsurfaceScattering.transmissionPower",
-                    "subsurfaceScattering.transmissionDistortion",
-                    "subsurfaceScattering.transmissionAttenuation"
-                ]
+                "file": "StandardPBR_EmissiveState.lua"
             }
         },
         {
-            "type": "UpdatePropertyVisibility",
+            "type": "Lua",
             "args": {
-                "actions": [
-                    {
-                        "triggerProperty": "subsurfaceScattering.enableSubsurfaceScattering",
-                        "triggerValue": true,
-                        "visibility": "Enabled"
-                    },
-                    {
-                        "triggerProperty": "subsurfaceScattering.enableSubsurfaceScattering",
-                        "triggerValue": false,
-                        "visibility": "Hidden"
-                    }
-                ],
-                "affectedProperties": [
-                    "subsurfaceScattering.subsurfaceScatterFactor",
-                    "subsurfaceScattering.useInfluenceMap",
-                    "subsurfaceScattering.scatterColor",
-                    "subsurfaceScattering.scatterDistance",
-                    "subsurfaceScattering.quality"
-                ]
+                "file": "StandardPBR_ParallaxState.lua"
             }
         },
         {
-            "type": "UpdatePropertyVisibility",
+            "type": "Lua",
             "args": {
-                "actions": [
-                    {
-                        "triggerProperty": "subsurfaceScattering.enableTransmission",
-                        "triggerValue": true,
-                        "visibility": "Enabled"
-                    },
-                    {
-                        "triggerProperty": "subsurfaceScattering.enableTransmission",
-                        "triggerValue": false,
-                        "visibility": "Hidden"
-                    }
-                ],
-                "affectedProperties": [
-                    "subsurfaceScattering.thickness",
-                    "subsurfaceScattering.useThicknessMap",
-                    "subsurfaceScattering.transmissionTint",
-                    "subsurfaceScattering.transmissionMode",
-                    "subsurfaceScattering.transmissionScale"
-                ]
+                "file": "StandardPBR_Roughness.lua"
             }
         },
         {
             "type": "Lua",
             "args": {
-                "file": "StandardPBR_ParallaxState.lua"
+                "file": "StandardPBR_SubsurfaceState.lua"
             }
         },
         {
@@ -2069,33 +1657,21 @@
             }
         },
         {
-            "type": "OverrideDrawList",
-            "args": {
-                "triggerProperty": "opacity.mode",
-                "triggerValue": "Blended",
-                "shaderIndex": 1,
-                "drawList": "transparent"
-            }
-        },
-        {
-            "type": "OverrideDrawList",
+            "type": "Lua",
             "args": {
-                "triggerProperty": "opacity.mode",
-                "triggerValue": "TintedTransparent",
-                "shaderIndex": 1,
-                "drawList": "transparent"
+                "file": "StandardPBR_HandleOpacityMode.lua"
             }
         },
         {
             "type": "Lua",
             "args": {
-                "file": "StandardPBR_HandleOpacityMode.lua"
+                "file": "MaterialInputs/DetailMapsCommonFunctor.lua"
             }
         },
         {
             "type": "Lua",
             "args": {
-                "file": "MaterialInputs/DetailMapsCommonFunctor.lua"
+                "file": "StandardPBR_ShaderEnable.lua"
             }
         }
     ],
@@ -2104,3 +1680,4 @@
         "UV1": "Unwrapped"
     }
 }
+
diff --git a/Gems/Atom/Feature/Common/Assets/Materials/Types/EnhancedPBR_ForwardPass.azsl b/Gems/Atom/Feature/Common/Assets/Materials/Types/EnhancedPBR_ForwardPass.azsl
index 440bb97c4e..a4fcccb5f5 100644
--- a/Gems/Atom/Feature/Common/Assets/Materials/Types/EnhancedPBR_ForwardPass.azsl
+++ b/Gems/Atom/Feature/Common/Assets/Materials/Types/EnhancedPBR_ForwardPass.azsl
@@ -267,16 +267,16 @@ PbrLightingOutput ForwardPassPS_Common(VSOutput IN, bool isFrontFace, out float
     // Directional light shadow coordinates
     lightingData.shadowCoords = IN.m_shadowCoords;
 
-    // ------- Occlusion -------
-    
-    lightingData.diffuseAmbientOcclusion = GetOcclusionInput(MaterialSrg::m_diffuseOcclusionMap, MaterialSrg::m_sampler, IN.m_uv[MaterialSrg::m_diffuseOcclusionMapUvIndex], MaterialSrg::m_diffuseOcclusionFactor, o_diffuseOcclusion_useTexture);
-    lightingData.specularOcclusion = GetOcclusionInput(MaterialSrg::m_specularOcclusionMap, MaterialSrg::m_sampler, IN.m_uv[MaterialSrg::m_specularOcclusionMapUvIndex], MaterialSrg::m_specularOcclusionFactor, o_specularOcclusion_useTexture);
-
     // ------- Emissive -------
 
     float2 emissiveUv = IN.m_uv[MaterialSrg::m_emissiveMapUvIndex];
     lightingData.emissiveLighting = GetEmissiveInput(MaterialSrg::m_emissiveMap, MaterialSrg::m_sampler, emissiveUv, MaterialSrg::m_emissiveIntensity, MaterialSrg::m_emissiveColor.rgb, o_emissiveEnabled, o_emissive_useTexture);
 
+    // ------- Occlusion -------
+    
+    lightingData.diffuseAmbientOcclusion = GetOcclusionInput(MaterialSrg::m_diffuseOcclusionMap, MaterialSrg::m_sampler, IN.m_uv[MaterialSrg::m_diffuseOcclusionMapUvIndex], MaterialSrg::m_diffuseOcclusionFactor, o_diffuseOcclusion_useTexture);
+    lightingData.specularOcclusion = GetOcclusionInput(MaterialSrg::m_specularOcclusionMap, MaterialSrg::m_sampler, IN.m_uv[MaterialSrg::m_specularOcclusionMapUvIndex], MaterialSrg::m_specularOcclusionFactor, o_specularOcclusion_useTexture);
+
     // ------- Clearcoat -------
     
     // [GFX TODO][ATOM-14603]: Clean up the double uses of these clear coat flags
diff --git a/Gems/Atom/Feature/Common/Assets/Materials/Types/Skin.materialtype b/Gems/Atom/Feature/Common/Assets/Materials/Types/Skin.materialtype
index 101a03b907..f8c49d579c 100644
--- a/Gems/Atom/Feature/Common/Assets/Materials/Types/Skin.materialtype
+++ b/Gems/Atom/Feature/Common/Assets/Materials/Types/Skin.materialtype
@@ -287,6 +287,13 @@
                         "id": "m_specularF0Map"
                     }
                 },
+                {
+                    "id": "useTexture",
+                    "displayName": "Use Texture",
+                    "description": "Whether to use the texture map, or just default to the Factor value.",
+                    "type": "Bool",
+                    "defaultValue": true
+                },
                 {
                     "id": "textureMapUv",
                     "displayName": "UV",
@@ -299,13 +306,7 @@
                         "id": "m_specularF0MapUvIndex"
                     }
                 },
-                {
-                    "id": "useTexture",
-                    "displayName": "Use Texture",
-                    "description": "Whether to use the texture map, or just default to the Factor value.",
-                    "type": "Bool",
-                    "defaultValue": true
-                },
+                // Consider moving this to the "general" group to be consistent with StandardMultilayerPBR
                 {
                     "id": "enableMultiScatterCompensation",
                     "displayName": "Multiscattering Compensation",
@@ -616,7 +617,7 @@
                     "type": "float",
                     "defaultValue": 6.0,
                     "min": 0.0,
-                    "softMax":  20.0
+                    "softMax": 20.0
                 },
                 {
                     "id": "transmissionDistortion",
@@ -909,7 +910,7 @@
                     "description": "Center point for scaling and rotation transformations.",
                     "type": "vector2",
                     "vectorLabels": [ "U", "V" ],
-                    "defaultValue": [ 0.0, 0.0 ]
+                    "defaultValue": [ 0.5, 0.5 ]
                 },
                 {
                     "id": "tileU",
@@ -1011,18 +1012,18 @@
             "type": "HandleSubsurfaceScatteringParameters",
             "args": {
                 "mode": "subsurfaceScattering.transmissionMode",
-                "scale" : "subsurfaceScattering.transmissionScale",
-                "power" : "subsurfaceScattering.transmissionPower",
-                "distortion" : "subsurfaceScattering.transmissionDistortion",
-                "attenuation" : "subsurfaceScattering.transmissionAttenuation",
-                "tintColor" : "subsurfaceScattering.transmissionTint",
-                "thickness" : "subsurfaceScattering.thickness",
+                "scale": "subsurfaceScattering.transmissionScale",
+                "power": "subsurfaceScattering.transmissionPower",
+                "distortion": "subsurfaceScattering.transmissionDistortion",
+                "attenuation": "subsurfaceScattering.transmissionAttenuation",
+                "tintColor": "subsurfaceScattering.transmissionTint",
+                "thickness": "subsurfaceScattering.thickness",
                 "enabled": "subsurfaceScattering.enableSubsurfaceScattering",
-                "scatterDistanceColor" : "subsurfaceScattering.scatterColor",
-                "scatterDistanceIntensity" : "subsurfaceScattering.scatterDistance",
-                "scatterDistanceShaderInput" : "m_scatterDistance",
-                "parametersShaderInput" : "m_transmissionParams",
-                "tintThickenssShaderInput" : "m_transmissionTintThickness"
+                "scatterDistanceColor": "subsurfaceScattering.scatterColor",
+                "scatterDistanceIntensity": "subsurfaceScattering.scatterDistance",
+                "scatterDistanceShaderInput": "m_scatterDistance",
+                "parametersShaderInput": "m_transmissionParams",
+                "tintThickenssShaderInput": "m_transmissionTintThickness"
             }
         },
         {
@@ -1038,8 +1039,8 @@
             "type": "UseTexture",
             "args": {
                 "textureProperty": "specularF0.textureMap",
-                "dependentProperties": ["specularF0.textureMapUv"],
                 "useTextureProperty": "specularF0.useTexture",
+                "dependentProperties": ["specularF0.textureMapUv"],
                 "shaderOption": "o_specularF0_useTexture"
             }
         },
diff --git a/Gems/Atom/Feature/Common/Assets/Materials/Types/StandardMultilayerPBR.materialtype b/Gems/Atom/Feature/Common/Assets/Materials/Types/StandardMultilayerPBR.materialtype
index 274cb4dcb5..ec1298ae77 100644
--- a/Gems/Atom/Feature/Common/Assets/Materials/Types/StandardMultilayerPBR.materialtype
+++ b/Gems/Atom/Feature/Common/Assets/Materials/Types/StandardMultilayerPBR.materialtype
@@ -369,15 +369,14 @@
             ],
             "parallax": [
                 {
+                    // Note parallax is enabled by default so that as soon as a user hooks up displacement settings they will see some parallax applied. 
+                    // The functor that controls parallax will set o_parallax_feature_enabled=false when all the individual layers have no displacement, so
+                    // a default value of true here will not have any initial impact on performance.
                     "id": "enable",
                     "displayName": "Enable",
                     "description": "Whether to enable the parallax feature for this material.",
                     "type": "Bool",
-                    "defaultValue": false,
-                    "connection": {
-                        "type": "ShaderOption",
-                        "id": "o_parallax_feature_enabled"
-                    }
+                    "defaultValue": true
                 }, 
                 {
                     "id": "parallaxUv",
@@ -409,7 +408,7 @@
                     "description": "Quality of parallax mapping.",
                     "type": "Enum",
                     "enumValues": [ "Low", "Medium", "High", "Ultra" ],
-                    "defaultValue": "Medium",
+                    "defaultValue": "Low",
                     "connection": {
                         "type": "ShaderOption",
                         "id": "o_parallax_quality"
@@ -445,7 +444,7 @@
                     "description": "Center point for scaling and rotation transformations.",
                     "type": "vector2",
                     "vectorLabels": [ "U", "V" ],
-                    "defaultValue": [ 0.0, 0.0 ]
+                    "defaultValue": [ 0.5, 0.5 ]
                 },
                 {
                     "id": "tileU",
@@ -1141,7 +1140,7 @@
                     "displayName": "Scale",
                     "description": "The total height of the displacement texture map in local model units.",
                     "type": "Float",
-                    "defaultValue": 0.0,
+                    "defaultValue": 0.05,
                     "min": 0.0,
                     "softMax": 0.1,
                     "connection": {
@@ -1170,7 +1169,7 @@
                     "description": "Center point for scaling and rotation transformations.",
                     "type": "vector2",
                     "vectorLabels": [ "U", "V" ],
-                    "defaultValue": [ 0.0, 0.0 ]
+                    "defaultValue": [ 0.5, 0.5 ]
                 },
                 {
                     "id": "tileU",
@@ -1847,7 +1846,7 @@
                     "displayName": "Scale",
                     "description": "The total height of the displacement texture map in local model units.",
                     "type": "Float",
-                    "defaultValue": 0.0,
+                    "defaultValue": 0.05,
                     "min": 0.0,
                     "softMax": 0.1,
                     "connection": {
@@ -1876,7 +1875,7 @@
                     "description": "Center point for scaling and rotation transformations.",
                     "type": "vector2",
                     "vectorLabels": [ "U", "V" ],
-                    "defaultValue": [ 0.0, 0.0 ]
+                    "defaultValue": [ 0.5, 0.5 ]
                 },
                 {
                     "id": "tileU",
@@ -2553,7 +2552,7 @@
                     "displayName": "Scale",
                     "description": "The total height of the displacement texture map in local model units.",
                     "type": "Float",
-                    "defaultValue": 0.0,
+                    "defaultValue": 0.05,
                     "min": 0.0,
                     "softMax": 0.1,
                     "connection": {
@@ -2582,7 +2581,7 @@
                     "description": "Center point for scaling and rotation transformations.",
                     "type": "vector2",
                     "vectorLabels": [ "U", "V" ],
-                    "defaultValue": [ 0.0, 0.0 ]
+                    "defaultValue": [ 0.5, 0.5 ]
                 },
                 {
                     "id": "tileU",
diff --git a/Gems/Atom/Feature/Common/Assets/Materials/Types/StandardMultilayerPBR_Displacement.lua b/Gems/Atom/Feature/Common/Assets/Materials/Types/StandardMultilayerPBR_Displacement.lua
index 34a067577d..d2bf8f28d3 100644
--- a/Gems/Atom/Feature/Common/Assets/Materials/Types/StandardMultilayerPBR_Displacement.lua
+++ b/Gems/Atom/Feature/Common/Assets/Materials/Types/StandardMultilayerPBR_Displacement.lua
@@ -35,6 +35,10 @@ function GetMaterialPropertyDependencies()
     }
 end
 
+function GetShaderOptionDependencies()
+    return {"o_parallax_feature_enabled"}
+end
+
 -- These values must align with LayerBlendSource in StandardMultilayerPBR_Common.azsli.
 LayerBlendSource_BlendMaskTexture = 0
 LayerBlendSource_BlendMaskVertexColors = 1
@@ -50,6 +54,39 @@ function BlendSourceUsesDisplacement(context)
     return blendSourceIncludesDisplacement
 end
 
+function IsParallaxNeededForLayer(context, layerNumber)
+    local enableLayer = true
+    if(layerNumber > 1) then -- layer 1 is always enabled, it is the implicit base layer
+        enableLayer = context:GetMaterialPropertyValue_bool("blend.enableLayer" .. layerNumber)
+    end
+
+    if not enableLayer then
+        return false
+    end
+    
+    local parallaxGroupName = "layer" .. layerNumber .. "_parallax."
+
+    local factor = context:GetMaterialPropertyValue_float(parallaxGroupName .. "factor")
+    local offset = context:GetMaterialPropertyValue_float(parallaxGroupName .. "offset")
+    
+    if factor == 0.0 and offset == 0.0 then
+        return false
+    end
+
+    local hasTexture = nil ~= context:GetMaterialPropertyValue_Image(parallaxGroupName .. "textureMap")
+    local useTexture = context:GetMaterialPropertyValue_bool(parallaxGroupName .. "useTexture")
+    
+    if not hasTexture or not useTexture then
+        factorLayer = 0.0
+    end
+    
+    if factor == 0.0 and offset == 0.0 then
+        return false
+    end
+    
+    return true
+end
+
 -- Calculates the min and max displacement height values encompassing all enabled layers.
 -- @return a table with two values {min,max}. Negative values are below the surface and positive values are above the surface.
 function CalcOverallHeightRange(context)
@@ -114,21 +151,32 @@ function Process(context)
     local heightMinMax = CalcOverallHeightRange(context)
     context:SetShaderConstant_float("m_displacementMin", heightMinMax[0])
     context:SetShaderConstant_float("m_displacementMax", heightMinMax[1])
+    
+    local parallaxFeatureEnabled = context:GetMaterialPropertyValue_bool("parallax.enable")
+    if parallaxFeatureEnabled then
+        if not IsParallaxNeededForLayer(context, 1) and
+           not IsParallaxNeededForLayer(context, 2) and
+           not IsParallaxNeededForLayer(context, 3) then
+            parallaxFeatureEnabled = false
+        end
+    end
+    
+    context:SetShaderOptionValue_bool("o_parallax_feature_enabled", parallaxFeatureEnabled)
 end
 
 function ProcessEditor(context)
-    local enable = context:GetMaterialPropertyValue_bool("parallax.enable")
+    local enableParallaxSettings = context:GetMaterialPropertyValue_bool("parallax.enable")
     
-    local visibility = MaterialPropertyVisibility_Enabled
-    if(not enable) then
-        visibility = MaterialPropertyVisibility_Hidden
+    local parallaxSettingVisibility = MaterialPropertyVisibility_Enabled
+    if(not enableParallaxSettings) then
+        parallaxSettingVisibility = MaterialPropertyVisibility_Hidden
     end
     
-    context:SetMaterialPropertyVisibility("parallax.parallaxUv", visibility)
-    context:SetMaterialPropertyVisibility("parallax.algorithm", visibility)
-    context:SetMaterialPropertyVisibility("parallax.quality", visibility)
-    context:SetMaterialPropertyVisibility("parallax.pdo", visibility)
-    context:SetMaterialPropertyVisibility("parallax.showClipping", visibility)
+    context:SetMaterialPropertyVisibility("parallax.parallaxUv", parallaxSettingVisibility)
+    context:SetMaterialPropertyVisibility("parallax.algorithm", parallaxSettingVisibility)
+    context:SetMaterialPropertyVisibility("parallax.quality", parallaxSettingVisibility)
+    context:SetMaterialPropertyVisibility("parallax.pdo", parallaxSettingVisibility)
+    context:SetMaterialPropertyVisibility("parallax.showClipping", parallaxSettingVisibility)
     
     if BlendSourceUsesDisplacement(context) then
         context:SetMaterialPropertyVisibility("blend.displacementBlendDistance", MaterialPropertyVisibility_Enabled)
diff --git a/Gems/Atom/Feature/Common/Assets/Materials/Types/StandardPBR.materialtype b/Gems/Atom/Feature/Common/Assets/Materials/Types/StandardPBR.materialtype
index 2b0d09bc5c..ca3e5e1ce4 100644
--- a/Gems/Atom/Feature/Common/Assets/Materials/Types/StandardPBR.materialtype
+++ b/Gems/Atom/Feature/Common/Assets/Materials/Types/StandardPBR.materialtype
@@ -601,7 +601,7 @@
                     "displayName": "Opacity Mode",
                     "description": "Opacity mode for this texture.",
                     "type": "Enum",
-                    "enumValues": [ "Opaque", "Cutout", "Blended" ],
+                    "enumValues": [ "Opaque", "Cutout", "Blended", "TintedTransparent" ],
                     "defaultValue": "Opaque",
                     "connection": {
                         "type": "ShaderOption",
@@ -669,12 +669,12 @@
                     "description": "Center point for scaling and rotation transformations.",
                     "type": "vector2",
                     "vectorLabels": [ "U", "V" ],
-                    "defaultValue": [ 0.0, 0.0 ]
+                    "defaultValue": [ 0.5, 0.5 ]
                 },
                 {
                     "id": "tileU",
                     "displayName": "Tile U",
-                    "description": "Scales texture coordinates in V.",
+                    "description": "Scales texture coordinates in U.",
                     "type": "float",
                     "defaultValue": 1.0,
                     "step": 0.1
@@ -879,13 +879,6 @@
                 }
             ],
             "parallax": [
-                {
-                    "id": "enable",
-                    "displayName": "Enable",
-                    "description": "Whether to enable the parallax feature.",
-                    "type": "Bool",
-                    "defaultValue": false
-                },
                 {
                     "id": "textureMap",
                     "displayName": "Texture Map",
@@ -896,6 +889,13 @@
                         "id": "m_depthMap"
                     }
                 },
+                {
+                    "id": "useTexture",
+                    "displayName": "Use Texture",
+                    "description": "Whether to use the texture map.",
+                    "type": "Bool",
+                    "defaultValue": true
+                },
                 {
                     "id": "textureMapUv",
                     "displayName": "UV",
@@ -913,7 +913,7 @@
                     "displayName": "Heightmap Scale",
                     "description": "The total height of the heightmap in local model units.",
                     "type": "Float",
-                    "defaultValue": 0.0,
+                    "defaultValue": 0.05,
                     "min": 0.0,
                     "softMax": 0.1,
                     "connection": {
@@ -951,7 +951,7 @@
                     "description": "Select the algorithm to use for parallax mapping.",
                     "type": "Enum",
                     "enumValues": [ "Basic", "Steep", "POM", "Relief", "ContactRefinement" ],
-                    "defaultValue": "Basic",
+                    "defaultValue": "POM",
                     "connection": {
                         "type": "ShaderOption",
                         "id": "o_parallax_algorithm"
@@ -1139,7 +1139,7 @@
                     "type": "float",
                     "defaultValue": 6.0,
                     "min": 0.0,
-                    "softMax":  20.0
+                    "softMax": 20.0
                 },
                 {
                     "id": "transmissionDistortion",
@@ -1170,7 +1170,7 @@
                 }
             ],
             "irradiance": [
-                // Note: this property group is used in the DiffuseGlobalIllumination pass, it is not read by the StandardPBR shader
+                // Note: this property group is used in the DiffuseGlobalIllumination pass and not by the main forward shader
                 {
                     "id": "color",
                     "displayName": "Color",
@@ -1277,18 +1277,18 @@
             "type": "HandleSubsurfaceScatteringParameters",
             "args": {
                 "mode": "subsurfaceScattering.transmissionMode",
-                "scale" : "subsurfaceScattering.transmissionScale",
-                "power" : "subsurfaceScattering.transmissionPower",
-                "distortion" : "subsurfaceScattering.transmissionDistortion",
-                "attenuation" : "subsurfaceScattering.transmissionAttenuation",
-                "tintColor" : "subsurfaceScattering.transmissionTint",
-                "thickness" : "subsurfaceScattering.thickness",
+                "scale": "subsurfaceScattering.transmissionScale",
+                "power": "subsurfaceScattering.transmissionPower",
+                "distortion": "subsurfaceScattering.transmissionDistortion",
+                "attenuation": "subsurfaceScattering.transmissionAttenuation",
+                "tintColor": "subsurfaceScattering.transmissionTint",
+                "thickness": "subsurfaceScattering.thickness",
                 "enabled": "subsurfaceScattering.enableSubsurfaceScattering",
-                "scatterDistanceColor" : "subsurfaceScattering.scatterColor",
-                "scatterDistanceIntensity" : "subsurfaceScattering.scatterDistance",
-                "scatterDistanceShaderInput" : "m_scatterDistance",
-                "parametersShaderInput" : "m_transmissionParams",
-                "tintThickenssShaderInput" : "m_transmissionTintThickness"
+                "scatterDistanceColor": "subsurfaceScattering.scatterColor",
+                "scatterDistanceIntensity": "subsurfaceScattering.scatterDistance",
+                "scatterDistanceShaderInput": "m_scatterDistance",
+                "parametersShaderInput": "m_transmissionParams",
+                "tintThickenssShaderInput": "m_transmissionTintThickness"
             }
         },
         {
@@ -1387,15 +1387,6 @@
                 "file": "StandardPBR_HandleOpacityDoubleSided.lua"
             }
         },
-        {
-            "type": "OverrideDrawList",
-            "args": {
-                "triggerProperty": "opacity.mode",
-                "triggerValue": "Blended",
-                "shaderIndex": 1,
-                "drawList": "transparent"
-            }
-        },
         {
             "type": "Lua",
             "args": {
diff --git a/Gems/Atom/Feature/Common/Assets/Materials/Types/StandardPBR_ForwardPass.azsl b/Gems/Atom/Feature/Common/Assets/Materials/Types/StandardPBR_ForwardPass.azsl
index 2667c8123b..10fa3814f3 100644
--- a/Gems/Atom/Feature/Common/Assets/Materials/Types/StandardPBR_ForwardPass.azsl
+++ b/Gems/Atom/Feature/Common/Assets/Materials/Types/StandardPBR_ForwardPass.azsl
@@ -294,6 +294,24 @@ PbrLightingOutput ForwardPassPS_Common(VSOutput IN, bool isFrontFace, out float
         lightingOutput.m_diffuseColor.rgb *= lightingOutput.m_diffuseColor.w; // pre-multiply diffuse
         lightingOutput.m_diffuseColor.rgb += lightingOutput.m_specularColor.rgb; // add specular
     }
+    else if (o_opacity_mode == OpacityMode::TintedTransparent)
+    {
+        // See OpacityMode::Blended above for the basic method. TintedTransparent adds onto the above concept by supporting
+        // colored alpha. This is currently a very basic calculation that uses the baseColor as a multiplier with strength
+        // determined by the alpha. We'll modify this later to be more physically accurate and allow surface depth,
+        // absorption, and interior color to be specified.
+        //
+        // The technique uses dual source blending to allow two separate sources to be part of the blending equation
+        // even though ultimately only a single render target is being written to. m_diffuseColor is render target 0 and
+        // m_specularColor render target 1, and the blend mode is (dest * source1color) + (source * 1.0).
+        //
+        // This means that m_specularColor.rgb (source 1) is multiplied against the destination, then
+        // m_diffuseColor.rgb (source) is added to that, and the final result is stored in render target 0.
+
+        lightingOutput.m_diffuseColor.rgb *= lightingOutput.m_diffuseColor.w; // pre-multiply diffuse
+        lightingOutput.m_diffuseColor.rgb += lightingOutput.m_specularColor.rgb; // add specular
+        lightingOutput.m_specularColor.rgb = baseColor * (1.0 - lightingOutput.m_diffuseColor.w); 
+    }
     else
     {
         // Pack factor and quality, drawback: because of precision limit of float16 cannot represent exact 1, maximum representable value is 0.9961
diff --git a/Gems/Atom/Feature/Common/Assets/Materials/Types/StandardPBR_HandleOpacityMode.lua b/Gems/Atom/Feature/Common/Assets/Materials/Types/StandardPBR_HandleOpacityMode.lua
index 541b1ac1ce..20d3ee47ae 100644
--- a/Gems/Atom/Feature/Common/Assets/Materials/Types/StandardPBR_HandleOpacityMode.lua
+++ b/Gems/Atom/Feature/Common/Assets/Materials/Types/StandardPBR_HandleOpacityMode.lua
@@ -60,10 +60,13 @@ function Process(context)
 
     if(opacityMode == OpacityMode_Blended) then
         ConfigureAlphaBlending(context:GetShader(ForwardPassIndex))
+        context:GetShader(ForwardPassIndex):SetDrawListTagOverride("transparent")
     elseif(opacityMode == OpacityMode_TintedTransparent) then
         ConfigureDualSourceBlending(context:GetShader(ForwardPassIndex))
+        context:GetShader(ForwardPassIndex):SetDrawListTagOverride("transparent")
     else
         ResetAlphaBlending(context:GetShader(ForwardPassIndex))
+        context:GetShader(ForwardPassIndex):SetDrawListTagOverride("") -- reset to default draw list
     end
 end
 
diff --git a/Gems/Atom/Feature/Common/Assets/Materials/Types/StandardPBR_ParallaxState.lua b/Gems/Atom/Feature/Common/Assets/Materials/Types/StandardPBR_ParallaxState.lua
index e6689da327..53d6334f28 100644
--- a/Gems/Atom/Feature/Common/Assets/Materials/Types/StandardPBR_ParallaxState.lua
+++ b/Gems/Atom/Feature/Common/Assets/Materials/Types/StandardPBR_ParallaxState.lua
@@ -13,7 +13,7 @@
 ----------------------------------------------------------------------------------------------------
 
 function GetMaterialPropertyDependencies()
-    return {"parallax.enable", "parallax.textureMap"}
+    return {"parallax.textureMap", "parallax.useTexture"}
 end
 
 function GetShaderOptionDependencies()
@@ -21,27 +21,31 @@ function GetShaderOptionDependencies()
 end
  
 function Process(context)
-    local enable = context:GetMaterialPropertyValue_bool("parallax.enable")
     local textureMap = context:GetMaterialPropertyValue_Image("parallax.textureMap")
+    local useTexture = context:GetMaterialPropertyValue_bool("parallax.useTexture")
+    local enable = textureMap ~= nil and useTexture 
     context:SetShaderOptionValue_bool("o_parallax_feature_enabled", enable)
-    context:SetShaderOptionValue_bool("o_useDepthMap", enable and textureMap ~= nil)
+    context:SetShaderOptionValue_bool("o_useDepthMap", enable)
 end
 
 function ProcessEditor(context)
-    local enable = context:GetMaterialPropertyValue_bool("parallax.enable")
+    local textureMap = context:GetMaterialPropertyValue_Image("parallax.textureMap")
     
-    if enable then
-        context:SetMaterialPropertyVisibility("parallax.textureMap", MaterialPropertyVisibility_Enabled)
+    if textureMap ~= nil then
+        context:SetMaterialPropertyVisibility("parallax.useTexture", MaterialPropertyVisibility_Enabled)
     else 
-        context:SetMaterialPropertyVisibility("parallax.textureMap", MaterialPropertyVisibility_Hidden)
+        context:SetMaterialPropertyVisibility("parallax.useTexture", MaterialPropertyVisibility_Hidden)
     end
     
-    local textureMap = context:GetMaterialPropertyValue_Image("parallax.textureMap")
+    local useTexture = context:GetMaterialPropertyValue_bool("parallax.useTexture")
+
     local visibility = MaterialPropertyVisibility_Enabled
-    if(not enable or textureMap == nil) then
+    if(textureMap == nil) then
         visibility = MaterialPropertyVisibility_Hidden
+    elseif not useTexture then
+        visibility = MaterialPropertyVisibility_Disabled
     end
-    
+        
     context:SetMaterialPropertyVisibility("parallax.factor", visibility)
     context:SetMaterialPropertyVisibility("parallax.offset", visibility)
     context:SetMaterialPropertyVisibility("parallax.showClipping", visibility)
diff --git a/Gems/Atom/Feature/Common/Assets/Materials/Types/StandardPBR_ShaderEnable.lua b/Gems/Atom/Feature/Common/Assets/Materials/Types/StandardPBR_ShaderEnable.lua
index e502eb38f8..b245fde3df 100644
--- a/Gems/Atom/Feature/Common/Assets/Materials/Types/StandardPBR_ShaderEnable.lua
+++ b/Gems/Atom/Feature/Common/Assets/Materials/Types/StandardPBR_ShaderEnable.lua
@@ -13,7 +13,7 @@
 ----------------------------------------------------------------------------------------------------
 
 function GetMaterialPropertyDependencies()
-    return {"opacity.mode", "parallax.enable", "parallax.pdo"}
+    return {"opacity.mode", "parallax.textureMap", "parallax.useTexture", "parallax.pdo"}
 end
 
 OpacityMode_Opaque = 0
@@ -21,41 +21,61 @@ OpacityMode_Cutout = 1
 OpacityMode_Blended = 2
 OpacityMode_TintedTransparent = 3
 
+function TryGetShaderByTag(context, shaderTag)
+    if context:HasShaderWithTag(shaderTag) then
+        return context:GetShaderByTag(shaderTag)
+    else
+        return nil
+    end
+end
+
+function TrySetShaderEnabled(shader, enabled)
+    if shader then 
+        shader:SetEnabled(enabled)
+    end
+end
+
 function Process(context)
     local opacityMode = context:GetMaterialPropertyValue_enum("opacity.mode")
-    local parallaxEnabled = context:GetMaterialPropertyValue_bool("parallax.enable")
+    local displacementMap = context:GetMaterialPropertyValue_Image("parallax.textureMap")
+    local useDisplacementMap = context:GetMaterialPropertyValue_bool("parallax.useTexture")
+    local parallaxEnabled = displacementMap ~= nil and useDisplacementMap
     local parallaxPdoEnabled = context:GetMaterialPropertyValue_bool("parallax.pdo")
     
     local depthPass = context:GetShaderByTag("DepthPass")
     local shadowMap = context:GetShaderByTag("Shadowmap")
     local forwardPassEDS = context:GetShaderByTag("ForwardPass_EDS")
-    local lowEndForwardEDS = context:GetShaderByTag("LowEndForward_EDS")
 
     local depthPassWithPS = context:GetShaderByTag("DepthPass_WithPS")
     local shadowMapWithPS = context:GetShaderByTag("Shadowmap_WithPS")
     local forwardPass = context:GetShaderByTag("ForwardPass")
-    local lowEndForward = context:GetShaderByTag("LowEndForward")
+
+    -- Use TryGetShaderByTag because these shaders only exist in StandardPBR but this script is also used for EnhancedPBR
+    local lowEndForwardEDS = TryGetShaderByTag(context, "LowEndForward_EDS")
+    local lowEndForward = TryGetShaderByTag(context, "LowEndForward")
     
     if parallaxEnabled and parallaxPdoEnabled then
         depthPass:SetEnabled(false)
         shadowMap:SetEnabled(false)
         forwardPassEDS:SetEnabled(false)
-        lowEndForwardEDS:SetEnabled(false)
         
         depthPassWithPS:SetEnabled(true)
         shadowMapWithPS:SetEnabled(true)
         forwardPass:SetEnabled(true)
-        lowEndForward:SetEnabled(true)
+
+        TrySetShaderEnabled(lowEndForwardEDS, false)
+        TrySetShaderEnabled(lowEndForward, true)
     else
         depthPass:SetEnabled(opacityMode == OpacityMode_Opaque)
         shadowMap:SetEnabled(opacityMode == OpacityMode_Opaque)
         forwardPassEDS:SetEnabled((opacityMode == OpacityMode_Opaque) or (opacityMode == OpacityMode_Blended) or (opacityMode == OpacityMode_TintedTransparent))
-        lowEndForwardEDS:SetEnabled((opacityMode == OpacityMode_Opaque) or (opacityMode == OpacityMode_Blended) or (opacityMode == OpacityMode_TintedTransparent))
         
         depthPassWithPS:SetEnabled(opacityMode == OpacityMode_Cutout)
         shadowMapWithPS:SetEnabled(opacityMode == OpacityMode_Cutout)
         forwardPass:SetEnabled(opacityMode == OpacityMode_Cutout)
-        lowEndForward:SetEnabled(opacityMode == OpacityMode_Cutout)
+
+        TrySetShaderEnabled(lowEndForwardEDS, (opacityMode == OpacityMode_Opaque) or (opacityMode == OpacityMode_Blended) or (opacityMode == OpacityMode_TintedTransparent))
+        TrySetShaderEnabled(lowEndForward, opacityMode == OpacityMode_Cutout)
     end
     
     context:GetShaderByTag("DepthPassTransparentMin"):SetEnabled((opacityMode == OpacityMode_Blended) or (opacityMode == OpacityMode_TintedTransparent))
diff --git a/Gems/Atom/Feature/Common/Code/Source/CommonSystemComponent.cpp b/Gems/Atom/Feature/Common/Code/Source/CommonSystemComponent.cpp
index 089a6168b1..16f20d7178 100644
--- a/Gems/Atom/Feature/Common/Code/Source/CommonSystemComponent.cpp
+++ b/Gems/Atom/Feature/Common/Code/Source/CommonSystemComponent.cpp
@@ -14,8 +14,6 @@
 #include <Source/Material/UseTextureFunctor.h>
 #include <Source/Material/SubsurfaceTransmissionParameterFunctor.h>
 #include <Source/Material/Transform2DFunctor.h>
-#include <Source/Material/ShaderEnableFunctor.h>
-#include <Source/Material/PropertyVisibilityFunctor.h>
 #include <Source/Material/DrawListFunctor.h>
 #include <Source/Material/ConvertEmissiveUnitFunctor.h>
 
@@ -114,7 +112,6 @@ namespace AZ
             ProjectedShadowFeatureProcessor::Reflect(context);
             SkyBoxFeatureProcessor::Reflect(context);
             UseTextureFunctor::Reflect(context);
-            PropertyVisibilityFunctor::Reflect(context);
             DrawListFunctor::Reflect(context);
             SubsurfaceTransmissionParameterFunctor::Reflect(context);
             Transform2DFunctor::Reflect(context);
@@ -126,7 +123,6 @@ namespace AZ
             DisplayMapperPassData::Reflect(context);
             ConvertEmissiveUnitFunctor::Reflect(context);
             LookupTableAsset::Reflect(context);
-            ShaderEnableFunctor::Reflect(context);
             ReflectionProbeFeatureProcessor::Reflect(context);
             DecalTextureArrayFeatureProcessor::Reflect(context);
             SMAAFeatureProcessor::Reflect(context);
diff --git a/Gems/Atom/Feature/Common/Code/Source/EditorCommonSystemComponent.cpp b/Gems/Atom/Feature/Common/Code/Source/EditorCommonSystemComponent.cpp
index 32a29cf4d3..2373d0cb00 100644
--- a/Gems/Atom/Feature/Common/Code/Source/EditorCommonSystemComponent.cpp
+++ b/Gems/Atom/Feature/Common/Code/Source/EditorCommonSystemComponent.cpp
@@ -12,11 +12,9 @@
 
 #include <EditorCommonSystemComponent.h>
 #include <Source/Material/UseTextureFunctorSourceData.h>
-#include <Source/Material/PropertyVisibilityFunctorSourceData.h>
 #include <Source/Material/DrawListFunctorSourceData.h>
 #include <Source/Material/SubsurfaceTransmissionParameterFunctorSourceData.h>
 #include <Source/Material/Transform2DFunctorSourceData.h>
-#include <Source/Material/ShaderEnableFunctorSourceData.h>
 #include <Source/Material/ConvertEmissiveUnitFunctorSourceData.h>
 
 #include <Atom/Feature/Utils/EditorLightingPreset.h>
@@ -58,11 +56,9 @@ namespace AZ
                 }
 
                 AZ::Render::UseTextureFunctorSourceData::Reflect(context);
-                AZ::Render::PropertyVisibilityFunctorSourceData::Reflect(context);
                 AZ::Render::DrawListFunctorSourceData::Reflect(context);
                 AZ::Render::Transform2DFunctorSourceData::Reflect(context);
                 AZ::Render::ConvertEmissiveUnitFunctorSourceData::Reflect(context);
-                AZ::Render::ShaderEnableFunctorSourceData::Reflect(context);
                 AZ::Render::SubsurfaceTransmissionParameterFunctorSourceData::Reflect(context);
 
                 AZ::Render::EditorLightingPreset::Reflect(context);
@@ -104,11 +100,9 @@ namespace AZ
             }
 
             materialFunctorRegistration->RegisterMaterialFunctor("UseTexture", azrtti_typeid<UseTextureFunctorSourceData>());
-            materialFunctorRegistration->RegisterMaterialFunctor("UpdatePropertyVisibility", azrtti_typeid<PropertyVisibilityFunctorSourceData>());
             materialFunctorRegistration->RegisterMaterialFunctor("OverrideDrawList",         azrtti_typeid<DrawListFunctorSourceData>());
             materialFunctorRegistration->RegisterMaterialFunctor("Transform2D",              azrtti_typeid<Transform2DFunctorSourceData>());
             materialFunctorRegistration->RegisterMaterialFunctor("ConvertEmissiveUnit",      azrtti_typeid<ConvertEmissiveUnitFunctorSourceData>());
-            materialFunctorRegistration->RegisterMaterialFunctor("ShaderEnable",             azrtti_typeid<ShaderEnableFunctorSourceData>());
             materialFunctorRegistration->RegisterMaterialFunctor("HandleSubsurfaceScatteringParameters", azrtti_typeid<SubsurfaceTransmissionParameterFunctorSourceData>());
             materialFunctorRegistration->RegisterMaterialFunctor("Lua", azrtti_typeid<RPI::LuaMaterialFunctorSourceData>());
 
diff --git a/Gems/Atom/Feature/Common/Code/Source/Material/PropertyVisibilityFunctor.cpp b/Gems/Atom/Feature/Common/Code/Source/Material/PropertyVisibilityFunctor.cpp
deleted file mode 100644
index da8730f1ed..0000000000
--- a/Gems/Atom/Feature/Common/Code/Source/Material/PropertyVisibilityFunctor.cpp
+++ /dev/null
@@ -1,77 +0,0 @@
-/*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
-
-#include "PropertyVisibilityFunctor.h"
-
-namespace AZ
-{
-    namespace Render
-    {
-        void PropertyVisibilityFunctor::Reflect(ReflectContext* context)
-        {
-            if (auto* serializeContext = azrtti_cast<SerializeContext*>(context))
-            {
-                serializeContext->Class<Action>()
-                    ->Version(1)
-                    ->Field("triggerProperty", &Action::m_triggerPropertyIndex)
-                    ->Field("triggerValue", &Action::m_triggerValue)
-                    ->Field("visibility", &Action::m_visibility)
-                    ;
-                serializeContext->Class<PropertyVisibilityFunctor, RPI::MaterialFunctor>()
-                    ->Version(1)
-                    ->Field("actions",            &PropertyVisibilityFunctor::m_actions)
-                    ->Field("affectedProperties", &PropertyVisibilityFunctor::m_affectedProperties)
-                    ;
-            }
-        }
-
-        void PropertyVisibilityFunctor::Process(EditorContext& context)
-        {
-            bool visibilityApplied = false;
-            RPI::MaterialPropertyVisibility lastAppliedVisibility;
-
-            for (const auto& action : m_actions)
-            {
-                bool willSetVisibility = false;
-                if (action.m_triggerValue.Is<bool>() || action.m_triggerValue.Is<int32_t>() || action.m_triggerValue.Is<uint32_t>())
-                {
-                    willSetVisibility = action.m_triggerValue == context.GetMaterialPropertyValue(action.m_triggerPropertyIndex);
-                }
-                else if (action.m_triggerValue.Is<float>())
-                {
-                    willSetVisibility = AZ::IsClose(action.m_triggerValue.GetValue<float>(),
-                        context.GetMaterialPropertyValue<float>(action.m_triggerPropertyIndex),
-                        std::numeric_limits<float>::epsilon());
-                }
-                else // for types Vector2, Vector3, Vector4, Color, Image
-                {
-                    AZ_Error("PropertyVisibilityFunctor", false, "Unsupported property data type as an enable property.");
-                }
-
-                if (willSetVisibility)
-                {
-                    visibilityApplied = true;
-                    lastAppliedVisibility = action.m_visibility;
-                }
-            }
-
-            if (visibilityApplied)
-            {
-                for (const auto& propertyIndex : m_affectedProperties)
-                {
-                    context.SetMaterialPropertyVisibility(propertyIndex, lastAppliedVisibility);
-                }
-            }
-        }
-
-    } // namespace Render
-} // namespace AZ
diff --git a/Gems/Atom/Feature/Common/Code/Source/Material/PropertyVisibilityFunctor.h b/Gems/Atom/Feature/Common/Code/Source/Material/PropertyVisibilityFunctor.h
deleted file mode 100644
index d1a7772fc8..0000000000
--- a/Gems/Atom/Feature/Common/Code/Source/Material/PropertyVisibilityFunctor.h
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
-
-#pragma once
-
-#include <Atom/RPI.Reflect/Material/MaterialFunctor.h>
-#include <Atom/RPI.Reflect/Material/MaterialPropertyDescriptor.h>
-
-namespace AZ
-{
-    namespace Render
-    {
-        //! Materials can use this functor to control when and how to set the visibility of a group of properties.
-        class PropertyVisibilityFunctor final
-            : public RPI::MaterialFunctor
-        {
-            friend class PropertyVisibilityFunctorSourceData;
-        public:
-            AZ_RTTI(AZ::Render::PropertyVisibilityFunctor, "{2582B36F-FA7C-450F-B46A-39AAE18356A0}", RPI::MaterialFunctor);
-
-            static void Reflect(ReflectContext* context);
-
-            void Process(EditorContext& context) override;
-
-        private:
-            struct Action
-            {
-                AZ_TYPE_INFO(AZ::Render::PropertyVisibilityFunctor::Action, "{5DF4D981-9D0C-4040-A6C5-52E1D0BD876B}");
-
-                RPI::MaterialPropertyIndex      m_triggerPropertyIndex; //! The control property for affected properties.
-                RPI::MaterialPropertyValue      m_triggerValue;         //! The trigger value of the control property.
-                RPI::MaterialPropertyVisibility m_visibility;           //! The visibility of affected properties when the trigger value is hit.
-            };
-            // Material property inputs...
-            AZStd::vector<Action>                     m_actions;            //! The actions that describes when and what to do with visibilities.
-            AZStd::vector<RPI::MaterialPropertyIndex> m_affectedProperties; //! The properties that are affected by actions.
-        };
-
-    } // namespace Render
-} // namespace AZ
diff --git a/Gems/Atom/Feature/Common/Code/Source/Material/PropertyVisibilityFunctorSourceData.cpp b/Gems/Atom/Feature/Common/Code/Source/Material/PropertyVisibilityFunctorSourceData.cpp
deleted file mode 100644
index 3baf27de60..0000000000
--- a/Gems/Atom/Feature/Common/Code/Source/Material/PropertyVisibilityFunctorSourceData.cpp
+++ /dev/null
@@ -1,100 +0,0 @@
-/*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
-
-#include "PropertyVisibilityFunctorSourceData.h"
-#include <Atom/RPI.Reflect/Shader/ShaderOptionGroupLayout.h>
-#include <AzCore/Serialization/SerializeContext.h>
-
-#include <Atom/RPI.Edit/Material/MaterialUtils.h>
-
-namespace AZ
-{
-    namespace Render
-    {
-        void PropertyVisibilityFunctorSourceData::Reflect(ReflectContext* context)
-        {
-            if (auto* serializeContext = azrtti_cast<SerializeContext*>(context))
-            {
-                serializeContext->Class<ActionSourceData>()
-                    ->Version(1)
-                    ->Field("triggerProperty", &ActionSourceData::m_triggerPropertyName)
-                    ->Field("triggerValue", &ActionSourceData::m_triggerValue)
-                    ->Field("visibility", &ActionSourceData::m_visibility)
-                    ;
-                serializeContext->Class<PropertyVisibilityFunctorSourceData>()
-                    ->Version(2)
-                    ->Field("actions", &PropertyVisibilityFunctorSourceData::m_actions)
-                    ->Field("affectedProperties", &PropertyVisibilityFunctorSourceData::m_affectedPropertyNames)
-                    ;
-            }
-        }
-
-        RPI::MaterialFunctorSourceData::FunctorResult PropertyVisibilityFunctorSourceData::CreateFunctor(const EditorContext& context) const
-        {
-            using namespace RPI;
-
-            RPI::Ptr<PropertyVisibilityFunctor> functor = aznew PropertyVisibilityFunctor;
-
-            functor->m_actions.reserve(m_actions.size());
-
-            for (const auto& actionSource : m_actions)
-            {
-                functor->m_actions.emplace_back();
-                PropertyVisibilityFunctor::Action& action = functor->m_actions.back();
-                action.m_triggerPropertyIndex = context.FindMaterialPropertyIndex(AZ::Name{ actionSource.m_triggerPropertyName });
-                if (action.m_triggerPropertyIndex.IsNull())
-                {
-                    return Failure();
-                }
-                AddMaterialPropertyDependency(functor, action.m_triggerPropertyIndex);
-
-                if (!actionSource.m_triggerValue.Resolve(*context.GetMaterialPropertiesLayout(), Name{ actionSource.m_triggerPropertyName }))
-                {
-                    // Error is reported in Resolve().
-                    return Failure();
-                }
-
-                const MaterialPropertyDescriptor* propertyDescriptor = context.GetMaterialPropertiesLayout()->GetPropertyDescriptor(action.m_triggerPropertyIndex);
-                // Enum type should resolve further to a unit32_t from the string source.
-                if (propertyDescriptor->GetDataType() == RPI::MaterialPropertyDataType::Enum)
-                {
-                    if (!RPI::MaterialUtils::ResolveMaterialPropertyEnumValue(
-                        propertyDescriptor,
-                        Name(actionSource.m_triggerValue.GetValue().GetValue<AZStd::string>()),
-                        action.m_triggerValue))
-                    {
-                        return Failure();
-                    }
-                }
-                else
-                {
-                    action.m_triggerValue = actionSource.m_triggerValue.GetValue();
-                }
-
-                action.m_visibility = actionSource.m_visibility;
-            }
-
-            functor->m_affectedProperties.reserve(m_affectedPropertyNames.size());
-            for (const AZStd::string& name : m_affectedPropertyNames)
-            {
-                RPI::MaterialPropertyIndex index = context.FindMaterialPropertyIndex(AZ::Name{ name });
-                if (index.IsNull())
-                {
-                    return Failure();
-                }
-                functor->m_affectedProperties.push_back(index);
-            }
-
-            return Success(RPI::Ptr<MaterialFunctor>(functor));
-        }
-    } // namespace Render
-} // namespace AZ
diff --git a/Gems/Atom/Feature/Common/Code/Source/Material/PropertyVisibilityFunctorSourceData.h b/Gems/Atom/Feature/Common/Code/Source/Material/PropertyVisibilityFunctorSourceData.h
deleted file mode 100644
index 6b212f78a0..0000000000
--- a/Gems/Atom/Feature/Common/Code/Source/Material/PropertyVisibilityFunctorSourceData.h
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
-
-#pragma once
-
-#include "PropertyVisibilityFunctor.h"
-#include <Atom/RPI.Edit/Material/MaterialFunctorSourceData.h>
-#include <Atom/RPI.Edit/Material/MaterialPropertyValueSourceData.h>
-
-namespace AZ
-{
-    namespace Render
-    {
-        //! Builds a PropertyVisibilityFunctor.
-        //! Materials can use this functor to control whether a specific property group will be enabled.
-        class PropertyVisibilityFunctorSourceData final
-            : public RPI::MaterialFunctorSourceData
-        {
-        public:
-            AZ_RTTI(AZ::Render::PropertyVisibilityFunctorSourceData, "{B44E6929-8FFF-405F-9056-B9B811F97676}", RPI::MaterialFunctorSourceData);
-
-            static void Reflect(ReflectContext* context);
-
-            FunctorResult CreateFunctor(const EditorContext& context) const override;
-        private:
-            struct ActionSourceData
-            {
-                AZ_TYPE_INFO(AZ::Render::PropertyVisibilityFunctorSourceData::ActionSourceData, "{70E01DA6-0B42-4CCB-AAD0-51980DB43F62}");
-                AZStd::string                        m_triggerPropertyName; //! The control property for affected properties.
-                RPI::MaterialPropertyValueSourceData m_triggerValue;        //! The trigger value of the control property.
-                RPI::MaterialPropertyVisibility      m_visibility;          //! The visibility of affected properties when the trigger value is hit.
-            };
-            // Material property inputs...
-            AZStd::vector<ActionSourceData> m_actions;               //! The actions that describes when and what to do with visibilities.
-            AZStd::vector<AZStd::string>    m_affectedPropertyNames; //! The properties that are affected by actions.
-        };
-
-    } // namespace Render
-} // namespace AZ
diff --git a/Gems/Atom/Feature/Common/Code/Source/Material/ShaderEnableFunctor.cpp b/Gems/Atom/Feature/Common/Code/Source/Material/ShaderEnableFunctor.cpp
deleted file mode 100644
index dd602cc4ba..0000000000
--- a/Gems/Atom/Feature/Common/Code/Source/Material/ShaderEnableFunctor.cpp
+++ /dev/null
@@ -1,74 +0,0 @@
-/*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
-
-#include "./ShaderEnableFunctor.h"
-#include <Atom/RPI.Public/Material/Material.h>
-#include <Atom/RPI.Reflect/Image/Image.h>
-#include <Atom/RPI.Reflect/Shader/ShaderOptionGroup.h>
-
-namespace AZ
-{
-    namespace Render
-    {
-        void ShaderEnableFunctor::Reflect(ReflectContext* context)
-        {
-            if (auto* serializeContext = azrtti_cast<SerializeContext*>(context))
-            {
-                serializeContext->Class<ShaderEnableFunctor, RPI::MaterialFunctor>()
-                    ->Version(4)
-                    ->Field("opacityModeIndex", &ShaderEnableFunctor::m_opacityModeIndex)
-                    ->Field("parallaxEnableIndex", &ShaderEnableFunctor::m_parallaxEnableIndex)
-                    ->Field("parallaxPdoEnableIndex", &ShaderEnableFunctor::m_parallaxPdoEnableIndex)
-                    ->Field("shadowShaderNoPSIndex", &ShaderEnableFunctor::m_shadowShaderNoPSIndex)
-                    ->Field("shadowShaderWithPSIndex", &ShaderEnableFunctor::m_shadowShaderWithPSIndex)
-                    ->Field("depthShaderNoPSIndex", &ShaderEnableFunctor::m_depthShaderNoPSIndex)
-                    ->Field("depthShaderWithPSIndex", &ShaderEnableFunctor::m_depthShaderWithPSIndex)
-                    ->Field("pbrShaderNoEdsIndex", &ShaderEnableFunctor::m_pbrShaderNoEdsIndex)
-                    ->Field("pbrShaderWithEdsIndex", &ShaderEnableFunctor::m_pbrShaderWithEdsIndex)
-                    ->Field("depthShaderTransparentMin", &ShaderEnableFunctor::m_depthShaderTransparentMin)
-                    ->Field("depthShaderTransparentMax", &ShaderEnableFunctor::m_depthShaderTransparentMax)
-                ;
-            }
-        }
-
-        void ShaderEnableFunctor::Process(RuntimeContext& context)
-        {
-            unsigned int opacityMode = context.GetMaterialPropertyValue<uint32_t>(m_opacityModeIndex);
-            bool parallaxEnabled = context.GetMaterialPropertyValue<bool>(m_parallaxEnableIndex);
-            bool parallaxPdoEnabled = context.GetMaterialPropertyValue<bool>(m_parallaxPdoEnableIndex);
-
-            if (parallaxEnabled && parallaxPdoEnabled)
-            {
-                context.SetShaderEnabled(m_depthShaderNoPSIndex, false);
-                context.SetShaderEnabled(m_shadowShaderNoPSIndex, false);
-                context.SetShaderEnabled(m_pbrShaderWithEdsIndex, false);
-
-                context.SetShaderEnabled(m_depthShaderWithPSIndex, true);
-                context.SetShaderEnabled(m_shadowShaderWithPSIndex, true);
-                context.SetShaderEnabled(m_pbrShaderNoEdsIndex, true);
-            }
-            else
-            {
-                context.SetShaderEnabled(m_depthShaderNoPSIndex, opacityMode == OpacityMode::Opaque );
-                context.SetShaderEnabled(m_shadowShaderNoPSIndex, opacityMode == OpacityMode::Opaque);
-                context.SetShaderEnabled(m_pbrShaderWithEdsIndex, opacityMode == OpacityMode::Opaque || opacityMode == OpacityMode::Blended || opacityMode == OpacityMode::TintedTransparent);
-
-                context.SetShaderEnabled(m_depthShaderWithPSIndex, opacityMode == OpacityMode::Cutout);
-                context.SetShaderEnabled(m_shadowShaderWithPSIndex, opacityMode == OpacityMode::Cutout);
-                context.SetShaderEnabled(m_pbrShaderNoEdsIndex, opacityMode == OpacityMode::Cutout);
-            }
-
-            context.SetShaderEnabled(m_depthShaderTransparentMin, opacityMode == OpacityMode::Blended || opacityMode == OpacityMode::TintedTransparent);
-            context.SetShaderEnabled(m_depthShaderTransparentMax, opacityMode == OpacityMode::Blended || opacityMode == OpacityMode::TintedTransparent);
-        }
-    }
-}
diff --git a/Gems/Atom/Feature/Common/Code/Source/Material/ShaderEnableFunctor.h b/Gems/Atom/Feature/Common/Code/Source/Material/ShaderEnableFunctor.h
deleted file mode 100644
index ac5f31ba30..0000000000
--- a/Gems/Atom/Feature/Common/Code/Source/Material/ShaderEnableFunctor.h
+++ /dev/null
@@ -1,63 +0,0 @@
-/*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
-
-#pragma once
-
-#include <Atom/RPI.Reflect/Material/MaterialFunctor.h>
-#include <Atom/RPI.Reflect/Material/MaterialPropertyDescriptor.h>
-#include <Atom/RHI.Reflect/Limits.h>
-
-namespace AZ
-{
-    namespace Render
-    {
-        enum OpacityMode
-        {
-            Opaque = 0,
-            Cutout,
-            Blended,
-            TintedTransparent,
-        };
-
-        //! Select shadow and depth shader based on opacity mode and parallax state
-        //! Opaque:                      Enable shader without PS
-        //! Cutout or Parallax enable:   Enable shader with PS
-        //! Blended:                     Disable both
-        //! TintedTransparent:           Disable both
-        class ShaderEnableFunctor final
-            : public RPI::MaterialFunctor
-        {
-            friend class ShaderEnableFunctorSourceData;
-        public:
-            AZ_RTTI(ShaderEnableFunctor, "{2079A693-FE4F-46A7-95C0-09D88AC156D0}", RPI::MaterialFunctor);
-
-            static void Reflect(ReflectContext* context);
-
-            void Process(RuntimeContext& context) override;
-
-        private:
-            RPI::MaterialPropertyIndex m_opacityModeIndex;
-            RPI::MaterialPropertyIndex m_parallaxEnableIndex;
-            RPI::MaterialPropertyIndex m_parallaxPdoEnableIndex;
-
-            uint32_t m_shadowShaderNoPSIndex = -1;
-            uint32_t m_shadowShaderWithPSIndex = -1;
-            uint32_t m_depthShaderNoPSIndex = -1;
-            uint32_t m_depthShaderWithPSIndex = -1;
-            uint32_t m_pbrShaderWithEdsIndex = -1;
-            uint32_t m_pbrShaderNoEdsIndex = -1;
-            // The following are used by the light culling system to produce min/max depth bounds
-            uint32_t m_depthShaderTransparentMin = -1;
-            uint32_t m_depthShaderTransparentMax = -1;
-        };
-    }
-}
diff --git a/Gems/Atom/Feature/Common/Code/Source/Material/ShaderEnableFunctorSourceData.cpp b/Gems/Atom/Feature/Common/Code/Source/Material/ShaderEnableFunctorSourceData.cpp
deleted file mode 100644
index 3c16666f82..0000000000
--- a/Gems/Atom/Feature/Common/Code/Source/Material/ShaderEnableFunctorSourceData.cpp
+++ /dev/null
@@ -1,116 +0,0 @@
-/*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
-
-#include "./ShaderEnableFunctorSourceData.h"
-#include <Atom/RPI.Reflect/Shader/ShaderOptionGroupLayout.h>
-#include <AzCore/Serialization/SerializeContext.h>
-
-namespace AZ
-{
-    namespace Render
-    {
-        void ShaderEnableFunctorSourceData::Reflect(ReflectContext* context)
-        {
-            if (auto* serializeContext = azrtti_cast<SerializeContext*>(context))
-            {
-                serializeContext->Class<ShaderEnableFunctorSourceData>()
-                    ->Version(5)
-                    ->Field("opacityMode", &ShaderEnableFunctorSourceData::m_opacityMode)
-                    ->Field("parallaxEnable", &ShaderEnableFunctorSourceData::m_parallaxEnable)
-                    ->Field("parallaxPdoEnable", &ShaderEnableFunctorSourceData::m_parallaxPdoEnable)
-                    ->Field("shadowShaderNoPSIndex", &ShaderEnableFunctorSourceData::m_shadowShaderNoPSIndex)
-                    ->Field("shadowShaderWithPSIndex", &ShaderEnableFunctorSourceData::m_shadowShaderWithPSIndex)
-                    ->Field("depthShaderNoPSIndex", &ShaderEnableFunctorSourceData::m_depthShaderNoPSIndex)
-                    ->Field("depthShaderWithPSIndex", &ShaderEnableFunctorSourceData::m_depthShaderWithPSIndex)
-                    ->Field("pbrShaderNoEdsIndex", &ShaderEnableFunctorSourceData::m_pbrShaderNoEdsIndex)
-                    ->Field("pbrShaderWithEdsIndex", &ShaderEnableFunctorSourceData::m_pbrShaderWithEdsIndex)
-                    ->Field("depthShaderTransparentMin", &ShaderEnableFunctorSourceData::m_depthShaderTransparentMin)
-                    ->Field("depthShaderTransparentMax", &ShaderEnableFunctorSourceData::m_depthShaderTransparentMax)
-                ;
-            }
-        }
-
-        RPI::MaterialFunctorSourceData::FunctorResult ShaderEnableFunctorSourceData::CreateFunctor(const RuntimeContext& context) const
-        {
-            RPI::Ptr<ShaderEnableFunctor> functor = aznew ShaderEnableFunctor;
-
-            functor->m_opacityModeIndex = context.FindMaterialPropertyIndex(Name{ m_opacityMode });
-            if (functor->m_opacityModeIndex.IsNull())
-            {
-                return Failure();
-            }
-            AddMaterialPropertyDependency(functor, functor->m_opacityModeIndex);
-
-            functor->m_parallaxEnableIndex = context.FindMaterialPropertyIndex(Name{ m_parallaxEnable });
-            if (functor->m_parallaxEnableIndex.IsNull())
-            {
-                return Failure();
-            }
-            AddMaterialPropertyDependency(functor, functor->m_parallaxEnableIndex);
-
-            functor->m_parallaxPdoEnableIndex = context.FindMaterialPropertyIndex(Name{ m_parallaxPdoEnable });
-            if (functor->m_parallaxPdoEnableIndex.IsNull())
-            {
-                return Failure();
-            }
-            AddMaterialPropertyDependency(functor, functor->m_parallaxPdoEnableIndex);
-
-            if (!context.CheckShaderIndexValid(m_shadowShaderWithPSIndex))
-            {
-                return Failure();
-            }
-            functor->m_shadowShaderWithPSIndex = m_shadowShaderWithPSIndex;
-
-            if (!context.CheckShaderIndexValid(m_shadowShaderNoPSIndex))
-            {
-                return Failure();
-            }
-            functor->m_shadowShaderNoPSIndex = m_shadowShaderNoPSIndex;
-
-            if (!context.CheckShaderIndexValid(m_depthShaderWithPSIndex))
-            {
-                return Failure();
-            }
-            functor->m_depthShaderWithPSIndex = m_depthShaderWithPSIndex;
-
-            if (!context.CheckShaderIndexValid(m_depthShaderNoPSIndex))
-            {
-                return Failure();
-            }
-            functor->m_depthShaderNoPSIndex = m_depthShaderNoPSIndex;
-
-            if (!context.CheckShaderIndexValid(m_pbrShaderNoEdsIndex))
-            {
-                return Failure();
-            }
-            functor->m_pbrShaderNoEdsIndex = m_pbrShaderNoEdsIndex;
-
-            if (!context.CheckShaderIndexValid(m_pbrShaderWithEdsIndex))
-            {
-                return Failure();
-            }
-            functor->m_pbrShaderWithEdsIndex = m_pbrShaderWithEdsIndex;
-            if (!context.CheckShaderIndexValid(m_depthShaderTransparentMin))
-            {
-                return Failure();
-            }
-            functor->m_depthShaderTransparentMin = m_depthShaderTransparentMin;
-            if (!context.CheckShaderIndexValid(m_depthShaderTransparentMax))
-            {
-                return Failure();
-            }
-            functor->m_depthShaderTransparentMax = m_depthShaderTransparentMax;
-
-            return Success(RPI::Ptr<RPI::MaterialFunctor>(functor));
-        }
-    }
-}
diff --git a/Gems/Atom/Feature/Common/Code/Source/Material/ShaderEnableFunctorSourceData.h b/Gems/Atom/Feature/Common/Code/Source/Material/ShaderEnableFunctorSourceData.h
deleted file mode 100644
index 2d00a4a015..0000000000
--- a/Gems/Atom/Feature/Common/Code/Source/Material/ShaderEnableFunctorSourceData.h
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
-* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
-* its licensors.
-*
-* For complete copyright and license terms please see the LICENSE at the root of this
-* distribution (the "License"). All use of this software is governed by the License,
-* or, if provided, by the license below or the license accompanying this file. Do not
-* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-*
-*/
-
-#pragma once
-
-#include "./ShaderEnableFunctor.h"
-#include <Atom/RPI.Edit/Material/MaterialFunctorSourceData.h>
-
-namespace AZ
-{
-    namespace Render
-    {
-        class ShaderEnableFunctor;
-
-        //! Builds a ShaderEnableFunctor
-        class ShaderEnableFunctorSourceData final
-            : public RPI::MaterialFunctorSourceData
-        {
-        public:
-            AZ_RTTI(ShaderEnableFunctorSourceData, "{63775ECB-5C3E-44D3-B175-4537BF76C3A7}", RPI::MaterialFunctorSourceData);
-
-            static void Reflect(ReflectContext* context);
-
-            FunctorResult CreateFunctor(const RuntimeContext& context) const override;
-
-        private:
-
-            AZStd::string m_opacityMode;
-            AZStd::string m_parallaxEnable;
-            AZStd::string m_parallaxPdoEnable;
-
-            uint32_t m_shadowShaderNoPSIndex = -1;
-            uint32_t m_shadowShaderWithPSIndex = -1;
-            uint32_t m_depthShaderNoPSIndex = -1;
-            uint32_t m_depthShaderWithPSIndex = -1;
-            uint32_t m_pbrShaderWithEdsIndex = -1;
-            uint32_t m_pbrShaderNoEdsIndex = -1;
-            // The following are used by the light culling system to produce min/max depth bounds
-            uint32_t m_depthShaderTransparentMin = -1;
-            uint32_t m_depthShaderTransparentMax = -1;
-        };
-    }
-}
diff --git a/Gems/Atom/Feature/Common/Code/atom_feature_common_editor_files.cmake b/Gems/Atom/Feature/Common/Code/atom_feature_common_editor_files.cmake
index 3a749a4b67..4e7cc9dab3 100644
--- a/Gems/Atom/Feature/Common/Code/atom_feature_common_editor_files.cmake
+++ b/Gems/Atom/Feature/Common/Code/atom_feature_common_editor_files.cmake
@@ -24,16 +24,12 @@ set(FILES
     Source/Material/ConvertEmissiveUnitFunctorSourceData.h
     Source/Material/MaterialConverterSystemComponent.cpp
     Source/Material/MaterialConverterSystemComponent.h
-    Source/Material/ShaderEnableFunctorSourceData.cpp
-    Source/Material/ShaderEnableFunctorSourceData.h
     Source/Material/SubsurfaceTransmissionParameterFunctorSourceData.cpp
     Source/Material/SubsurfaceTransmissionParameterFunctorSourceData.h
     Source/Material/Transform2DFunctorSourceData.cpp
     Source/Material/Transform2DFunctorSourceData.h
     Source/Material/UseTextureFunctorSourceData.cpp
     Source/Material/UseTextureFunctorSourceData.h
-    Source/Material/PropertyVisibilityFunctorSourceData.cpp
-    Source/Material/PropertyVisibilityFunctorSourceData.h
     Source/Material/DrawListFunctorSourceData.cpp
     Source/Material/DrawListFunctorSourceData.h
 )
diff --git a/Gems/Atom/Feature/Common/Code/atom_feature_common_files.cmake b/Gems/Atom/Feature/Common/Code/atom_feature_common_files.cmake
index 46a4e06ac2..4f98046adb 100644
--- a/Gems/Atom/Feature/Common/Code/atom_feature_common_files.cmake
+++ b/Gems/Atom/Feature/Common/Code/atom_feature_common_files.cmake
@@ -155,16 +155,12 @@ set(FILES
     Source/LookupTable/LookupTableAsset.cpp
     Source/Material/ConvertEmissiveUnitFunctor.cpp
     Source/Material/ConvertEmissiveUnitFunctor.h
-    Source/Material/ShaderEnableFunctor.cpp
-    Source/Material/ShaderEnableFunctor.h
     Source/Material/SubsurfaceTransmissionParameterFunctor.cpp
     Source/Material/SubsurfaceTransmissionParameterFunctor.h
     Source/Material/Transform2DFunctor.cpp
     Source/Material/Transform2DFunctor.h
     Source/Material/UseTextureFunctor.cpp
     Source/Material/UseTextureFunctor.h
-    Source/Material/PropertyVisibilityFunctor.cpp
-    Source/Material/PropertyVisibilityFunctor.h
     Source/Material/DrawListFunctor.cpp
     Source/Material/DrawListFunctor.h
     Source/Math/GaussianMathFilter.h
diff --git a/Gems/Atom/RHI/Code/Source/RHI.Edit/ShaderCompilerArguments.cpp b/Gems/Atom/RHI/Code/Source/RHI.Edit/ShaderCompilerArguments.cpp
index 3a04bf6b88..09cd1c125e 100644
--- a/Gems/Atom/RHI/Code/Source/RHI.Edit/ShaderCompilerArguments.cpp
+++ b/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;
         }
     }
diff --git a/Gems/Atom/RHI/Vulkan/Code/Source/RHI/NullDescriptorManager.cpp b/Gems/Atom/RHI/Vulkan/Code/Source/RHI/NullDescriptorManager.cpp
index cdacd2578f..791fa006b0 100644
--- a/Gems/Atom/RHI/Vulkan/Code/Source/RHI/NullDescriptorManager.cpp
+++ b/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;
diff --git a/Gems/Atom/RPI/Code/Include/Atom/RPI.Reflect/Material/LuaMaterialFunctor.h b/Gems/Atom/RPI/Code/Include/Atom/RPI.Reflect/Material/LuaMaterialFunctor.h
index 396ba14810..f372f40981 100644
--- a/Gems/Atom/RPI/Code/Include/Atom/RPI.Reflect/Material/LuaMaterialFunctor.h
+++ b/Gems/Atom/RPI/Code/Include/Atom/RPI.Reflect/Material/LuaMaterialFunctor.h
@@ -288,6 +288,7 @@ namespace AZ
             AZStd::size_t GetShaderCount() const;
             LuaMaterialFunctorShaderItem GetShader(AZStd::size_t index);
             LuaMaterialFunctorShaderItem GetShaderByTag(const char* shaderTag);
+            bool HasShaderWithTag(const char* shaderTag);
 
         private:
 
diff --git a/Gems/Atom/RPI/Code/Source/RPI.Public/GpuQuery/Query.cpp b/Gems/Atom/RPI/Code/Source/RPI.Public/GpuQuery/Query.cpp
index 227e096594..1d6e8cdc65 100644
--- a/Gems/Atom/RPI/Code/Source/RPI.Public/GpuQuery/Query.cpp
+++ b/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())
             {
diff --git a/Gems/Atom/RPI/Code/Source/RPI.Public/Pass/RenderPass.cpp b/Gems/Atom/RPI/Code/Source/RPI.Public/Pass/RenderPass.cpp
index 9c6a95e582..3a2a556429 100644
--- a/Gems/Atom/RPI/Code/Source/RPI.Public/Pass/RenderPass.cpp
+++ b/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()
diff --git a/Gems/Atom/RPI/Code/Source/RPI.Public/Shader/ShaderVariantAsyncLoader.cpp b/Gems/Atom/RPI/Code/Source/RPI.Public/Shader/ShaderVariantAsyncLoader.cpp
index 6579e6a98d..3fc2bbd197 100644
--- a/Gems/Atom/RPI/Code/Source/RPI.Public/Shader/ShaderVariantAsyncLoader.cpp
+++ b/Gems/Atom/RPI/Code/Source/RPI.Public/Shader/ShaderVariantAsyncLoader.cpp
@@ -150,10 +150,7 @@ namespace AZ
                     }
                 }
 
-                if (!shaderVariantTreePendingRequests.empty() || !shaderVariantPendingRequests.empty())
-                {
-                    AZStd::this_thread::sleep_for(AZStd::chrono::milliseconds(1000));
-                }
+                AZStd::this_thread::sleep_for(AZStd::chrono::milliseconds(1000));
             }
         }
 
diff --git a/Gems/Atom/RPI/Code/Source/RPI.Reflect/Material/LuaMaterialFunctor.cpp b/Gems/Atom/RPI/Code/Source/RPI.Reflect/Material/LuaMaterialFunctor.cpp
index 7db5f12560..d6421e1337 100644
--- a/Gems/Atom/RPI/Code/Source/RPI.Reflect/Material/LuaMaterialFunctor.cpp
+++ b/Gems/Atom/RPI/Code/Source/RPI.Reflect/Material/LuaMaterialFunctor.cpp
@@ -296,6 +296,7 @@ namespace AZ
                 ->Method("GetShaderCount", &LuaMaterialFunctorRuntimeContext::GetShaderCount)
                 ->Method("GetShader", &LuaMaterialFunctorRuntimeContext::GetShader)
                 ->Method("GetShaderByTag", &LuaMaterialFunctorRuntimeContext::GetShaderByTag)
+                ->Method("HasShaderWithTag", &LuaMaterialFunctorRuntimeContext::HasShaderWithTag)
                 ;
         }
 
@@ -424,6 +425,11 @@ namespace AZ
                 return LuaMaterialFunctorShaderItem{nullptr};
             }
         }
+        
+        bool LuaMaterialFunctorRuntimeContext::HasShaderWithTag(const char* shaderTag)
+        {
+            return m_runtimeContextImpl->m_shaderCollection->HasShaderTag(AZ::Name{shaderTag});
+        }
 
         void LuaMaterialFunctorEditorContext::LuaMaterialFunctorEditorContext::Reflect(BehaviorContext* behaviorContext)
         {
diff --git a/Gems/Atom/RPI/Code/Tests/System/GpuQueryTests.cpp b/Gems/Atom/RPI/Code/Tests/System/GpuQueryTests.cpp
index e55ec8012b..98ff6befdd 100644
--- a/Gems/Atom/RPI/Code/Tests/System/GpuQueryTests.cpp
+++ b/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;
diff --git a/Gems/Atom/TestData/TestData/Materials/ParallaxRock.material b/Gems/Atom/TestData/TestData/Materials/ParallaxRock.material
index 4c3a925e52..c9276216eb 100644
--- a/Gems/Atom/TestData/TestData/Materials/ParallaxRock.material
+++ b/Gems/Atom/TestData/TestData/Materials/ParallaxRock.material
@@ -17,7 +17,6 @@
             "textureMap": "TestData/Textures/cc0/Rock030_2K_Normal.jpg"
         },
         "parallax": {
-            "enable": true,
             "algorithm": "POM",
             "factor": 0.03,
             "quality": "High",
diff --git a/Gems/Atom/TestData/TestData/Materials/StandardMultilayerPbrTestCases/001_ManyFeatures.material b/Gems/Atom/TestData/TestData/Materials/StandardMultilayerPbrTestCases/001_ManyFeatures.material
index 17353a0603..415bd36dcf 100644
--- a/Gems/Atom/TestData/TestData/Materials/StandardMultilayerPbrTestCases/001_ManyFeatures.material
+++ b/Gems/Atom/TestData/TestData/Materials/StandardMultilayerPbrTestCases/001_ManyFeatures.material
@@ -86,6 +86,10 @@
             "textureMap": "TestData/Textures/cc0/Lava004_1K_Roughness.jpg"
         },
         "layer2_uv": {
+            "center": [
+                0.0,
+                0.0
+            ],
             "offsetU": 0.5,
             "offsetV": 0.25
         },
@@ -128,11 +132,15 @@
             "factor": 0.47474750876426699
         },
         "layer3_uv": {
+            "center": [
+                0.0,
+                0.0
+            ],
             "offsetU": 0.11999999731779099,
             "rotateDegrees": -57.599998474121097
         },
         "parallax": {
-            "enable": true
+            "quality": "Medium"
         },
         "uv": {
             "center": [
diff --git a/Gems/Atom/TestData/TestData/Materials/StandardMultilayerPbrTestCases/002_ParallaxPdo.material b/Gems/Atom/TestData/TestData/Materials/StandardMultilayerPbrTestCases/002_ParallaxPdo.material
index 8cddab24bc..64adf317a9 100644
--- a/Gems/Atom/TestData/TestData/Materials/StandardMultilayerPbrTestCases/002_ParallaxPdo.material
+++ b/Gems/Atom/TestData/TestData/Materials/StandardMultilayerPbrTestCases/002_ParallaxPdo.material
@@ -48,8 +48,8 @@
             "textureMap": "TestData/Textures/cc0/Concrete019_1K_Color.jpg"
         },
         "parallax": {
-            "enable": true,
-            "pdo": true
+            "pdo": true,
+            "quality": "Medium"
         }
     }
 }
\ No newline at end of file
diff --git a/Gems/Atom/TestData/TestData/Materials/StandardMultilayerPbrTestCases/004_UseVertexColors.material b/Gems/Atom/TestData/TestData/Materials/StandardMultilayerPbrTestCases/004_UseVertexColors.material
index 3201fa3864..ea3ea8b519 100644
--- a/Gems/Atom/TestData/TestData/Materials/StandardMultilayerPbrTestCases/004_UseVertexColors.material
+++ b/Gems/Atom/TestData/TestData/Materials/StandardMultilayerPbrTestCases/004_UseVertexColors.material
@@ -6,6 +6,9 @@
     "properties": {
         "blend": {
             "blendSource": "BlendMaskVertexColors"
+        },
+        "parallax": {
+            "quality": "Medium"
         }
     }
-}
+}
\ No newline at end of file
diff --git a/Gems/Atom/TestData/TestData/Materials/StandardMultilayerPbrTestCases/005_UseDisplacement.material b/Gems/Atom/TestData/TestData/Materials/StandardMultilayerPbrTestCases/005_UseDisplacement.material
index 55a4774d49..9163fe0a0c 100644
--- a/Gems/Atom/TestData/TestData/Materials/StandardMultilayerPbrTestCases/005_UseDisplacement.material
+++ b/Gems/Atom/TestData/TestData/Materials/StandardMultilayerPbrTestCases/005_UseDisplacement.material
@@ -46,8 +46,8 @@
         },
         "layer2_uv": {
             "center": [
-                0.5,
-                0.5
+                0.0,
+                0.0
             ],
             "offsetU": 0.1599999964237213,
             "offsetV": 0.07999999821186066,
@@ -67,13 +67,15 @@
             "textureMap": "TestData/Textures/cc0/Rocks002_1K_Roughness.jpg"
         },
         "layer3_uv": {
+            "center": [
+                0.0,
+                0.0
+            ],
             "scale": 3.4999988079071047
         },
         "parallax": {
             "algorithm": "Relief",
-            "enable": true,
-            "pdo": true,
-            "quality": "Low"
+            "pdo": true
         }
     }
 }
\ No newline at end of file
diff --git a/Gems/Atom/TestData/TestData/Materials/StandardPbrTestCases/009_Opacity_TintedTransparent.material b/Gems/Atom/TestData/TestData/Materials/StandardPbrTestCases/009_Opacity_TintedTransparent.material
new file mode 100644
index 0000000000..1716792af1
--- /dev/null
+++ b/Gems/Atom/TestData/TestData/Materials/StandardPbrTestCases/009_Opacity_TintedTransparent.material
@@ -0,0 +1,23 @@
+{
+    "description": "",
+    "materialType": "Materials/Types/StandardPBR.materialtype",
+    "parentMaterial": "",
+    "propertyLayoutVersion": 3,
+    "properties": {
+        "baseColor": {
+            "color": [
+                0.5906767249107361,
+                1.0,
+                0.11703670024871826,
+                1.0
+            ],
+            "textureMap": "Textures/Default/default_basecolor.tif"
+        },
+        "opacity": {
+            "alphaSource": "Split",
+            "factor": 0.75,
+            "mode": "TintedTransparent",
+            "textureMap": "TestData/Textures/checker8x8_gray_512.png"
+        }
+    }
+}
\ No newline at end of file
diff --git a/Gems/Atom/TestData/TestData/Materials/StandardPbrTestCases/012_Parallax_POM.material b/Gems/Atom/TestData/TestData/Materials/StandardPbrTestCases/012_Parallax_POM.material
index a94d90d04d..ed070d5de2 100644
--- a/Gems/Atom/TestData/TestData/Materials/StandardPbrTestCases/012_Parallax_POM.material
+++ b/Gems/Atom/TestData/TestData/Materials/StandardPbrTestCases/012_Parallax_POM.material
@@ -8,7 +8,6 @@
         },
         "parallax": {
             "algorithm": "POM",
-            "enable": true,
             "factor": 0.02500000037252903,
             "quality": "High",
             "textureMap": "TestData/Textures/TextureHaven/4k_castle_brick_02_red/4k_castle_brick_02_red_disp.png"
diff --git a/Gems/Atom/TestData/TestData/Materials/StandardPbrTestCases/012_Parallax_POM_Cutout.material b/Gems/Atom/TestData/TestData/Materials/StandardPbrTestCases/012_Parallax_POM_Cutout.material
index fb862dc5d3..f5ec0e8287 100644
--- a/Gems/Atom/TestData/TestData/Materials/StandardPbrTestCases/012_Parallax_POM_Cutout.material
+++ b/Gems/Atom/TestData/TestData/Materials/StandardPbrTestCases/012_Parallax_POM_Cutout.material
@@ -13,13 +13,15 @@
             "textureMap": "TestData/Textures/checker8x8_512.png"
         },
         "parallax": {
-            "algorithm": "POM",
-            "enable": true,
             "factor": 0.10000000149011612,
             "quality": "High",
             "textureMap": "TestData/Textures/TextureHaven/4k_castle_brick_02_red/4k_castle_brick_02_red_disp.png"
         },
         "uv": {
+            "center": [
+                0.0,
+                0.0
+            ],
             "scale": 0.5
         }
     }
diff --git a/Gems/Atom/TestData/TestData/Materials/StandardPbrTestCases/015_SubsurfaceScattering_Transmission.material b/Gems/Atom/TestData/TestData/Materials/StandardPbrTestCases/015_SubsurfaceScattering_Transmission.material
index dbaf6cb587..38adbc70cd 100644
--- a/Gems/Atom/TestData/TestData/Materials/StandardPbrTestCases/015_SubsurfaceScattering_Transmission.material
+++ b/Gems/Atom/TestData/TestData/Materials/StandardPbrTestCases/015_SubsurfaceScattering_Transmission.material
@@ -6,7 +6,6 @@
     "properties": {
         "subsurfaceScattering": {
             "enableSubsurfaceScattering": true,
-            "enableTransmission": true,
             "scatterDistance": 64.6464614868164,
             "subsurfaceScatterFactor": 1.0,
             "thicknessMap": "TestData/Textures/checker8x8_512.png",
diff --git a/Gems/Atom/TestData/TestData/Materials/StandardPbrTestCases/100_UvTiling_Parallax_A.material b/Gems/Atom/TestData/TestData/Materials/StandardPbrTestCases/100_UvTiling_Parallax_A.material
index 7bf12e5358..b3e69212db 100644
--- a/Gems/Atom/TestData/TestData/Materials/StandardPbrTestCases/100_UvTiling_Parallax_A.material
+++ b/Gems/Atom/TestData/TestData/Materials/StandardPbrTestCases/100_UvTiling_Parallax_A.material
@@ -13,7 +13,6 @@
         },
         "parallax": {
             "algorithm": "POM",
-            "enable": true,
             "factor": 0.10000000149011612,
             "quality": "High",
             "textureMap": "TestData/Objects/cube/cube_diff.tif"
diff --git a/Gems/Atom/TestData/TestData/Materials/StandardPbrTestCases/100_UvTiling_Parallax_B.material b/Gems/Atom/TestData/TestData/Materials/StandardPbrTestCases/100_UvTiling_Parallax_B.material
index 4b9f233a85..3d52f3b9e6 100644
--- a/Gems/Atom/TestData/TestData/Materials/StandardPbrTestCases/100_UvTiling_Parallax_B.material
+++ b/Gems/Atom/TestData/TestData/Materials/StandardPbrTestCases/100_UvTiling_Parallax_B.material
@@ -13,7 +13,6 @@
         },
         "parallax": {
             "algorithm": "POM",
-            "enable": true,
             "factor": 0.05000000074505806,
             "quality": "High",
             "textureMap": "TestData/Objects/cube/cube_diff.tif"
diff --git a/Gems/Atom/TestData/TestData/Materials/StandardPbrTestCases/101_DetailMaps_LucyBaseNoDetailMaps.material b/Gems/Atom/TestData/TestData/Materials/StandardPbrTestCases/101_DetailMaps_LucyBaseNoDetailMaps.material
index 7b1f0ba6a9..6d77be5a49 100644
--- a/Gems/Atom/TestData/TestData/Materials/StandardPbrTestCases/101_DetailMaps_LucyBaseNoDetailMaps.material
+++ b/Gems/Atom/TestData/TestData/Materials/StandardPbrTestCases/101_DetailMaps_LucyBaseNoDetailMaps.material
@@ -8,18 +8,24 @@
             "textureMap": "Objects/Lucy/Lucy_bronze_BaseColor.png",
             "textureMapUv": "Unwrapped"
         },
+        "detailUV": {
+            "center": [
+                0.0,
+                0.0
+            ]
+        },
         "metallic": {
-            "textureMap": "Objects/Lucy/Lucy_bronze_metallic.png",
+            "textureMap": "Objects/Lucy/Lucy_bronze_Metallic.png",
             "textureMapUv": "Unwrapped"
         },
         "normal": {
             "flipY": true,
-            "textureMap": "Objects/Lucy/Lucy_normal.png",
+            "textureMap": "Objects/Lucy/Lucy_Normal.png",
             "textureMapUv": "Unwrapped"
         },
         "roughness": {
-            "textureMap": "Objects/Lucy/Lucy_bronze_roughness.png",
+            "textureMap": "Objects/Lucy/Lucy_bronze_Roughness.png",
             "textureMapUv": "Unwrapped"
         }
     }
-}
+}
\ No newline at end of file
diff --git a/Gems/Atom/TestData/TestData/Materials/StandardPbrTestCases/102_DetailMaps_All.material b/Gems/Atom/TestData/TestData/Materials/StandardPbrTestCases/102_DetailMaps_All.material
index 55a01866b5..1a29f392c8 100644
--- a/Gems/Atom/TestData/TestData/Materials/StandardPbrTestCases/102_DetailMaps_All.material
+++ b/Gems/Atom/TestData/TestData/Materials/StandardPbrTestCases/102_DetailMaps_All.material
@@ -5,7 +5,7 @@
     "propertyLayoutVersion": 3,
     "properties": {
         "baseColor": {
-            "textureMap": "Objects/Lucy/Lucy_bronze_baseColor.png",
+            "textureMap": "Objects/Lucy/Lucy_bronze_BaseColor.png",
             "textureMapUv": "Unwrapped"
         },
         "detailLayerGroup": {
@@ -19,20 +19,24 @@
             "normalDetailStrength": 1.5
         },
         "detailUV": {
+            "center": [
+                0.0,
+                0.0
+            ],
             "scale": 10.0
         },
         "metallic": {
-            "textureMap": "Objects/Lucy/Lucy_bronze_metallic.png",
+            "textureMap": "Objects/Lucy/Lucy_bronze_Metallic.png",
             "textureMapUv": "Unwrapped"
         },
         "normal": {
             "flipY": true,
-            "textureMap": "Objects/Lucy/Lucy_normal.png",
+            "textureMap": "Objects/Lucy/Lucy_Normal.png",
             "textureMapUv": "Unwrapped"
         },
         "roughness": {
-            "textureMap": "Objects/Lucy/Lucy_bronze_roughness.png",
+            "textureMap": "Objects/Lucy/Lucy_bronze_Roughness.png",
             "textureMapUv": "Unwrapped"
         }
     }
-}
+}
\ No newline at end of file
diff --git a/Gems/Atom/TestData/TestData/Materials/StandardPbrTestCases/105_DetailMaps_BlendMaskUsingDetailUVs.material b/Gems/Atom/TestData/TestData/Materials/StandardPbrTestCases/105_DetailMaps_BlendMaskUsingDetailUVs.material
index 6193cf4eed..a69b72b623 100644
--- a/Gems/Atom/TestData/TestData/Materials/StandardPbrTestCases/105_DetailMaps_BlendMaskUsingDetailUVs.material
+++ b/Gems/Atom/TestData/TestData/Materials/StandardPbrTestCases/105_DetailMaps_BlendMaskUsingDetailUVs.material
@@ -5,7 +5,7 @@
     "propertyLayoutVersion": 3,
     "properties": {
         "baseColor": {
-            "textureMap": "Objects/Lucy/Lucy_bronze_baseColor.png",
+            "textureMap": "Objects/Lucy/Lucy_bronze_BaseColor.png",
             "textureMapUv": "Unwrapped"
         },
         "detailLayerGroup": {
@@ -18,20 +18,24 @@
             "normalDetailStrength": 1.5
         },
         "detailUV": {
+            "center": [
+                0.0,
+                0.0
+            ],
             "scale": 10.0
         },
         "metallic": {
-            "textureMap": "Objects/Lucy/Lucy_bronze_metallic.png",
+            "textureMap": "Objects/Lucy/Lucy_bronze_Metallic.png",
             "textureMapUv": "Unwrapped"
         },
         "normal": {
             "flipY": true,
-            "textureMap": "Objects/Lucy/Lucy_normal.png",
+            "textureMap": "Objects/Lucy/Lucy_Normal.png",
             "textureMapUv": "Unwrapped"
         },
         "roughness": {
-            "textureMap": "Objects/Lucy/Lucy_bronze_roughness.png",
+            "textureMap": "Objects/Lucy/Lucy_bronze_Roughness.png",
             "textureMapUv": "Unwrapped"
         }
     }
-}
+}
\ No newline at end of file
diff --git a/Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Viewport/RenderViewportWidget.h b/Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Viewport/RenderViewportWidget.h
index a41c8221f0..f2c120dbcd 100644
--- a/Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Viewport/RenderViewportWidget.h
+++ b/Gems/Atom/Tools/AtomToolsFramework/Code/Include/AtomToolsFramework/Viewport/RenderViewportWidget.h
@@ -98,6 +98,7 @@ namespace AtomToolsFramework
         AZStd::optional<AZ::Vector3> ViewportScreenToWorld(const AzFramework::ScreenPoint& screenPosition, float depth) override;
         AZStd::optional<AzToolsFramework::ViewportInteraction::ProjectedViewportRay> ViewportScreenToWorldRay(
             const AzFramework::ScreenPoint& screenPosition) override;
+        float DeviceScalingFactor() override;
 
         //! Set interface for providing viewport specific settings (e.g. snapping properties).
         void SetViewportSettings(const AzToolsFramework::ViewportInteraction::ViewportSettings* viewportSettings);
diff --git a/Gems/Atom/Tools/AtomToolsFramework/Code/Source/Viewport/RenderViewportWidget.cpp b/Gems/Atom/Tools/AtomToolsFramework/Code/Source/Viewport/RenderViewportWidget.cpp
index cee178c724..35edb3af5b 100644
--- a/Gems/Atom/Tools/AtomToolsFramework/Code/Source/Viewport/RenderViewportWidget.cpp
+++ b/Gems/Atom/Tools/AtomToolsFramework/Code/Source/Viewport/RenderViewportWidget.cpp
@@ -313,8 +313,7 @@ namespace AtomToolsFramework
         // Scale the size by the DPI of the platform to
         // get the proper size in pixels.
         const QSize uiWindowSize = size();
-        const qreal deficePixelRatio = devicePixelRatioF();
-        const QSize windowSize = uiWindowSize * deficePixelRatio;
+        const QSize windowSize = uiWindowSize * devicePixelRatioF();
 
         const AzFramework::NativeWindowHandle windowId = reinterpret_cast<AzFramework::NativeWindowHandle>(winId());
         AzFramework::WindowNotificationBus::Event(windowId, &AzFramework::WindowNotifications::OnWindowResized, windowSize.width(), windowSize.height());
@@ -465,6 +464,11 @@ namespace AtomToolsFramework
         return AzToolsFramework::ViewportInteraction::ProjectedViewportRay{rayOrigin, rayDirection};
     }
 
+    float RenderViewportWidget::DeviceScalingFactor()
+    {
+        return aznumeric_cast<float>(devicePixelRatioF());
+    }
+
     AzFramework::ScreenPoint RenderViewportWidget::ViewportCursorScreenPosition()
     {
         return AzToolsFramework::ViewportInteraction::ScreenPointFromQPoint(m_mousePosition.toPoint());
diff --git a/Gems/Atom/Tools/MaterialEditor/Code/Source/Window/CreateMaterialDialog/CreateMaterialDialog.cpp b/Gems/Atom/Tools/MaterialEditor/Code/Source/Window/CreateMaterialDialog/CreateMaterialDialog.cpp
index 6a4bb8c0f4..887019787b 100644
--- a/Gems/Atom/Tools/MaterialEditor/Code/Source/Window/CreateMaterialDialog/CreateMaterialDialog.cpp
+++ b/Gems/Atom/Tools/MaterialEditor/Code/Source/Window/CreateMaterialDialog/CreateMaterialDialog.cpp
@@ -71,6 +71,8 @@ namespace MaterialEditor
         QObject::connect(m_ui->m_materialTypeComboBox, static_cast<void (QComboBox::*)(const int)>(&QComboBox::currentIndexChanged), this, [this]() { UpdateMaterialTypeSelection(); });
         QObject::connect(m_ui->m_materialTypeComboBox, &QComboBox::currentTextChanged, this, [this]() { UpdateMaterialTypeSelection(); });
 
+        m_ui->m_materialTypeComboBox->model()->sort(0, Qt::AscendingOrder); 
+
         // Select the default material type from settings
         auto settings =
             AZ::UserSettings::CreateFind<MaterialDocumentSettings>(AZ::Crc32("MaterialDocumentSettings"), AZ::UserSettings::CT_GLOBAL);
diff --git a/Gems/AtomContent/LookDevelopmentStudioPixar/Assets/Materials/Bricks038_8K/bricks038.material b/Gems/AtomContent/LookDevelopmentStudioPixar/Assets/Materials/Bricks038_8K/bricks038.material
index 25e29b55e5..82b1cdb590 100644
--- a/Gems/AtomContent/LookDevelopmentStudioPixar/Assets/Materials/Bricks038_8K/bricks038.material
+++ b/Gems/AtomContent/LookDevelopmentStudioPixar/Assets/Materials/Bricks038_8K/bricks038.material
@@ -26,7 +26,6 @@
         },
         "parallax": {
             "algorithm": "POM",
-            "enable": true,
             "factor": 0.02500000037252903,
             "pdo": true,
             "quality": "Ultra",
diff --git a/Gems/AtomContent/LookDevelopmentStudioPixar/Assets/Materials/Concrete016_8K/Concrete016.material b/Gems/AtomContent/LookDevelopmentStudioPixar/Assets/Materials/Concrete016_8K/Concrete016.material
index 336d479b30..03fb0ea5be 100644
--- a/Gems/AtomContent/LookDevelopmentStudioPixar/Assets/Materials/Concrete016_8K/Concrete016.material
+++ b/Gems/AtomContent/LookDevelopmentStudioPixar/Assets/Materials/Concrete016_8K/Concrete016.material
@@ -31,7 +31,8 @@
             "algorithm": "ContactRefinement",
             "factor": 0.019999999552965165,
             "quality": "Ultra",
-            "textureMap": "Materials/Concrete016_8K/Concrete016_8K_Displacement.png"
+            "textureMap": "Materials/Concrete016_8K/Concrete016_8K_Displacement.png",
+            "useTexture": false
         },
         "roughness": {
             "textureMap": "Materials/Concrete016_8K/Concrete016_8K_Roughness.png"
diff --git a/Gems/AtomContent/LookDevelopmentStudioPixar/Assets/Materials/Fabric001_8K/Fabric001.material b/Gems/AtomContent/LookDevelopmentStudioPixar/Assets/Materials/Fabric001_8K/Fabric001.material
index 72610e8bb6..7d8c3d5142 100644
--- a/Gems/AtomContent/LookDevelopmentStudioPixar/Assets/Materials/Fabric001_8K/Fabric001.material
+++ b/Gems/AtomContent/LookDevelopmentStudioPixar/Assets/Materials/Fabric001_8K/Fabric001.material
@@ -20,7 +20,6 @@
         },
         "parallax": {
             "algorithm": "ContactRefinement",
-            "enable": true,
             "factor": 0.004999999888241291,
             "quality": "Ultra",
             "textureMap": "Materials/Fabric001_8K/Fabric001_8K_Displacement.png"
diff --git a/Gems/AtomContent/LookDevelopmentStudioPixar/Assets/Materials/Fabric030_4K/Fabric030.material b/Gems/AtomContent/LookDevelopmentStudioPixar/Assets/Materials/Fabric030_4K/Fabric030.material
index 458ab811b6..493bfab455 100644
--- a/Gems/AtomContent/LookDevelopmentStudioPixar/Assets/Materials/Fabric030_4K/Fabric030.material
+++ b/Gems/AtomContent/LookDevelopmentStudioPixar/Assets/Materials/Fabric030_4K/Fabric030.material
@@ -20,7 +20,6 @@
         },
         "parallax": {
             "algorithm": "ContactRefinement",
-            "enable": true,
             "factor": 0.0020000000949949028,
             "pdo": true,
             "quality": "Medium",
diff --git a/Gems/AtomContent/LookDevelopmentStudioPixar/Assets/Materials/PaintedPlaster015_8K/PaintedPlaster015.material b/Gems/AtomContent/LookDevelopmentStudioPixar/Assets/Materials/PaintedPlaster015_8K/PaintedPlaster015.material
index 57163f520d..a2bb2c7704 100644
--- a/Gems/AtomContent/LookDevelopmentStudioPixar/Assets/Materials/PaintedPlaster015_8K/PaintedPlaster015.material
+++ b/Gems/AtomContent/LookDevelopmentStudioPixar/Assets/Materials/PaintedPlaster015_8K/PaintedPlaster015.material
@@ -19,7 +19,6 @@
         },
         "parallax": {
             "algorithm": "ContactRefinement",
-            "enable": true,
             "factor": 0.009999999776482582,
             "pdo": true,
             "quality": "Ultra",
diff --git a/Gems/AtomContent/LookDevelopmentStudioPixar/Assets/Materials/baseboards.material b/Gems/AtomContent/LookDevelopmentStudioPixar/Assets/Materials/baseboards.material
index 625d872475..f75490c2ad 100644
--- a/Gems/AtomContent/LookDevelopmentStudioPixar/Assets/Materials/baseboards.material
+++ b/Gems/AtomContent/LookDevelopmentStudioPixar/Assets/Materials/baseboards.material
@@ -30,7 +30,8 @@
             "factor": 0.02500000037252903,
             "pdo": true,
             "quality": "Ultra",
-            "textureMap": "Materials/Bricks038_8K/Bricks038_8K_Displacement.png"
+            "textureMap": "Materials/Bricks038_8K/Bricks038_8K_Displacement.png",
+            "useTexture": false
         },
         "roughness": {
             "factor": 0.4343433976173401,
diff --git a/Gems/AtomContent/LookDevelopmentStudioPixar/Assets/Materials/crown.material b/Gems/AtomContent/LookDevelopmentStudioPixar/Assets/Materials/crown.material
index e3c6d9eae6..d7e2050dbd 100644
--- a/Gems/AtomContent/LookDevelopmentStudioPixar/Assets/Materials/crown.material
+++ b/Gems/AtomContent/LookDevelopmentStudioPixar/Assets/Materials/crown.material
@@ -22,7 +22,6 @@
         },
         "parallax": {
             "algorithm": "POM",
-            "enable": true,
             "factor": 0.02500000037252903,
             "pdo": true,
             "quality": "Ultra",
diff --git a/Gems/AtomContent/ReferenceMaterials/Assets/Materials/ConcreteStucco/concrete_stucco.material b/Gems/AtomContent/ReferenceMaterials/Assets/Materials/ConcreteStucco/concrete_stucco.material
index ab9f366ff6..d4e2016022 100644
--- a/Gems/AtomContent/ReferenceMaterials/Assets/Materials/ConcreteStucco/concrete_stucco.material
+++ b/Gems/AtomContent/ReferenceMaterials/Assets/Materials/ConcreteStucco/concrete_stucco.material
@@ -19,7 +19,8 @@
         },
         "parallax": {
             "factor": 0.0010101000079885126,
-            "textureMap": "Materials/ConcreteStucco/concrete_stucco_height.jpg"
+            "textureMap": "Materials/ConcreteStucco/concrete_stucco_height.jpg",
+            "useTexture": false
         },
         "specularF0": {
             "factor": 0.5050504803657532
diff --git a/Gems/AtomContent/Sponza/Assets/license.txt b/Gems/AtomContent/Sponza/Assets/license.txt
new file mode 100644
index 0000000000..e303d8c767
--- /dev/null
+++ b/Gems/AtomContent/Sponza/Assets/license.txt
@@ -0,0 +1,8 @@
+The content in this gem "O3DE\Gems\AtomContent\Sponza" is ported 
+from the original source, and modified for the O3DE Engine and Atom Renderer.
+
+The original "Crytek Sponza" scene data can be downloaded from the
+"McGuire Computer Graphics Archive": https://casual-effects.com/data/
+
+The original content is under the "CC BY 3.0" License:
+https://creativecommons.org/licenses/by/3.0/
\ No newline at end of file
diff --git a/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_arch.material b/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_arch.material
index 1102fb150a..d95e84121c 100644
--- a/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_arch.material
+++ b/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_arch.material
@@ -41,7 +41,8 @@
             "factor": 0.050999999046325687,
             "pdo": true,
             "quality": "High",
-            "textureMap": "Textures/arch_1k_height.png"
+            "textureMap": "Textures/arch_1k_height.png",
+            "useTexture": false
         },
         "roughness": {
             "textureMap": "Textures/arch_1k_roughness.png"
diff --git a/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_background.material b/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_background.material
index c1853250d7..710f790419 100644
--- a/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_background.material
+++ b/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_background.material
@@ -47,7 +47,8 @@
             "factor": 0.03099999949336052,
             "pdo": true,
             "quality": "High",
-            "textureMap": "Textures/background_1k_height.png"
+            "textureMap": "Textures/background_1k_height.png",
+            "useTexture": false
         },
         "roughness": {
             "textureMap": "Textures/background_1k_roughness.png"
diff --git a/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_bricks.material b/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_bricks.material
index a269098b4d..26d64c7db9 100644
--- a/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_bricks.material
+++ b/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_bricks.material
@@ -46,7 +46,8 @@
             "algorithm": "ContactRefinement",
             "factor": 0.03500000014901161,
             "quality": "Medium",
-            "textureMap": "Textures/bricks_1k_height.png"
+            "textureMap": "Textures/bricks_1k_height.png",
+            "useTexture": false
         },
         "roughness": {
             "textureMap": "Textures/bricks_1k_roughness.png"
diff --git a/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_ceiling.material b/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_ceiling.material
index 94225cd00e..95d08d398b 100644
--- a/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_ceiling.material
+++ b/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_ceiling.material
@@ -48,7 +48,8 @@
             "factor": 0.019999999552965165,
             "pdo": true,
             "quality": "Medium",
-            "textureMap": "Textures/ceiling_1k_height.png"
+            "textureMap": "Textures/ceiling_1k_height.png",
+            "useTexture": false
         },
         "roughness": {
             "textureMap": "Textures/ceiling_1k_roughness.png"
diff --git a/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_columna.material b/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_columna.material
index 8f1cea8649..cc1f685c7c 100644
--- a/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_columna.material
+++ b/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_columna.material
@@ -47,7 +47,8 @@
             "factor": 0.017000000923871995,
             "pdo": true,
             "quality": "High",
-            "textureMap": "Textures/columnA_1k_height.png"
+            "textureMap": "Textures/columnA_1k_height.png",
+            "useTexture": false
         },
         "roughness": {
             "textureMap": "Textures/columnA_1k_roughness.png"
diff --git a/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_columnb.material b/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_columnb.material
index ac474d7e76..a1e8747f65 100644
--- a/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_columnb.material
+++ b/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_columnb.material
@@ -46,7 +46,8 @@
             "factor": 0.020999999716877939,
             "pdo": true,
             "quality": "High",
-            "textureMap": "Textures/columnB_1k_height.png"
+            "textureMap": "Textures/columnB_1k_height.png",
+            "useTexture": false
         },
         "roughness": {
             "textureMap": "Textures/columnB_1k_roughness.png"
diff --git a/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_columnc.material b/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_columnc.material
index 81fd03fc4a..6edbfde47c 100644
--- a/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_columnc.material
+++ b/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_columnc.material
@@ -47,7 +47,8 @@
             "factor": 0.014000000432133675,
             "pdo": true,
             "quality": "High",
-            "textureMap": "Textures/columnC_1k_height.png"
+            "textureMap": "Textures/columnC_1k_height.png",
+            "useTexture": false
         },
         "roughness": {
             "textureMap": "Textures/columnC_1k_roughness.png"
diff --git a/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_details.material b/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_details.material
index fde599fd4c..1b66a51ec0 100644
--- a/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_details.material
+++ b/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_details.material
@@ -38,7 +38,8 @@
             "algorithm": "POM",
             "factor": 0.02500000037252903,
             "pdo": true,
-            "textureMap": "Textures/details_1k_height.png"
+            "textureMap": "Textures/details_1k_height.png",
+            "useTexture": false
         },
         "roughness": {
             "textureMap": "Textures/details_1k_roughness.png"
diff --git a/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_flagpole.material b/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_flagpole.material
index e50e8a0ed2..19010d66e5 100644
--- a/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_flagpole.material
+++ b/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_flagpole.material
@@ -41,7 +41,8 @@
             "factor": 0.014000000432133675,
             "pdo": true,
             "quality": "High",
-            "textureMap": "Textures/flagpole_1k_height.png"
+            "textureMap": "Textures/flagpole_1k_height.png",
+            "useTexture": false
         },
         "roughness": {
             "textureMap": "Textures/flagpole_1k_roughness.png"
diff --git a/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_floor.material b/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_floor.material
index 064a2b24a6..bee92e0edb 100644
--- a/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_floor.material
+++ b/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_floor.material
@@ -43,7 +43,8 @@
             "algorithm": "POM",
             "factor": 0.012000000104308129,
             "pdo": true,
-            "textureMap": "Textures/floor_1k_height.png"
+            "textureMap": "Textures/floor_1k_height.png",
+            "useTexture": false
         },
         "roughness": {
             "textureMap": "Textures/floor_1k_roughness.png"
diff --git a/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_leaf.material b/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_leaf.material
index 269e1e5684..ac326ae935 100644
--- a/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_leaf.material
+++ b/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_leaf.material
@@ -42,7 +42,8 @@
             "mode": "Cutout"
         },
         "parallax": {
-            "textureMap": "Textures/thorn_height.png"
+            "textureMap": "Textures/thorn_height.png",
+            "useTexture": false
         },
         "roughness": {
             "textureMap": "Textures/thorn_roughness.png"
diff --git a/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_lion.material b/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_lion.material
index 8dc4852b03..b1f78aa33f 100644
--- a/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_lion.material
+++ b/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_lion.material
@@ -38,7 +38,6 @@
         },
         "parallax": {
             "algorithm": "ContactRefinement",
-            "enable": true,
             "factor": 0.009999999776482582,
             "pdo": true,
             "quality": "Ultra",
diff --git a/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_roof.material b/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_roof.material
index 0a7246703c..a3e066a438 100644
--- a/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_roof.material
+++ b/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_roof.material
@@ -35,7 +35,8 @@
             "algorithm": "ContactRefinement",
             "factor": 0.019999999552965165,
             "quality": "Medium",
-            "textureMap": "Textures/roof_1k_height.png"
+            "textureMap": "Textures/roof_1k_height.png",
+            "useTexture": false
         },
         "roughness": {
             "textureMap": "Textures/roof_1k_roughness.png"
diff --git a/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_vase.material b/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_vase.material
index 77adc798a0..dea9aa2a8a 100644
--- a/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_vase.material
+++ b/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_vase.material
@@ -41,7 +41,8 @@
             "factor": 0.027000000700354577,
             "pdo": true,
             "quality": "High",
-            "textureMap": "Textures/vase_1k_height.png"
+            "textureMap": "Textures/vase_1k_height.png",
+            "useTexture": false
         },
         "roughness": {
             "textureMap": "Textures/vase_1k_roughness.png"
diff --git a/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_vasehanging.material b/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_vasehanging.material
index 22e78f03ae..b2a342dd76 100644
--- a/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_vasehanging.material
+++ b/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_vasehanging.material
@@ -41,7 +41,8 @@
             "factor": 0.04600000008940697,
             "pdo": true,
             "quality": "High",
-            "textureMap": "Textures/vaseHanging_1k_height.png"
+            "textureMap": "Textures/vaseHanging_1k_height.png",
+            "useTexture": false
         },
         "roughness": {
             "textureMap": "Textures/vaseHanging_1k_roughness.png"
diff --git a/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_vaseround.material b/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_vaseround.material
index c773146b51..fba07379c0 100644
--- a/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_vaseround.material
+++ b/Gems/AtomContent/Sponza/Assets/objects/sponza_mat_vaseround.material
@@ -45,7 +45,8 @@
             "factor": 0.019999999552965165,
             "pdo": true,
             "quality": "High",
-            "textureMap": "Textures/vaseRound_1k_height.png"
+            "textureMap": "Textures/vaseRound_1k_height.png",
+            "useTexture": false
         },
         "roughness": {
             "textureMap": "Textures/vaseRound_1k_roughness.png"
diff --git a/Gems/AtomContent/Sponza/Assets/stub b/Gems/AtomContent/Sponza/Assets/stub
deleted file mode 100644
index e69de29bb2..0000000000
diff --git a/Gems/AtomLyIntegration/AtomViewportDisplayIcons/Code/Source/AtomViewportDisplayIconsSystemComponent.cpp b/Gems/AtomLyIntegration/AtomViewportDisplayIcons/Code/Source/AtomViewportDisplayIconsSystemComponent.cpp
index dce83c3072..5fe8c50350 100644
--- a/Gems/AtomLyIntegration/AtomViewportDisplayIcons/Code/Source/AtomViewportDisplayIconsSystemComponent.cpp
+++ b/Gems/AtomLyIntegration/AtomViewportDisplayIcons/Code/Source/AtomViewportDisplayIconsSystemComponent.cpp
@@ -18,6 +18,7 @@
 #include <AzCore/std/containers/array.h>
 
 #include <AzFramework/Asset/AssetSystemBus.h>
+#include <AzFramework/Viewport/ViewportScreen.h>
 
 #include <AzToolsFramework/Viewport/ViewportMessages.h>
 #include <AzToolsFramework/API/EditorAssetSystemAPI.h>
@@ -145,12 +146,24 @@ namespace AZ::Render
         }
 
         // Initialize our shader
-        auto viewportSize = viewportContext->GetViewportSize();
+        AZ::Vector2 viewportSize;
+        {
+            AzFramework::WindowSize viewportWindowSize = viewportContext->GetViewportSize();
+            viewportSize = AZ::Vector2{aznumeric_cast<float>(viewportWindowSize.m_width), aznumeric_cast<float>(viewportWindowSize.m_height)};
+        }
         AZ::Data::Instance<AZ::RPI::ShaderResourceGroup> drawSrg = dynamicDraw->NewDrawSrg();
-        drawSrg->SetConstant(m_viewportSizeIndex, AZ::Vector2(aznumeric_cast<float>(viewportSize.m_width), aznumeric_cast<float>(viewportSize.m_height)));
+        drawSrg->SetConstant(m_viewportSizeIndex,viewportSize);
         drawSrg->SetImageView(m_textureParameterIndex, image->GetImageView());
         drawSrg->Compile();
 
+        // Scale icons by screen DPI
+        float scalingFactor = 1.0f;
+        {
+            using ViewportRequestBus = AzToolsFramework::ViewportInteraction::ViewportInteractionRequestBus;
+            ViewportRequestBus::EventResult(
+                scalingFactor, drawParameters.m_viewport, &ViewportRequestBus::Events::DeviceScalingFactor);
+        }
+
         AZ::Vector3 screenPosition;
         if (drawParameters.m_positionSpace == CoordinateSpace::ScreenSpace)
         {
@@ -158,9 +171,11 @@ namespace AZ::Render
         }
         else if (drawParameters.m_positionSpace == CoordinateSpace::WorldSpace)
         {
-            using ViewportRequestBus = AzToolsFramework::ViewportInteraction::ViewportInteractionRequestBus;
-            AzFramework::ScreenPoint position;
-            ViewportRequestBus::EventResult(position, drawParameters.m_viewport, &ViewportRequestBus::Events::ViewportWorldToScreen, drawParameters.m_position);
+            // Calculate our screen space position using the viewport size
+            // We want this instead of RenderViewportWidget::WorldToScreen which works in QWidget virtual coordinate space
+            AzFramework::ScreenPoint position = AzFramework::WorldToScreen(
+                drawParameters.m_position, viewportContext->GetCameraViewMatrix(), viewportContext->GetCameraProjectionMatrix(),
+                viewportSize);
             screenPosition.SetX(aznumeric_cast<float>(position.m_x));
             screenPosition.SetY(aznumeric_cast<float>(position.m_y));
         }
@@ -179,8 +194,8 @@ namespace AZ::Render
         {
             Vertex vertex;
             screenPosition.StoreToFloat3(vertex.m_position);
-            vertex.m_position[0] += offsetX * drawParameters.m_size.GetX();
-            vertex.m_position[1] += offsetY * drawParameters.m_size.GetY();
+            vertex.m_position[0] += offsetX * drawParameters.m_size.GetX() * scalingFactor;
+            vertex.m_position[1] += offsetY * drawParameters.m_size.GetY() * scalingFactor;
             vertex.m_color = drawParameters.m_color.ToU32();
             vertex.m_uv[0] = u;
             vertex.m_uv[1] = v;
@@ -197,8 +212,15 @@ namespace AZ::Render
         dynamicDraw->DrawIndexed(&vertices, vertices.size(), &indices, indices.size(), RHI::IndexFormat::Uint16, drawSrg);
     }
 
-    QString AtomViewportDisplayIconsSystemComponent::FindAssetPath(const QString& sourceRelativePath) const
+    QString AtomViewportDisplayIconsSystemComponent::FindAssetPath(const QString& path) const
     {
+        // If we get an absolute path, just use it.
+        QFileInfo pathInfo(path);
+        if (pathInfo.isAbsolute())
+        {
+            return path;
+        }
+
         bool found = false;
         AZStd::vector<AZStd::string> scanFolders;
         AzToolsFramework::AssetSystemRequestBus::BroadcastResult(
@@ -212,9 +234,9 @@ namespace AZ::Render
         for (const auto& folder : scanFolders)
         {
             QDir dir(folder.data());
-            if (dir.exists(sourceRelativePath))
+            if (dir.exists(path))
             {
-                return dir.absoluteFilePath(sourceRelativePath);
+                return dir.absoluteFilePath(path);
             }
         }
 
@@ -256,10 +278,6 @@ namespace AZ::Render
     AzToolsFramework::EditorViewportIconDisplayInterface::IconId AtomViewportDisplayIconsSystemComponent::GetOrLoadIconForPath(
         AZStd::string_view path)
     {
-        AZ_Error(
-            "AtomViewportDisplayIconsSystemComponent", AzFramework::StringFunc::Path::IsRelative(path.data()),
-            "GetOrLoadIconForPath assumes that it will always be given a relative path, but got '%s'", path.data());
-
         // Check our cache to see if the image is already loaded
         auto existingEntryIt = AZStd::find_if(m_iconData.begin(), m_iconData.end(), [&path](const auto& iconData)
         {
diff --git a/Gems/AtomLyIntegration/AtomViewportDisplayIcons/Code/Source/AtomViewportDisplayIconsSystemComponent.h b/Gems/AtomLyIntegration/AtomViewportDisplayIcons/Code/Source/AtomViewportDisplayIconsSystemComponent.h
index 0c7366f23b..b44957b51d 100644
--- a/Gems/AtomLyIntegration/AtomViewportDisplayIcons/Code/Source/AtomViewportDisplayIconsSystemComponent.h
+++ b/Gems/AtomLyIntegration/AtomViewportDisplayIcons/Code/Source/AtomViewportDisplayIconsSystemComponent.h
@@ -61,7 +61,7 @@ namespace AZ
             static constexpr QSize MinimumRenderedSvgSize = QSize(128, 128);
             static constexpr QImage::Format QtImageFormat = QImage::Format_RGBA8888;
 
-            QString FindAssetPath(const QString& sourceRelativePath) const;
+            QString FindAssetPath(const QString& path) const;
             QImage RenderSvgToImage(const QString& svgPath) const;
             AZ::Data::Instance<AZ::RPI::Image> ConvertToAtomImage(AZ::Uuid assetId, QImage image) const;
 
diff --git a/Gems/AtomLyIntegration/AtomViewportDisplayInfo/Code/Source/AtomViewportDisplayInfoSystemComponent.cpp b/Gems/AtomLyIntegration/AtomViewportDisplayInfo/Code/Source/AtomViewportDisplayInfoSystemComponent.cpp
index 30841648ae..146c0c67d0 100644
--- a/Gems/AtomLyIntegration/AtomViewportDisplayInfo/Code/Source/AtomViewportDisplayInfoSystemComponent.cpp
+++ b/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)
         {
diff --git a/Tools/LyTestTools/ly_test_tools/_internal/managers/abstract_resource_locator.py b/Tools/LyTestTools/ly_test_tools/_internal/managers/abstract_resource_locator.py
index 5a14ef9419..ec4b43b023 100755
--- a/Tools/LyTestTools/ly_test_tools/_internal/managers/abstract_resource_locator.py
+++ b/Tools/LyTestTools/ly_test_tools/_internal/managers/abstract_resource_locator.py
@@ -16,8 +16,10 @@ import pathlib
 import warnings
 from abc import ABCMeta, abstractmethod
 
+import ly_test_tools._internal.pytest_plugin
 from ly_test_tools.environment.file_system import find_ancestor_file
 
+
 def _find_engine_root(initial_path):
     # type: (str) -> str
     """
@@ -34,11 +36,9 @@ def _find_engine_root(initial_path):
     # Assumes folder structure similar to: engine_root/dev/Tools/.../ly_test_tools/builtin
     for _ in range(15):
         if os.path.exists(os.path.join(current_dir, root_file)):
-            # The parent of the directory containing the engineroot.txt is the root directory
-            engine_root = current_dir
-            return engine_root
-        # Using an explicit else to avoid aberrant behavior from following filesystem links
-        else:
+            # parent of the directory containing root_file
+            return current_dir
+        else:  # explicit else avoids aberrant behavior from following filesystem links
             current_dir = os.path.abspath(os.path.join(current_dir, os.path.pardir))
 
     raise OSError(f"Unable to find engine root directory. Verify root file '{root_file}' exists")
@@ -50,8 +50,10 @@ def _find_project_json(engine_root, project):
     Find the project.json file for this project.
     :return: Full path to the project.json file
     """
-    project_json = find_ancestor_file('project.json')
-    if not project_json:
+    # First check relative to defined build directory, for external projects which configure through SDK settings
+    project_json = find_ancestor_file(target_file_name='project.json',
+                                      start_path=ly_test_tools._internal.pytest_plugin.build_directory)
+    if not project_json:  # check internally for a project bundled with the engine
         project_json = os.path.join(engine_root, project, 'project.json')
 
     return project_json
diff --git a/cmake/Packaging.cmake b/cmake/Packaging.cmake
index fbeffa94eb..84bad13687 100644
--- a/cmake/Packaging.cmake
+++ b/cmake/Packaging.cmake
@@ -17,6 +17,8 @@ endif()
 set(LY_INSTALLER_DOWNLOAD_URL "" CACHE STRING "URL embedded into the installer to download additional artifacts")
 set(LY_INSTALLER_LICENSE_URL "" CACHE STRING "Optionally embed a link to the license instead of raw text")
 
+set(CPACK_DESIRED_CMAKE_VERSION 3.20.2)
+
 # set all common cpack variable overrides first so they can be accessible via configure_file
 # when the platform specific settings are applied below.  additionally, any variable with
 # the "CPACK_" prefix will automatically be cached for use in any phase of cpack namely
@@ -38,6 +40,7 @@ set(CPACK_PACKAGE_INSTALL_DIRECTORY "${CPACK_PACKAGE_VENDOR}/${CPACK_PACKAGE_VER
 
 # neither of the SOURCE_DIR variables equate to anything during execution of pre/post build scripts
 set(CPACK_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/cmake)
+set(CPACK_BINARY_DIR ${CMAKE_BINARY_DIR}/_CPack) # to match other CPack out dirs
 
 # attempt to apply platform specific settings
 ly_get_absolute_pal_filename(pal_dir ${CPACK_SOURCE_DIR}/Platform/${PAL_HOST_PLATFORM_NAME})
@@ -48,6 +51,53 @@ if(NOT CPACK_GENERATOR)
     return()
 endif()
 
+# pull down the desired copy of CMake so it can be included in the package
+if(NOT (CPACK_CMAKE_PACKAGE_FILE AND CPACK_CMAKE_PACKAGE_HASH))
+    message(FATAL_ERROR
+        "Packaging is missing one or more following properties required to include CMake: "
+        " CPACK_CMAKE_PACKAGE_FILE, CPACK_CMAKE_PACKAGE_HASH")
+endif()
+
+set(_cmake_package_dest ${CPACK_BINARY_DIR}/${CPACK_CMAKE_PACKAGE_FILE})
+
+string(REPLACE "." ";" _version_componets "${CPACK_DESIRED_CMAKE_VERSION}")
+list(GET _version_componets 0 _major_version)
+list(GET _version_componets 1 _minor_version)
+
+set(_url_version_tag "v${_major_version}.${_minor_version}")
+set(_package_url "https://cmake.org/files/${_url_version_tag}/${CPACK_CMAKE_PACKAGE_FILE}")
+
+message(STATUS "Ensuring CMake ${CPACK_DESIRED_CMAKE_VERSION} is available for packaging...")
+download_file(
+    URL ${_package_url}
+    TARGET_FILE ${_cmake_package_dest}
+    EXPECTED_HASH ${CPACK_CMAKE_PACKAGE_HASH}
+    RESULTS _results
+)
+list(GET _results 0 _status_code)
+
+if (${_status_code} EQUAL 0 AND EXISTS ${_cmake_package_dest})
+    message(STATUS "-> Package found and verified!")
+else()
+    file(REMOVE ${_cmake_package_dest})
+    list(REMOVE_AT _results 0)
+
+    set(_error_message "An error occurred, code ${_status_code}.  URL ${_package_url} - ${_results}")
+
+    if(${_status_code} EQUAL 1)
+        string(APPEND _error_message
+            "  Please double check the CPACK_CMAKE_PACKAGE_FILE and "
+            "CPACK_CMAKE_PACKAGE_HASH properties before trying again.")
+    endif()
+
+    message(FATAL_ERROR ${_error_message})
+endif()
+
+install(FILES ${_cmake_package_dest}
+    DESTINATION ./Tools/Redistributables/CMake
+    COMPONENT ${LY_DEFAULT_INSTALL_COMPONENT}
+)
+
 # IMPORTANT: required to be included AFTER setting all property overrides
 include(CPack REQUIRED)
 
diff --git a/cmake/Platform/Windows/Packaging/PostInstallSetup.wxs b/cmake/Platform/Windows/Packaging/PostInstallSetup.wxs
new file mode 100644
index 0000000000..d4f6c181dd
--- /dev/null
+++ b/cmake/Platform/Windows/Packaging/PostInstallSetup.wxs
@@ -0,0 +1,65 @@
+<?xml version='1.0' encoding='windows-1252'?>
+
+<?include "cpack_variables.wxi"?>
+
+<Wix xmlns='http://schemas.microsoft.com/wix/2006/wi'
+    xmlns:util="http://schemas.microsoft.com/wix/UtilExtension">
+    <Fragment>
+
+        <!-- RemoveFolderEx works on properties instead of directory references -->
+        <Property Id="INSTALLPATH">
+            <RegistrySearch Id="INSTALLPATH_REGSEARCH"
+                Root="HKLM"
+                Key="Software\$(var.CPACK_PACKAGE_VENDOR)\$(var.CPACK_PACKAGE_NAME)\$(var.CPACK_PACKAGE_VERSION)"
+                Name="Install Path"
+                Type="raw"/>
+        </Property>
+
+        <DirectoryRef Id="INSTALL_ROOT">
+            <!-- this will clear out any additional files as part of the installation that weren't originally
+                included of the MSI table -->
+            <Component Id="SanitizeInstallFolder" Guid="{85468941-52E6-4C04-A66D-8E3CA3BBF04A}">
+                <Condition><![CDATA[Installed OR NOT MANUALPRODUCTFOUND]]></Condition>
+                <util:RemoveFolderEx On="uninstall" Property="INSTALLPATH"/>
+
+                <!-- registry entry is required to properly initialize the property during uninstall-->
+                <RegistryValue Root="HKLM"
+                    Key="Software\$(var.CPACK_PACKAGE_VENDOR)\$(var.CPACK_PACKAGE_NAME)\$(var.CPACK_PACKAGE_VERSION)"
+                    Name="Install Path"
+                    Type="string"
+                    Value="[INSTALL_ROOT]"
+                    KeyPath="yes"/>
+            </Component>
+
+            <!-- installation directory references for use in post install commands -->
+            <Directory Id="root.cmake" Name="cmake">
+                <Directory Id="root.cmake.runtime" Name="runtime"/>
+            </Directory>
+            <Directory Id="root.python" Name="python"/>
+            <Directory Id="root.tools" Name="Tools">
+                <Directory Id="root.tools.redist" Name="Redistributables">
+                    <Directory Id="root.tools.redist.cmake" Name="CMake"/>
+                </Directory>
+            </Directory>
+        </DirectoryRef>
+
+        <CustomAction Id="ExtractCMake"
+            ExeCommand="&quot;[SystemFolder]cmd.exe&quot; /C tar -x -f &quot;[root.tools.redist.cmake]$(var.CPACK_CMAKE_PACKAGE_NAME).zip&quot; -C &quot;[root.tools.redist]CMake&quot;"
+            Directory="INSTALL_ROOT"
+            Execute="deferred"
+            Impersonate="no"/>
+
+        <CustomAction Id="MoveCMake"
+            ExeCommand="&quot;[SystemFolder]cmd.exe&quot; /C move &quot;[root.tools.redist.cmake]$(var.CPACK_CMAKE_PACKAGE_NAME)&quot; &quot;[root.cmake]runtime&quot;"
+            Directory="INSTALL_ROOT"
+            Execute="deferred"
+            Impersonate="no"/>
+
+        <CustomAction Id="ConfigurePython"
+            ExeCommand="&quot;[SystemFolder]cmd.exe&quot; /C set &quot;LY_CMAKE_PATH=[root.cmake.runtime]bin&quot; &amp;&amp; &quot;[root.python]get_python.bat&quot;"
+            Directory="INSTALL_ROOT"
+            Execute="deferred"
+            Impersonate="no"/>
+
+    </Fragment>
+</Wix>
diff --git a/cmake/Platform/Windows/Packaging/Template.wxs.in b/cmake/Platform/Windows/Packaging/Template.wxs.in
index 2900b96f41..e14e064fbc 100644
--- a/cmake/Platform/Windows/Packaging/Template.wxs.in
+++ b/cmake/Platform/Windows/Packaging/Template.wxs.in
@@ -17,8 +17,7 @@
         <!-- auto distribute the installable files across N cab files -->
         <MediaTemplate EmbedCab="$(var.CPACK_EMBED_ARTIFACTS)"/>
 
-        <MajorUpgrade
-            Schedule="afterInstallInitialize"
+        <MajorUpgrade Schedule="afterInstallInitialize"
             AllowSameVersionUpgrades="yes"
             DowngradeErrorMessage="A later version of [ProductName] is already installed. Setup will now exit."/>
 
@@ -41,8 +40,24 @@
         <FeatureRef Id="ProductFeature">
             <ComponentRef Id="DesktopShortcuts"/>
             <ComponentRef Id="StartMenuShortcuts"/>
+
+            <!-- for removing cmake and python on uninstall -->
+            <ComponentRef Id="SanitizeInstallFolder"/>
         </FeatureRef>
 
+        <InstallExecuteSequence>
+            <!-- limit the actions to first time install and repairs -->
+            <Custom Action="ExtractCMake" Before="InstallFinalize">
+                NOT Installed Or REINSTALL
+            </Custom>
+            <Custom Action="MoveCMake" After="ExtractCMake">
+                NOT Installed Or REINSTALL
+            </Custom>
+            <Custom Action="ConfigurePython" After="MoveCMake">
+                NOT Installed Or REINSTALL
+            </Custom>
+        </InstallExecuteSequence>
+
         <UIRef Id="$(var.CPACK_WIX_UI_REF)" />
 
         <?include "properties.wxi"?>
diff --git a/cmake/Platform/Windows/Packaging_windows.cmake b/cmake/Platform/Windows/Packaging_windows.cmake
index ce73e9a07b..db9c7fc906 100644
--- a/cmake/Platform/Windows/Packaging_windows.cmake
+++ b/cmake/Platform/Windows/Packaging_windows.cmake
@@ -28,6 +28,10 @@ endif()
 
 set(CPACK_GENERATOR "WIX")
 
+set(_cmake_package_name "cmake-${CPACK_DESIRED_CMAKE_VERSION}-windows-x86_64")
+set(CPACK_CMAKE_PACKAGE_FILE "${_cmake_package_name}.zip")
+set(CPACK_CMAKE_PACKAGE_HASH "15a49e2ab81c1822d75b1b1a92f7863f58e31f6d6aac1c4103eef2b071be3112")
+
 # CPack will generate the WiX product/upgrade GUIDs further down the chain if they weren't supplied
 # however, they are unique for each run.  instead, let's do the auto generation here and add it to
 # the cache for run persistence and have the ability to detect if they are still being used.
@@ -83,9 +87,14 @@ set(CPACK_WIX_PRODUCT_ICON ${CPACK_SOURCE_DIR}/Platform/Windows/Packaging/produc
 set(CPACK_WIX_TEMPLATE "${CPACK_SOURCE_DIR}/Platform/Windows/Packaging/Template.wxs.in")
 
 set(CPACK_WIX_EXTRA_SOURCES
+    "${CPACK_SOURCE_DIR}/Platform/Windows/Packaging/PostInstallSetup.wxs"
     "${CPACK_SOURCE_DIR}/Platform/Windows/Packaging/Shortcuts.wxs"
 )
 
+set(CPACK_WIX_EXTENSIONS
+    WixUtilExtension
+)
+
 set(_embed_artifacts "yes")
 
 if(LY_INSTALLER_DOWNLOAD_URL)
@@ -101,4 +110,5 @@ endif()
 
 set(CPACK_WIX_CANDLE_EXTRA_FLAGS
     -dCPACK_EMBED_ARTIFACTS=${_embed_artifacts}
+    -dCPACK_CMAKE_PACKAGE_NAME=${_cmake_package_name}
 )