conflict fix

Signed-off-by: sphrose <82213493+sphrose@users.noreply.github.com>

AutomatedTesting/Editor/Scripts/auto_lod.py

@@ -0,0 +1,124 @@
+#
+# Copyright (c) Contributors to the Open 3D Engine Project.
+# For complete copyright and license terms please see the LICENSE at the root of this distribution.
+#
+# SPDX-License-Identifier: Apache-2.0 OR MIT
+#
+#
+import os, traceback, binascii, sys, json, pathlib, logging
+import azlmbr.math
+import azlmbr.bus
+from scene_helpers import *
+
+#
+# SceneAPI Processor
+#
+
+def update_manifest(scene):
+    import uuid
+    import azlmbr.scene as sceneApi
+    import azlmbr.scene.graph
+    from scene_api import scene_data as sceneData
+
+    graph = sceneData.SceneGraph(scene.graph)
+    # Get a list of all the mesh nodes, as well as all the nodes
+    mesh_name_list, all_node_paths = get_mesh_node_names(graph)
+    mesh_name_list.sort(key=lambda node: str.casefold(node.get_path()))
+    scene_manifest = sceneData.SceneManifest()
+
+    clean_filename = scene.sourceFilename.replace('.', '_')
+
+    # Compute the filename of the scene file
+    source_basepath = scene.watchFolder
+    source_relative_path = os.path.dirname(os.path.relpath(clean_filename, source_basepath))
+    source_filename_only = os.path.basename(clean_filename)
+
+    created_entities = []
+    previous_entity_id = azlmbr.entity.InvalidEntityId
+    first_mesh = True
+
+    # Make a list of mesh node paths
+    mesh_path_list = list(map(lambda node: node.get_path(), mesh_name_list))
+
+    # Assume the first mesh is the main mesh
+    main_mesh = mesh_name_list[0]
+    mesh_path = main_mesh.get_path()
+
+    # Create a unique mesh group name using the filename + node name
+    mesh_group_name = '{}_{}'.format(source_filename_only, main_mesh.get_name())
+    # Remove forbidden filename characters from the name since this will become a file on disk later
+    mesh_group_name = "".join(char for char in mesh_group_name if char not in "|<>:\"/?*\\")
+    # Add the MeshGroup to the manifest and give it a unique ID
+    mesh_group = scene_manifest.add_mesh_group(mesh_group_name)
+    mesh_group['id'] = '{' + str(uuid.uuid5(uuid.NAMESPACE_DNS, source_filename_only + mesh_path)) + '}'
+    # Set our current node as the only node that is included in this MeshGroup
+    scene_manifest.mesh_group_select_node(mesh_group, mesh_path)
+
+    # Explicitly remove all other nodes to prevent implicit inclusions
+    for node in mesh_path_list:
+        if node != mesh_path:
+            scene_manifest.mesh_group_unselect_node(mesh_group, node)
+
+    # Create a LOD rule
+    lod_rule = scene_manifest.mesh_group_add_lod_rule(mesh_group)
+
+    # Loop all the mesh nodes after the first
+    for x in mesh_path_list[1:]:
+        # Add a new LOD level
+        lod = scene_manifest.lod_rule_add_lod(lod_rule)
+        # Select the current mesh for this LOD level
+        scene_manifest.lod_select_node(lod, x)
+
+        # Unselect every other mesh for this LOD level
+        for y in mesh_path_list:
+            if y != x:
+                scene_manifest.lod_unselect_node(lod, y)
+
+    # Create an editor entity
+    entity_id = azlmbr.entity.EntityUtilityBus(azlmbr.bus.Broadcast, "CreateEditorReadyEntity", mesh_group_name)
+    # Add an EditorMeshComponent to the entity
+    editor_mesh_component = azlmbr.entity.EntityUtilityBus(azlmbr.bus.Broadcast, "GetOrAddComponentByTypeName", entity_id, "AZ::Render::EditorMeshComponent")
+    # Set the ModelAsset assetHint to the relative path of the input asset + the name of the MeshGroup we just created + the azmodel extension
+    # The MeshGroup we created will be output as a product in the asset's path named mesh_group_name.azmodel
+    # The assetHint will be converted to an AssetId later during prefab loading
+    json_update = json.dumps({
+        "Controller": { "Configuration": { "ModelAsset": {
+            "assetHint": os.path.join(source_relative_path, mesh_group_name) + ".azmodel" }}}
+        });
+    # Apply the JSON above to the component we created
+    result = azlmbr.entity.EntityUtilityBus(azlmbr.bus.Broadcast, "UpdateComponentForEntity", entity_id, editor_mesh_component, json_update)
+
+    if not result:
+        raise RuntimeError("UpdateComponentForEntity failed for Mesh component")
+
+    create_prefab(scene_manifest, source_filename_only, [entity_id])
+
+    # Convert the manifest to a JSON string and return it
+    new_manifest = scene_manifest.export()
+
+    return new_manifest
+
+sceneJobHandler = None
+
+def on_update_manifest(args):
+    try:
+        scene = args[0]
+        return update_manifest(scene)
+    except RuntimeError as err:
+        print (f'ERROR - {err}')
+        log_exception_traceback()
+    except:
+        log_exception_traceback()
+
+    global sceneJobHandler
+    sceneJobHandler = None
+
+# try to create SceneAPI handler for processing
+try:
+    import azlmbr.scene as sceneApi
+    if (sceneJobHandler == None):
+        sceneJobHandler = sceneApi.ScriptBuildingNotificationBusHandler()
+        sceneJobHandler.connect()
+        sceneJobHandler.add_callback('OnUpdateManifest', on_update_manifest)
+except:
+    sceneJobHandler = None

AutomatedTesting/Editor/Scripts/scene_helpers.py

@@ -0,0 +1,95 @@
+"""
+Copyright (c) Contributors to the Open 3D Engine Project.
+For complete copyright and license terms please see the LICENSE at the root of this distribution.
+
+SPDX-License-Identifier: Apache-2.0 OR MIT
+"""
+
+import traceback, logging, json
+from typing import Tuple, List
+
+import azlmbr.bus
+from scene_api import scene_data as sceneData
+from scene_api.scene_data import SceneGraphName
+
+
+def log_exception_traceback():
+    """
+    Outputs an exception stacktrace.
+    """
+    data = traceback.format_exc()
+    logger = logging.getLogger('python')
+    logger.error(data)
+
+
+def sanitize_name_for_disk(name: str):
+    """
+    Removes illegal filename characters from a string.
+
+    :param name: String to clean.
+    :return: Name with illegal characters removed.
+    """
+    return "".join(char for char in name if char not in "|<>:\"/?*\\")
+
+
+def get_mesh_node_names(scene_graph: sceneData.SceneGraph) -> Tuple[List[SceneGraphName], List[str]]:
+    """
+    Returns a tuple of all the mesh nodes as well as all the node paths
+
+    :param scene_graph: Scene graph to search
+    :return: Tuple of [Mesh Nodes, All Node Paths]
+    """
+    import azlmbr.scene as sceneApi
+    import azlmbr.scene.graph
+
+    mesh_data_list = []
+    node = scene_graph.get_root()
+    children = []
+    paths = []
+
+    while node.IsValid():
+        # store children to process after siblings
+        if scene_graph.has_node_child(node):
+            children.append(scene_graph.get_node_child(node))
+
+        node_name = sceneData.SceneGraphName(scene_graph.get_node_name(node))
+        paths.append(node_name.get_path())
+
+        # store any node that has mesh data content
+        node_content = scene_graph.get_node_content(node)
+        if node_content.CastWithTypeName('MeshData'):
+            if scene_graph.is_node_end_point(node) is False:
+                if len(node_name.get_path()):
+                    mesh_data_list.append(sceneData.SceneGraphName(scene_graph.get_node_name(node)))
+
+        # advance to next node
+        if scene_graph.has_node_sibling(node):
+            node = scene_graph.get_node_sibling(node)
+        elif children:
+            node = children.pop()
+        else:
+            node = azlmbr.scene.graph.NodeIndex()
+
+    return mesh_data_list, paths
+
+
+def create_prefab(scene_manifest: sceneData.SceneManifest, prefab_name: str, entities: list) -> None:
+    prefab_filename = prefab_name + ".prefab"
+    created_template_id = azlmbr.prefab.PrefabSystemScriptingBus(azlmbr.bus.Broadcast, "CreatePrefab", entities,
+                                                                 prefab_filename)
+
+    if created_template_id is None or created_template_id == azlmbr.prefab.InvalidTemplateId:
+        raise RuntimeError("CreatePrefab {} failed".format(prefab_filename))
+
+    # Convert the prefab to a JSON string
+    output = azlmbr.prefab.PrefabLoaderScriptingBus(azlmbr.bus.Broadcast, "SaveTemplateToString", created_template_id)
+
+    if output is not None and output.IsSuccess():
+        json_string = output.GetValue()
+        uuid = azlmbr.math.Uuid_CreateRandom().ToString()
+        json_result = json.loads(json_string)
+        # Add a PrefabGroup to the manifest and store the JSON on it
+        scene_manifest.add_prefab_group(prefab_name, uuid, json_result)
+    else:
+        raise RuntimeError(
+            "SaveTemplateToString failed for template id {}, prefab {}".format(created_template_id, prefab_filename))

AutomatedTesting/Editor/Scripts/scene_mesh_to_prefab.py

@@ -5,55 +5,16 @@
 # SPDX-License-Identifier: Apache-2.0 OR MIT
 #
 #
-import os, traceback, binascii, sys, json, pathlib
-import azlmbr.math
 import azlmbr.bus
+import azlmbr.math
+
+from scene_helpers import *
+
 
 #
 # SceneAPI Processor
 #
 
-
-def log_exception_traceback():
-    exc_type, exc_value, exc_tb = sys.exc_info()
-    data = traceback.format_exception(exc_type, exc_value, exc_tb)
-    print(str(data))
-
-def get_mesh_node_names(sceneGraph):
-    import azlmbr.scene as sceneApi
-    import azlmbr.scene.graph
-    from scene_api import scene_data as sceneData
-
-    meshDataList = []
-    node = sceneGraph.get_root()
-    children = []
-    paths = []
-
-    while node.IsValid():
-        # store children to process after siblings
-        if sceneGraph.has_node_child(node):
-            children.append(sceneGraph.get_node_child(node))
-
-        nodeName = sceneData.SceneGraphName(sceneGraph.get_node_name(node))
-        paths.append(nodeName.get_path())
-
-        # store any node that has mesh data content
-        nodeContent = sceneGraph.get_node_content(node)
-        if nodeContent.CastWithTypeName('MeshData'):
-            if sceneGraph.is_node_end_point(node) is False:
-                if (len(nodeName.get_path())):
-                    meshDataList.append(sceneData.SceneGraphName(sceneGraph.get_node_name(node)))
-
-        # advance to next node
-        if sceneGraph.has_node_sibling(node):
-            node = sceneGraph.get_node_sibling(node)
-        elif children:
-            node = children.pop()
-        else:
-            node = azlmbr.scene.graph.NodeIndex()
-
-    return meshDataList, paths
-
 def add_material_component(entity_id):
     # Create an override AZ::Render::EditorMaterialComponent
     editor_material_component = azlmbr.entity.EntityUtilityBus(
@@ -64,24 +25,24 @@ def add_material_component(entity_id):
 
     # this fills out the material asset to a known product AZMaterial asset relative path
     json_update = json.dumps({
-            "Controller": { "Configuration": { "materials": [
-                {
-                    "Key": {},
-                    "Value": { "MaterialAsset":{
-                        "assetHint": "materials/basic_grey.azmaterial"
-                    }}
-                }]
-            }}
-        });
-    result = azlmbr.entity.EntityUtilityBus(azlmbr.bus.Broadcast, "UpdateComponentForEntity", entity_id, editor_material_component, json_update)
+        "Controller": {"Configuration": {"materials": [
+            {
+                "Key": {},
+                "Value": {"MaterialAsset": {
+                    "assetHint": "materials/basic_grey.azmaterial"
+                }}
+            }]
+        }}
+    })
+    result = azlmbr.entity.EntityUtilityBus(azlmbr.bus.Broadcast, "UpdateComponentForEntity", entity_id,
+                                            editor_material_component, json_update)
 
     if not result:
         raise RuntimeError("UpdateComponentForEntity for editor_material_component failed")
 
+
 def update_manifest(scene):
-    import json
     import uuid, os
-    import azlmbr.scene as sceneApi
     import azlmbr.scene.graph
     from scene_api import scene_data as sceneData
 
@@ -89,9 +50,9 @@ def update_manifest(scene):
     # Get a list of all the mesh nodes, as well as all the nodes
     mesh_name_list, all_node_paths = get_mesh_node_names(graph)
     scene_manifest = sceneData.SceneManifest()
-    
+
     clean_filename = scene.sourceFilename.replace('.', '_')
-    
+
     # Compute the filename of the scene file
     source_basepath = scene.watchFolder
     source_relative_path = os.path.dirname(os.path.relpath(clean_filename, source_basepath))
@@ -108,31 +69,39 @@ def update_manifest(scene):
         # Create a unique mesh group name using the filename + node name
         mesh_group_name = '{}_{}'.format(source_filename_only, mesh_name.get_name())
         # Remove forbidden filename characters from the name since this will become a file on disk later
-        mesh_group_name = "".join(char for char in mesh_group_name if char not in "|<>:\"/?*\\")
+        mesh_group_name = sanitize_name_for_disk(mesh_group_name)
         # Add the MeshGroup to the manifest and give it a unique ID
         mesh_group = scene_manifest.add_mesh_group(mesh_group_name)
         mesh_group['id'] = '{' + str(uuid.uuid5(uuid.NAMESPACE_DNS, source_filename_only + mesh_path)) + '}'
         # Set our current node as the only node that is included in this MeshGroup
         scene_manifest.mesh_group_select_node(mesh_group, mesh_path)
+        scene_manifest.mesh_group_add_comment(mesh_group, "Hello World")
 
         # Explicitly remove all other nodes to prevent implicit inclusions
         for node in all_node_paths:
             if node != mesh_path:
                 scene_manifest.mesh_group_unselect_node(mesh_group, node)
 
+        scene_manifest.mesh_group_add_cloth_rule(mesh_group, mesh_path, "Col0", 1, "Col0", 2, "Col0", 2, 3)
+        scene_manifest.mesh_group_add_advanced_mesh_rule(mesh_group, True, False, True, "Col0")
+        scene_manifest.mesh_group_add_skin_rule(mesh_group, 3, 0.002)
+        scene_manifest.mesh_group_add_tangent_rule(mesh_group, 1, 0)
+
         # Create an editor entity
         entity_id = azlmbr.entity.EntityUtilityBus(azlmbr.bus.Broadcast, "CreateEditorReadyEntity", mesh_group_name)
         # Add an EditorMeshComponent to the entity
-        editor_mesh_component = azlmbr.entity.EntityUtilityBus(azlmbr.bus.Broadcast, "GetOrAddComponentByTypeName", entity_id, "AZ::Render::EditorMeshComponent")
-        # Set the ModelAsset assetHint to the relative path of the input asset + the name of the MeshGroup we just created + the azmodel extension
-        # The MeshGroup we created will be output as a product in the asset's path named mesh_group_name.azmodel
-        # The assetHint will be converted to an AssetId later during prefab loading
+        editor_mesh_component = azlmbr.entity.EntityUtilityBus(azlmbr.bus.Broadcast, "GetOrAddComponentByTypeName",
+                                                               entity_id, "AZ::Render::EditorMeshComponent")
+        # Set the ModelAsset assetHint to the relative path of the input asset + the name of the MeshGroup we just
+        # created + the azmodel extension The MeshGroup we created will be output as a product in the asset's path
+        # named mesh_group_name.azmodel The assetHint will be converted to an AssetId later during prefab loading
         json_update = json.dumps({
-            "Controller": { "Configuration": { "ModelAsset": {
-                "assetHint": os.path.join(source_relative_path, mesh_group_name) + ".azmodel" }}}
-            });
+            "Controller": {"Configuration": {"ModelAsset": {
+                "assetHint": os.path.join(source_relative_path, mesh_group_name) + ".azmodel"}}}
+        })
         # Apply the JSON above to the component we created
-        result = azlmbr.entity.EntityUtilityBus(azlmbr.bus.Broadcast, "UpdateComponentForEntity", entity_id, editor_mesh_component, json_update)
+        result = azlmbr.entity.EntityUtilityBus(azlmbr.bus.Broadcast, "UpdateComponentForEntity", entity_id,
+                                                editor_mesh_component, json_update)
 
         if not result:
             raise RuntimeError("UpdateComponentForEntity failed for Mesh component")
@@ -143,17 +112,19 @@ def update_manifest(scene):
             add_material_component(entity_id)
 
         # Get the transform component
-        transform_component = azlmbr.entity.EntityUtilityBus(azlmbr.bus.Broadcast, "GetOrAddComponentByTypeName", entity_id, "27F1E1A1-8D9D-4C3B-BD3A-AFB9762449C0")
+        transform_component = azlmbr.entity.EntityUtilityBus(azlmbr.bus.Broadcast, "GetOrAddComponentByTypeName",
+                                                             entity_id, "27F1E1A1-8D9D-4C3B-BD3A-AFB9762449C0")
 
         # Set this entity to be a child of the last entity we created
         # This is just an example of how to do parenting and isn't necessarily useful to parent everything like this
         if previous_entity_id is not None:
             transform_json = json.dumps({
-                "Parent Entity" : previous_entity_id.to_json()
-                });
+                "Parent Entity": previous_entity_id.to_json()
+            })
 
             # Apply the JSON update
-            result = azlmbr.entity.EntityUtilityBus(azlmbr.bus.Broadcast, "UpdateComponentForEntity", entity_id, transform_component, transform_json)
+            result = azlmbr.entity.EntityUtilityBus(azlmbr.bus.Broadcast, "UpdateComponentForEntity", entity_id,
+                                                    transform_component, transform_json)
 
             if not result:
                 raise RuntimeError("UpdateComponentForEntity failed for Transform component")
@@ -165,37 +136,23 @@ def update_manifest(scene):
         created_entities.append(entity_id)
 
     # Create a prefab with all our entities
-    prefab_filename = source_filename_only + ".prefab"
-    created_template_id = azlmbr.prefab.PrefabSystemScriptingBus(azlmbr.bus.Broadcast, "CreatePrefab", created_entities, prefab_filename)
-
-    if created_template_id == azlmbr.prefab.InvalidTemplateId:
-        raise RuntimeError("CreatePrefab {} failed".format(prefab_filename))
-
-    # Convert the prefab to a JSON string
-    output = azlmbr.prefab.PrefabLoaderScriptingBus(azlmbr.bus.Broadcast, "SaveTemplateToString", created_template_id)
-
-    if output.IsSuccess():
-        jsonString = output.GetValue()
-        uuid = azlmbr.math.Uuid_CreateRandom().ToString()
-        jsonResult = json.loads(jsonString)
-        # Add a PrefabGroup to the manifest and store the JSON on it
-        scene_manifest.add_prefab_group(source_filename_only, uuid, jsonResult)
-    else:
-        raise RuntimeError("SaveTemplateToString failed for template id {}, prefab {}".format(created_template_id, prefab_filename))
+    create_prefab(scene_manifest, source_filename_only, created_entities)
 
     # Convert the manifest to a JSON string and return it
     new_manifest = scene_manifest.export()
 
     return new_manifest
 
+
 sceneJobHandler = None
 
+
 def on_update_manifest(args):
     try:
         scene = args[0]
         return update_manifest(scene)
     except RuntimeError as err:
-        print (f'ERROR - {err}')
+        print(f'ERROR - {err}')
         log_exception_traceback()
     except:
         log_exception_traceback()
@@ -203,10 +160,12 @@ def on_update_manifest(args):
     global sceneJobHandler
     sceneJobHandler = None
 
+
 # try to create SceneAPI handler for processing
 try:
     import azlmbr.scene as sceneApi
-    if (sceneJobHandler == None):
+
+    if sceneJobHandler is None:
         sceneJobHandler = sceneApi.ScriptBuildingNotificationBusHandler()
         sceneJobHandler.connect()
         sceneJobHandler.add_callback('OnUpdateManifest', on_update_manifest)

AutomatedTesting/Gem/PythonTests/Atom/atom_utils/atom_constants.py

@@ -149,11 +149,14 @@ class AtomComponentProperties:
     def display_mapper(property: str = 'name') -> str:
         """
         Display Mapper component properties.
+          - 'LDR color Grading LUT' is the Low Definition Range (LDR) color grading for Look-up Textures (LUT) which is
+            an Asset.id value corresponding to a lighting asset file.
         :param property: From the last element of the property tree path. Default 'name' for component name string.
         :return: Full property path OR component name if no property specified.
         """
         properties = {
             'name': 'Display Mapper',
+            'LDR color Grading LUT': 'Controller|Configuration|LDR color Grading LUT',
         }
         return properties[property]
 
@@ -390,7 +393,7 @@ class AtomComponentProperties:
             'name': 'PostFX Shape Weight Modifier',
             'requires': [AtomComponentProperties.postfx_layer()],
             'shapes': ['Axis Aligned Box Shape', 'Box Shape', 'Capsule Shape', 'Compound Shape', 'Cylinder Shape',
-                       'Disk Shape', 'Polygon Prism Shape', 'Quad Shape', 'Sphere Shape', 'Vegetation Reference Shape'],
+                       'Disk Shape', 'Polygon Prism Shape', 'Quad Shape', 'Sphere Shape', 'Shape Reference'],
         }
         return properties[property]
 

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

@@ -5,6 +5,7 @@ For complete copyright and license terms please see the LICENSE at the root of t
 SPDX-License-Identifier: Apache-2.0 OR MIT
 """
 
+
 class Tests:
     camera_creation = (
         "Camera Entity successfully created",
@@ -39,6 +40,9 @@ class Tests:
     is_hidden = (
         "Entity is hidden",
         "Entity was not hidden")
+    ldr_color_grading_lut = (
+        "LDR color Grading LUT asset set",
+        "LDR color Grading LUT asset could not be set")
     entity_deleted = (
         "Entity deleted",
         "Entity was not deleted")
@@ -71,16 +75,19 @@ def AtomEditorComponents_DisplayMapper_AddedToEntity():
     5) Enter/Exit game mode.
     6) Test IsHidden.
     7) Test IsVisible.
-    8) Delete Display Mapper entity.
-    9) UNDO deletion.
-    10) REDO deletion.
-    11) Look for errors and asserts.
+    8) Set LDR color Grading LUT asset.
+    9) Delete Display Mapper entity.
+    10) UNDO deletion.
+    11) REDO deletion.
+    12) Look for errors and asserts.
 
     :return: None
     """
+    import os
 
     import azlmbr.legacy.general as general
 
+    from editor_python_test_tools.asset_utils import Asset
     from editor_python_test_tools.editor_entity_utils import EditorEntity
     from editor_python_test_tools.utils import Report, Tracer, TestHelper
     from Atom.atom_utils.atom_constants import AtomComponentProperties
@@ -97,7 +104,7 @@ def AtomEditorComponents_DisplayMapper_AddedToEntity():
         Report.critical_result(Tests.display_mapper_creation, display_mapper_entity.exists())
 
         # 2. Add Display Mapper component to Display Mapper entity.
-        display_mapper_entity.add_component(AtomComponentProperties.display_mapper())
+        display_mapper_component = display_mapper_entity.add_component(AtomComponentProperties.display_mapper())
         Report.critical_result(
             Tests.display_mapper_component,
             display_mapper_entity.has_component(AtomComponentProperties.display_mapper()))
@@ -140,19 +147,29 @@ def AtomEditorComponents_DisplayMapper_AddedToEntity():
         general.idle_wait_frames(1)
         Report.result(Tests.is_visible, display_mapper_entity.is_visible() is True)
 
-        # 8. Delete Display Mapper entity.
+        # 8. Set LDR color Grading LUT asset.
+        display_mapper_asset_path = os.path.join("TestData", "test.lightingpreset.azasset")
+        display_mapper_asset = Asset.find_asset_by_path(display_mapper_asset_path, False)
+        display_mapper_component.set_component_property_value(
+            AtomComponentProperties.display_mapper("LDR color Grading LUT"), display_mapper_asset.id)
+        Report.result(
+            Tests.ldr_color_grading_lut,
+            display_mapper_component.get_component_property_value(
+                AtomComponentProperties.display_mapper("LDR color Grading LUT")) == display_mapper_asset.id)
+
+        # 9. Delete Display Mapper entity.
         display_mapper_entity.delete()
         Report.result(Tests.entity_deleted, not display_mapper_entity.exists())
 
-        # 9. UNDO deletion.
+        # 10. UNDO deletion.
         general.undo()
         Report.result(Tests.deletion_undo, display_mapper_entity.exists())
 
-        # 10. REDO deletion.
+        # 11. REDO deletion.
         general.redo()
         Report.result(Tests.deletion_redo, not display_mapper_entity.exists())
 
-        # 11. Look for errors and asserts.
+        # 12. Look for errors and asserts.
         TestHelper.wait_for_condition(lambda: error_tracer.has_errors or error_tracer.has_asserts, 1.0)
         for error_info in error_tracer.errors:
             Report.info(f"Error: {error_info.filename} {error_info.function} | {error_info.message}")

AutomatedTesting/Gem/PythonTests/EditorPythonTestTools/README.txt

@@ -26,8 +26,8 @@ INSTALL
 It is recommended to set up these these tools with O3DE's CMake build commands.
 Assuming CMake is already setup on your operating system, below are some sample build commands:
     cd /path/to/od3e/
-    mkdir windows_vs2019
-    cd windows_vs2019
+    mkdir windows
+    cd windows
     cmake .. -G "Visual Studio 16 2019" -DLY_PROJECTS=AutomatedTesting
 
 To manually install the project in development mode using your own installed Python interpreter:

AutomatedTesting/Gem/PythonTests/EditorPythonTestTools/editor_python_test_tools/editor_entity_utils.py

@@ -459,3 +459,14 @@ class EditorEntity:
         """
         new_translation = convert_to_azvector3(new_translation)
         azlmbr.components.TransformBus(azlmbr.bus.Event, "SetLocalTranslation", self.id, new_translation)
+
+    # Use this only when prefab system is enabled as it will fail otherwise.
+    def focus_on_owning_prefab(self) -> None:
+        """
+        Focuses on the owning prefab instance of the given entity.
+        :param entity: The entity used to fetch the owning prefab to focus on.
+        """
+
+        assert self.id.isValid(), "A valid entity id is required to focus on its owning prefab."
+        focus_prefab_result = azlmbr.prefab.PrefabFocusPublicRequestBus(bus.Broadcast, "FocusOnOwningPrefab", self.id)
+        assert focus_prefab_result.IsSuccess(), f"Prefab operation 'FocusOnOwningPrefab' failed. Error: {focus_prefab_result.GetError()}"

AutomatedTesting/Gem/PythonTests/EditorPythonTestTools/editor_python_test_tools/utils.py

@@ -34,6 +34,38 @@ class TestHelper:
         # JIRA: SPEC-2880
         # general.idle_wait_frames(1)
 
+    @staticmethod
+    def create_level(level_name: str) -> bool:
+        """
+        :param level_name: The name of the level to be created
+        :return: True if ECreateLevelResult returns 0, False otherwise with logging to report reason
+        """
+        Report.info(f"Creating level {level_name}")
+
+        # Use these hardcoded values to pass expected values for old terrain system until new create_level API is
+        # available
+        heightmap_resolution = 1024
+        heightmap_meters_per_pixel = 1
+        terrain_texture_resolution = 4096
+        use_terrain = False
+
+        result = general.create_level_no_prompt(level_name, heightmap_resolution, heightmap_meters_per_pixel,
+                                                terrain_texture_resolution, use_terrain)
+
+        # Result codes are ECreateLevelResult defined in CryEdit.h
+        if result == 1:
+            Report.info(f"{level_name} level already exists")
+        elif result == 2:
+            Report.info("Failed to create directory")
+        elif result == 3:
+            Report.info("Directory length is too long")
+        elif result != 0:
+            Report.info("Unknown error, failed to create level")
+        else:
+            Report.info(f"{level_name} level created successfully")
+
+        return result == 0
+
     @staticmethod
     def open_level(directory : str, level : str):
         # type: (str, str) -> None

AutomatedTesting/Gem/PythonTests/Prefab/TestSuite_Main.py

@@ -61,3 +61,11 @@ class TestAutomation(TestAutomationBase):
     def test_CreatePrefab_UnderAnotherPrefab(self, request, workspace, editor, launcher_platform):
         from Prefab.tests.create_prefab import CreatePrefab_UnderAnotherPrefab as test_module
         self._run_prefab_test(request, workspace, editor, test_module, autotest_mode=False)
+
+    def test_DeleteEntity_UnderAnotherPrefab(self, request, workspace, editor, launcher_platform):
+        from Prefab.tests.delete_entity import DeleteEntity_UnderAnotherPrefab as test_module
+        self._run_prefab_test(request, workspace, editor, test_module, autotest_mode=False)
+
+    def test_DeleteEntity_UnderLevelPrefab(self, request, workspace, editor, launcher_platform):
+        from Prefab.tests.delete_entity import DeleteEntity_UnderLevelPrefab as test_module
+        self._run_prefab_test(request, workspace, editor, test_module, autotest_mode=False)

AutomatedTesting/Gem/PythonTests/Prefab/tests/delete_entity/DeleteEntity_UnderAnotherPrefab.py

@@ -0,0 +1,52 @@
+"""
+Copyright (c) Contributors to the Open 3D Engine Project.
+For complete copyright and license terms please see the LICENSE at the root of this distribution.
+
+SPDX-License-Identifier: Apache-2.0 OR MIT
+"""
+
+def DeleteEntity_UnderAnotherPrefab():
+    """
+    Test description:
+    - Creates an entity.
+    - Creates a prefab out of the above entity.
+    - Focuses on the created prefab and destroys the entity within.
+    Checks that the entity is correctly destroyed.
+    """
+
+    from editor_python_test_tools.editor_entity_utils import EditorEntity
+    from editor_python_test_tools.prefab_utils import Prefab
+
+    import Prefab.tests.PrefabTestUtils as prefab_test_utils
+
+    prefab_test_utils.open_base_tests_level()
+
+    PREFAB_FILE_NAME = 'some_prefab'
+
+    # Creates a new entity at the root level
+    entity = EditorEntity.create_editor_entity()
+    assert entity.id.IsValid(), "Couldn't create entity."
+
+    # Asserts if prefab creation doesn't succeed
+    child_prefab, child_instance = Prefab.create_prefab([entity], PREFAB_FILE_NAME)
+    child_entity_ids_inside_prefab = child_instance.get_direct_child_entities()
+    assert len(
+        child_entity_ids_inside_prefab) == 1, f"{len(child_entity_ids_inside_prefab)} entities found inside prefab" \
+                                              f" when there should have been just 1 entity"
+
+    child_entity_inside_prefab = child_entity_ids_inside_prefab[0]
+    child_entity_inside_prefab.focus_on_owning_prefab()
+
+    child_entity_inside_prefab.delete()
+
+    # Wait till prefab propagation finishes before validating entity deletion.
+    azlmbr.legacy.general.idle_wait_frames(1)
+
+    child_entity_ids_inside_prefab = child_instance.get_direct_child_entities()
+    assert len(
+        child_entity_ids_inside_prefab) == 0, f"{len(child_entity_ids_inside_prefab)} entities found inside prefab" \
+                                              f" when there should have been 0 entities"
+
+if __name__ == "__main__":
+    from editor_python_test_tools.utils import Report
+    Report.start_test(DeleteEntity_UnderAnotherPrefab)

AutomatedTesting/Gem/PythonTests/Prefab/tests/delete_entity/DeleteEntity_UnderLevelPrefab.py

@@ -0,0 +1,37 @@
+"""
+Copyright (c) Contributors to the Open 3D Engine Project.
+For complete copyright and license terms please see the LICENSE at the root of this distribution.
+
+SPDX-License-Identifier: Apache-2.0 OR MIT
+"""
+
+def DeleteEntity_UnderLevelPrefab():
+    """
+    Test description:
+    - Creates an entity.
+    - Destroys the created entity.
+    Checks that the entity is correctly destroyed.
+    """
+
+    from editor_python_test_tools.editor_entity_utils import EditorEntity
+    import Prefab.tests.PrefabTestUtils as prefab_test_utils
+
+    prefab_test_utils.open_base_tests_level()
+
+    # Creates a new Entity at the root level
+    # Asserts if creation didn't succeed
+    entity = EditorEntity.create_editor_entity_at((100.0, 100.0, 100.0), name = "TestEntity")
+    assert entity.id.IsValid(), "Couldn't create entity"
+
+    level_container_entity = EditorEntity(entity.get_parent_id())
+    entity.delete()
+
+    # Wait till prefab propagation finishes before validating entity deletion.
+    azlmbr.legacy.general.idle_wait_frames(1)
+    level_container_child_entities_count = len(level_container_entity.get_children_ids())
+    assert level_container_child_entities_count == 0, f"The level still has {level_container_child_entities_count}" \
+                                                      f" children when it should have 0."
+
+if __name__ == "__main__":
+    from editor_python_test_tools.utils import Report
+    Report.start_test(DeleteEntity_UnderLevelPrefab)

AutomatedTesting/Gem/PythonTests/Terrain/EditorScripts/Terrain_SupportsPhysics.py

@@ -72,7 +72,7 @@ def Terrain_SupportsPhysics():
 
     # 2) Create 2 test entities, one parent at 512.0, 512.0, 50.0 and one child at the default position and add the required components
     entity1_components_to_add = ["Axis Aligned Box Shape", "Terrain Layer Spawner", "Terrain Height Gradient List", "Terrain Physics Heightfield Collider", "PhysX Heightfield Collider"]
-    entity2_components_to_add = ["Vegetation Reference Shape", "Gradient Transform Modifier", "FastNoise Gradient"]
+    entity2_components_to_add = ["Shape Reference", "Gradient Transform Modifier", "FastNoise Gradient"]
     ball_components_to_add = ["Sphere Shape", "PhysX Collider", "PhysX Rigid Body"]
     terrain_spawner_entity = hydra.Entity("TestEntity1")
     terrain_spawner_entity.create_entity(azmath.Vector3(512.0, 512.0, 50.0), entity1_components_to_add)

AutomatedTesting/Gem/PythonTests/assetpipeline/ap_fixtures/ap_setup_fixture.py

@@ -4,7 +4,7 @@ For complete copyright and license terms please see the LICENSE at the root of t
 
 SPDX-License-Identifier: Apache-2.0 OR MIT
 
-A fixture for Setting Up Asset Processor Batch workspace for tests in lmbr_test
+A fixture for Setting Up Asset Processor Batch workspace for tests
 """
 
 # Import builtin libraries

AutomatedTesting/Gem/PythonTests/assetpipeline/ap_fixtures/asset_processor_fixture.py

@@ -4,7 +4,7 @@ For complete copyright and license terms please see the LICENSE at the root of t
 
 SPDX-License-Identifier: Apache-2.0 OR MIT
 
-A fixture for using the Asset Processor in lmbr_test, this will stop the asset processor after every test via
+A fixture for using the Asset Processor, this will stop the asset processor after every test via
 the teardown. Using the fixture at class level will stop the asset processor after the suite completes.
 Using the fixture at test level will stop asset processor after the test completes. Calling this fixture as a test argument will still run the teardown to stop the Asset Processor.
 """
@@ -15,6 +15,7 @@ import logging
 
 # Import LyTestTools
 import ly_test_tools.o3de.asset_processor as asset_processor_commands
+import ly_test_tools.o3de.asset_processor_utils
 
 logger = logging.getLogger(__name__)
 
@@ -36,5 +37,8 @@ def asset_processor(request: pytest.fixture, workspace: pytest.fixture) -> asset
         ap.stop()
 
     request.addfinalizer(teardown)
+    for n in ly_test_tools.o3de.asset_processor_utils.processList:
+        assert not ly_test_tools.o3de.asset_processor_utils.check_ap_running(n), f"{n} process did not shutdown correctly."
+
 
     return ap

AutomatedTesting/Gem/PythonTests/assetpipeline/asset_processor_tests/CMakeLists.txt

@@ -103,6 +103,19 @@ if(PAL_TRAIT_BUILD_TESTS_SUPPORTED AND PAL_TRAIT_BUILD_HOST_TOOLS)
             AZ::AssetBundlerBatch
     )
 
+    ly_add_pytest(
+        NAME AssetPipelineTests.BundleMode
+        PATH ${CMAKE_CURRENT_LIST_DIR}/bundle_mode_tests.py
+        EXCLUDE_TEST_RUN_TARGET_FROM_IDE
+        TEST_SERIAL
+        TEST_SUITE periodic
+        RUNTIME_DEPENDENCIES
+            AZ::AssetProcessor
+            AZ::AssetBundlerBatch
+            Legacy::Editor
+            AutomatedTesting.Assets
+    )
+
     ly_add_pytest(
         NAME AssetPipelineTests.AssetBuilder
         PATH ${CMAKE_CURRENT_LIST_DIR}/asset_builder_tests.py

AutomatedTesting/Gem/PythonTests/assetpipeline/asset_processor_tests/bundle_mode_in_editor_tests.py

@@ -0,0 +1,20 @@
+"""
+Copyright (c) Contributors to the Open 3D Engine Project.
+For complete copyright and license terms please see the LICENSE at the root of this distribution.
+
+SPDX-License-Identifier: Apache-2.0 OR MIT
+"""
+import azlmbr.bus
+import azlmbr.editor
+import azlmbr.legacy.general
+import sys
+
+# Print out the passed in bundle_path, so the outer test can verify this was sent in correctly
+bundle_path = sys.argv[1]
+print('Bundle mode test running with path {}'.format(sys.argv[1]))
+
+# Turn on bundle mode. This will trigger some printouts that the outer test logic will validate.
+azlmbr.legacy.general.set_cvar_integer("sys_report_files_not_found_in_paks", 1)
+azlmbr.legacy.general.run_console(f"loadbundles {bundle_path}")
+
+azlmbr.editor.EditorToolsApplicationRequestBus(azlmbr.bus.Broadcast, 'ExitNoPrompt')

AutomatedTesting/Gem/PythonTests/assetpipeline/asset_processor_tests/bundle_mode_tests.py

@@ -0,0 +1,93 @@
+"""
+Copyright (c) Contributors to the Open 3D Engine Project.
+For complete copyright and license terms please see the LICENSE at the root of this distribution.
+
+SPDX-License-Identifier: Apache-2.0 OR MIT
+"""
+
+import os
+import pytest
+import logging
+import sys
+import time
+pytest.importorskip('ly_test_tools')
+
+import ly_test_tools.environment.file_system as fs
+import ly_test_tools.environment.waiter as waiter
+import ly_test_tools.log.log_monitor
+
+from ..ap_fixtures.asset_processor_fixture import asset_processor as asset_processor
+from ..ap_fixtures.bundler_batch_setup_fixture import bundler_batch_setup_fixture as bundler_batch_helper
+from ..ap_fixtures.timeout_option_fixture import timeout_option_fixture as timeout
+
+@pytest.mark.SUITE_periodic
+@pytest.mark.parametrize('launcher_platform', ['windows_editor'])
+@pytest.mark.parametrize('project', ['AutomatedTesting'])
+@pytest.mark.parametrize('level', ['auto_test'])
+class TestBundleMode(object):
+    def test_bundle_mode_with_levels_mounts_bundles_correctly(self, request, editor, level, launcher_platform,
+                                                              asset_processor, workspace, bundler_batch_helper):
+        level_pak = os.path.join("levels", level, "level.pak")
+
+        bundles_folder = os.path.join(workspace.paths.project(), "Bundles")
+        bundle_request_path = os.path.join(bundles_folder, "bundle.pak")
+        bundle_result_path = os.path.join(bundles_folder,
+                                          bundler_batch_helper.platform_file_name(
+                                              "bundle.pak", workspace.asset_processor_platform))
+
+        # Create target 'Bundles' folder if it doesn't exist
+        if not os.path.exists(bundles_folder):
+            os.mkdir(bundles_folder)
+        # Delete target bundle file if it already exists
+        if os.path.exists(bundle_result_path):
+            fs.delete([bundle_result_path], True, False)
+
+        # Make asset list file to use in the bundle
+        bundler_batch_helper.call_assetLists(
+            addSeed=level_pak,
+            assetListFile=bundler_batch_helper["asset_info_file_request"],
+        )
+
+        # Make bundle in <project_folder>/Bundles
+        bundler_batch_helper.call_bundles(
+            assetListFile=bundler_batch_helper["asset_info_file_result"],
+            outputBundlePath=bundle_request_path,
+            maxSize="2048",
+        )
+
+        # Ensure the bundle was created
+        assert os.path.exists(bundle_result_path), f"Bundle was not created at location: {bundle_result_path}"
+
+        # The editor flips the slash direction in some of the printouts
+        bundle_result_path_editor_separator = bundle_result_path.replace('\\', '/')
+
+        expected_lines = [
+            # A beginning of test printout can help debug where failures occur, if this line is missing
+            # then the Editor didn't launch, didn't run the Python test, or didn't pass in the right parameter
+            f'Bundle mode test running with path {bundles_folder}',
+            # These printouts happen in response to the loadbundles call, and verify this bundle is actually loaded
+            f"[CONSOLE] Executing console command 'loadbundles {bundles_folder}'",
+            f'(BundlingSystem) - Loading bundles from {bundles_folder} of type .pak',
+            f'(Archive) - Opening archive file {bundle_result_path_editor_separator}',
+        ]
+        unexpected_lines = []
+
+        timeout = 180
+        halt_on_unexpected = False
+        test_directory = os.path.join(os.path.dirname(__file__))
+        test_file = os.path.join(test_directory, 'bundle_mode_in_editor_tests.py')
+        editor.args.extend(['-NullRenderer', '-rhi=Null', "--skipWelcomeScreenDialog",
+                            "--autotest_mode", "--runpythontest", test_file, "--runpythonargs", bundles_folder])
+
+        with editor.start(launch_ap=True):
+            editor_log_file = os.path.join(editor.workspace.paths.project_log(), 'Editor.log')
+            log_monitor = ly_test_tools.log.log_monitor.LogMonitor(editor, editor_log_file)
+            waiter.wait_for(
+                lambda: editor.is_alive(),
+                timeout,
+                exc=("Log file '{}' was never opened by another process.".format(editor_log_file)),
+                interval=1)
+            log_monitor.monitor_log_for_lines(expected_lines, unexpected_lines, halt_on_unexpected, timeout)
+
+        # Delete the bundle created and used in this test
+        fs.delete([bundle_result_path], True, False)

AutomatedTesting/Gem/PythonTests/editor/CMakeLists.txt

@@ -7,60 +7,6 @@
 #
 
 if(PAL_TRAIT_BUILD_TESTS_SUPPORTED AND PAL_TRAIT_BUILD_HOST_TOOLS AND PAL_TRAIT_FOUNDATION_TEST_SUPPORTED)
-    ly_add_pytest(
-        NAME AutomatedTesting::EditorTests_Main
-        TEST_SUITE main
-        TEST_SERIAL
-        PATH ${CMAKE_CURRENT_LIST_DIR}/TestSuite_Main.py
-        PYTEST_MARKS "not REQUIRES_gpu"
-        RUNTIME_DEPENDENCIES
-            Legacy::Editor
-            AZ::AssetProcessor
-            AutomatedTesting.Assets
-        COMPONENT
-            Editor
-    )
-
-    ly_add_pytest(
-        NAME AutomatedTesting::EditorTests_Main_GPU
-        TEST_SUITE main
-        TEST_SERIAL
-        TEST_REQUIRES gpu
-        PATH ${CMAKE_CURRENT_LIST_DIR}/TestSuite_Main.py
-        PYTEST_MARKS "REQUIRES_gpu"
-        RUNTIME_DEPENDENCIES
-            Legacy::Editor
-            AZ::AssetProcessor
-            AutomatedTesting.Assets
-        COMPONENT
-            Editor
-    )
-
-    ly_add_pytest(
-        NAME AutomatedTesting::EditorTests_Periodic
-        TEST_SUITE periodic
-        TEST_SERIAL
-        PATH ${CMAKE_CURRENT_LIST_DIR}/TestSuite_Periodic.py
-        RUNTIME_DEPENDENCIES
-            Legacy::Editor
-            AZ::AssetProcessor
-            AutomatedTesting.Assets
-        COMPONENT
-            Editor
-    )
-
-    ly_add_pytest(
-        NAME AutomatedTesting::EditorTests_Sandbox
-        TEST_SUITE sandbox
-        TEST_SERIAL
-        PATH ${CMAKE_CURRENT_LIST_DIR}/TestSuite_Sandbox.py
-        RUNTIME_DEPENDENCIES
-            Legacy::Editor
-            AZ::AssetProcessor
-            AutomatedTesting.Assets
-        COMPONENT
-            Editor
-    )
 
     ly_add_pytest(
         NAME AutomatedTesting::EditorTests_Main_Optimized

AutomatedTesting/Gem/PythonTests/editor/TestSuite_Main_Optimized.py

@@ -49,7 +49,6 @@ class TestAutomationNoAutoTestMode(EditorTestSuite):
         from .EditorScripts import AssetPicker_UI_UX as test_module
 
 
-@pytest.mark.xfail(reason="Optimized tests are experimental, we will enable xfail and monitor them temporarily.")
 @pytest.mark.SUITE_main
 @pytest.mark.parametrize("launcher_platform", ['windows_editor'])
 @pytest.mark.parametrize("project", ["AutomatedTesting"])

AutomatedTesting/Gem/PythonTests/largeworlds/CMakeLists.txt

@@ -11,24 +11,10 @@ if(PAL_TRAIT_BUILD_TESTS_SUPPORTED AND PAL_TRAIT_BUILD_HOST_TOOLS AND PAL_TRAIT_
 ## DynVeg ##
 
     ly_add_pytest(
-        NAME AutomatedTesting::DynamicVegetationTests_Main
+        NAME AutomatedTesting::DynamicVegetationTests_Main_Optimized
         TEST_SERIAL
         TEST_SUITE main
-        PATH ${CMAKE_CURRENT_LIST_DIR}/dyn_veg/TestSuite_Main.py
-        RUNTIME_DEPENDENCIES
-            AZ::AssetProcessor
-            Legacy::Editor
-            AutomatedTesting.GameLauncher
-            AutomatedTesting.Assets
-        COMPONENT
-            LargeWorlds
-    )
-
-    ly_add_pytest(
-        NAME AutomatedTesting::DynamicVegetationTests_Periodic
-        TEST_SERIAL
-        TEST_SUITE periodic
-        PATH ${CMAKE_CURRENT_LIST_DIR}/dyn_veg/TestSuite_Periodic.py
+        PATH ${CMAKE_CURRENT_LIST_DIR}/dyn_veg/TestSuite_Main_Optimized.py
         RUNTIME_DEPENDENCIES
             AZ::AssetProcessor
             Legacy::Editor
@@ -37,7 +23,6 @@ if(PAL_TRAIT_BUILD_TESTS_SUPPORTED AND PAL_TRAIT_BUILD_HOST_TOOLS AND PAL_TRAIT_
         COMPONENT
             LargeWorlds
     )
-
     ly_add_pytest(
         NAME AutomatedTesting::DynamicVegetationTests_Periodic_Optimized
         TEST_SERIAL
@@ -52,20 +37,6 @@ if(PAL_TRAIT_BUILD_TESTS_SUPPORTED AND PAL_TRAIT_BUILD_HOST_TOOLS AND PAL_TRAIT_
             LargeWorlds
     )
 
-    ly_add_pytest(
-        NAME AutomatedTesting::DynamicVegetationTests_Main_Optimized
-        TEST_SERIAL
-        TEST_SUITE main
-        PATH ${CMAKE_CURRENT_LIST_DIR}/dyn_veg/TestSuite_Main_Optimized.py
-        RUNTIME_DEPENDENCIES
-           AZ::AssetProcessor
-           Legacy::Editor
-           AutomatedTesting.Assets
-           AutomatedTesting.GameLauncher
-        COMPONENT
-            LargeWorlds
-    )
-
 ## LandscapeCanvas ##
 
     ly_add_pytest(

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

@@ -72,9 +72,9 @@ def DynamicSliceInstanceSpawner_Embedded_E2E():
     # 1) Create a new, temporary level
     lvl_name = "tmp_level"
     helper.init_idle()
-    level_created = general.create_level_no_prompt(lvl_name, 1024, 1, 4096, False)
+    level_created = helper.create_level(lvl_name)
     general.idle_wait(1.0)
-    Report.critical_result(Tests.level_created, level_created == 0)
+    Report.critical_result(Tests.level_created, level_created)
     general.set_current_view_position(512.0, 480.0, 38.0)
 
     # 2) Create a new entity with required vegetation area components and Script Canvas component for launcher test

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

@@ -73,9 +73,9 @@ def DynamicSliceInstanceSpawner_External_E2E():
     # 1) Create a new, temporary level
     lvl_name = "tmp_level"
     helper.init_idle()
-    level_created = general.create_level_no_prompt(lvl_name, 1024, 1, 4096, False)
+    level_created = helper.create_level(lvl_name)
     general.idle_wait(1.0)
-    Report.critical_result(Tests.level_created, level_created == 0)
+    Report.critical_result(Tests.level_created, level_created)
     general.set_current_view_position(512.0, 480.0, 38.0)
 
     # 2) Create a new entity with required vegetation area components and switch the Vegetation Asset List Source

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

@@ -76,9 +76,9 @@ def LayerBlender_E2E_Editor():
     # 1) Create a new, temporary level
     lvl_name = "tmp_level"
     helper.init_idle()
-    level_created = general.create_level_no_prompt(lvl_name, 1024, 1, 4096, False)
+    level_created = helper.create_level(lvl_name)
     general.idle_wait(1.0)
-    Report.critical_result(Tests.level_created, level_created == 0)
+    Report.critical_result(Tests.level_created, level_created)
 
     general.set_current_view_position(500.49, 498.69, 46.66)
     general.set_current_view_rotation(-42.05, 0.00, -36.33)

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

@@ -78,7 +78,7 @@ def LayerSpawner_InheritBehaviorFlag():
     # Create Vegetation area and assign a valid asset
     veg_1 = hydra.Entity("veg_1")
     veg_1.create_entity(
-        position, ["Vegetation Layer Spawner", "Vegetation Reference Shape", "Vegetation Asset List"]
+        position, ["Vegetation Layer Spawner", "Shape Reference", "Vegetation Asset List"]
     )
     set_dynamic_slice_asset(veg_1, 2, os.path.join("Slices", "PinkFlower.dynamicslice"))
     veg_1.get_set_test(1, "Configuration|Shape Entity Id", blender_entity.id)
@@ -86,7 +86,7 @@ def LayerSpawner_InheritBehaviorFlag():
     # Create second vegetation area and assign a valid asset
     veg_2 = hydra.Entity("veg_2")
     veg_2.create_entity(
-        position, ["Vegetation Layer Spawner", "Vegetation Reference Shape", "Vegetation Asset List"]
+        position, ["Vegetation Layer Spawner", "Shape Reference", "Vegetation Asset List"]
     )
     set_dynamic_slice_asset(veg_2, 2, os.path.join("Slices", "PurpleFlower.dynamicslice"))
     veg_2.get_set_test(1, "Configuration|Shape Entity Id", blender_entity.id)

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

@@ -9,7 +9,7 @@ SPDX-License-Identifier: Apache-2.0 OR MIT
 def LayerSpawner_InstancesPlantInAllSupportedShapes():
     """
     Summary:
-    The level is loaded and vegetation area is created. Then the Vegetation Reference Shape
+    The level is loaded and vegetation area is created. Then the Shape Reference
     component of vegetation area is pinned with entities of different shape components to check
     if the vegetation plants in different shaped areas.
 
@@ -67,7 +67,7 @@ def LayerSpawner_InstancesPlantInAllSupportedShapes():
                                                10.0, 10.0, 10.0,
                                                asset_path)
     vegetation.remove_component("Box Shape")
-    vegetation.add_component("Vegetation Reference Shape")
+    vegetation.add_component("Shape Reference")
 
     # Create surface for planting on
     dynveg.create_surface_entity("Surface Entity", entity_position, 60.0, 60.0, 1.0)

AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/TestSuite_Main_Optimized.py

@@ -12,13 +12,23 @@ import ly_test_tools.environment.file_system as file_system
 from ly_test_tools.o3de.editor_test import EditorSingleTest, EditorSharedTest, EditorParallelTest, EditorTestSuite
 
 
-@pytest.mark.xfail(reason="Optimized tests are experimental, we will enable xfail and monitor them temporarily.")
 @pytest.mark.SUITE_main
 @pytest.mark.parametrize("launcher_platform", ['windows_editor'])
 @pytest.mark.parametrize("project", ["AutomatedTesting"])
 class TestAutomation(EditorTestSuite):
 
     enable_prefab_system = False
+
+    # Helpers for test asset cleanup
+    def cleanup_test_level(self, workspace):
+        file_system.delete([os.path.join(workspace.paths.engine_root(), "AutomatedTesting", "Levels", "tmp_level")],
+                           True, True)
+
+    def cleanup_test_slices(self, workspace):
+        file_system.delete([os.path.join(workspace.paths.engine_root(), "AutomatedTesting", "slices",
+                                         "TestSlice_1.slice")], True, True)
+        file_system.delete([os.path.join(workspace.paths.engine_root(), "AutomatedTesting", "slices",
+                                         "TestSlice_2.slice")], True, True)
     
     class test_DynamicSliceInstanceSpawner_DynamicSliceSpawnerWorks(EditorParallelTest):
         from .EditorScripts import DynamicSliceInstanceSpawner_DynamicSliceSpawnerWorks as test_module
@@ -38,10 +48,7 @@ class TestAutomation(EditorTestSuite):
     class test_SpawnerSlices_SliceCreationAndVisibilityToggleWorks(EditorSingleTest):
         # Custom teardown to remove slice asset created during test
         def teardown(self, request, workspace, editor, editor_test_results, launcher_platform):
-            file_system.delete([os.path.join(workspace.paths.engine_root(), "AutomatedTesting", "slices",
-                                             "TestSlice_1.slice")], True, True)
-            file_system.delete([os.path.join(workspace.paths.engine_root(), "AutomatedTesting", "slices",
-                                             "TestSlice_2.slice")], True, True)
+            TestAutomation.cleanup_test_slices(self, workspace)
         from .EditorScripts import SpawnerSlices_SliceCreationAndVisibilityToggleWorks as test_module
 
     class test_AssetListCombiner_CombinedDescriptorsExpressInConfiguredArea(EditorParallelTest):
@@ -152,23 +159,29 @@ class TestAutomation(EditorTestSuite):
     class test_DynamicSliceInstanceSpawner_Embedded_E2E_Editor(EditorSingleTest):
         from .EditorScripts import DynamicSliceInstanceSpawner_Embedded_E2E as test_module
 
-        # Custom teardown to remove test level created during test
+        # Custom setup/teardown to remove test level created during test
+        def setup(self, request, workspace, editor, editor_test_results, launcher_platform):
+            TestAutomation.cleanup_test_level(self, workspace)
+
         def teardown(self, request, workspace, editor, editor_test_results, launcher_platform):
-            file_system.delete([os.path.join(workspace.paths.engine_root(), "AutomatedTesting", "Levels", "tmp_level")],
-                               True, True)
+            TestAutomation.cleanup_test_level(self, workspace)
 
     class test_DynamicSliceInstanceSpawner_External_E2E_Editor(EditorSingleTest):
         from .EditorScripts import DynamicSliceInstanceSpawner_External_E2E as test_module
 
-        # Custom teardown to remove test level created during test
+        # Custom setup/teardown to remove test level created during test
+        def setup(self, request, workspace, editor, editor_test_results, launcher_platform):
+            TestAutomation.cleanup_test_level(self, workspace)
+
         def teardown(self, request, workspace, editor, editor_test_results, launcher_platform):
-            file_system.delete([os.path.join(workspace.paths.engine_root(), "AutomatedTesting", "Levels", "tmp_level")],
-                               True, True)
-        
+            TestAutomation.cleanup_test_level(self, workspace)
+
     class test_LayerBlender_E2E_Editor(EditorSingleTest):
         from .EditorScripts import LayerBlender_E2E_Editor as test_module
 
-        # Custom teardown to remove test level created during test
+        # Custom setup/teardown to remove test level created during test
+        def setup(self, request, workspace, editor, editor_test_results, launcher_platform):
+            TestAutomation.cleanup_test_level(self, workspace)
+
         def teardown(self, request, workspace, editor, editor_test_results, launcher_platform):
-            file_system.delete([os.path.join(workspace.paths.engine_root(), "AutomatedTesting", "Levels", "tmp_level")],
-                               True, True)
+            TestAutomation.cleanup_test_level(self, workspace)

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

@@ -96,7 +96,7 @@ def AreaNodes_DependentComponentsAdded():
         'SpawnerAreaNode': [
             'Vegetation Layer Spawner',
             'Vegetation Asset List',
-            'Vegetation Reference Shape'
+            'Shape Reference'
         ],
         'MeshBlockerAreaNode': [
             'Vegetation Layer Blocker (Mesh)',
@@ -104,7 +104,7 @@ def AreaNodes_DependentComponentsAdded():
         ],
         'BlockerAreaNode': [
             'Vegetation Layer Blocker',
-            'Vegetation Reference Shape'
+            'Shape Reference'
         ]
     }
 

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

@@ -82,7 +82,7 @@ def Edit_DisabledNodeDuplication():
     nodes = {
         'SpawnerAreaNode': 'Vegetation Asset List',
         'MeshBlockerAreaNode': 'Mesh',
-        'BlockerAreaNode': 'Vegetation Reference Shape',
+        'BlockerAreaNode': 'Shape Reference',
         'FastNoiseGradientNode': 'Gradient Transform Modifier',
         'ImageGradientNode': 'Gradient Transform Modifier',
         'PerlinNoiseGradientNode': 'Gradient Transform Modifier',

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

@@ -104,7 +104,7 @@ def GradientNodes_DependentComponentsAdded():
     # we will be checking for
     commonComponents = [
         'Gradient Transform Modifier',
-        'Vegetation Reference Shape'
+        'Shape Reference'
     ]
     componentNames = []
     for name in gradients:
@@ -114,7 +114,7 @@ def GradientNodes_DependentComponentsAdded():
 
     # Create nodes for the gradients that have additional required dependencies and check if
     # the Entity created by adding the node has the appropriate Component and required
-    # Gradient Transform Modifier and Vegetation Reference Shape components added automatically to it
+    # Gradient Transform Modifier and Shape Reference components added automatically to it
     newGraph = graph.GraphManagerRequestBus(bus.Broadcast, 'GetGraph', newGraphId)
     x = 10.0
     y = 10.0

AutomatedTesting/Levels/macbeth_shaderballs/tags.txt

@@ -0,0 +1,12 @@
+0,0,0,0,0,0
+0,0,0,0,0,0
+0,0,0,0,0,0
+0,0,0,0,0,0
+0,0,0,0,0,0
+0,0,0,0,0,0
+0,0,0,0,0,0
+0,0,0,0,0,0
+0,0,0,0,0,0
+0,0,0,0,0,0
+0,0,0,0,0,0
+0,0,0,0,0,0

AutomatedTesting/Objects/sphere_5lods.fbx

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

AutomatedTesting/Objects/sphere_5lods.fbx.assetinfo

@@ -0,0 +1,8 @@
+{
+    "values": [
+        {
+            "$type": "ScriptProcessorRule",
+            "scriptFilename": "Editor/Scripts/auto_lod.py"
+        }
+    ]
+}