Merge branch 'main' into Atom/dmcdiar/ATOM-14706

AutomatedTesting/Gem/Editor/Scripts/__init__.py

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

AutomatedTesting/Gem/Editor/Scripts/bootstrap.py

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

AutomatedTesting/Gem/PythonTests/CMakeLists.txt

@@ -134,6 +134,25 @@ if(PAL_TRAIT_BUILD_TESTS_SUPPORTED AND PAL_TRAIT_BUILD_HOST_TOOLS)
     )
 endif()
 
+## Python Asset Builder ##
+if(PAL_TRAIT_BUILD_TESTS_SUPPORTED AND PAL_TRAIT_BUILD_HOST_TOOLS)
+    ly_add_pytest(
+        NAME AutomatedTesting::PythonAssetBuilder
+        TEST_SUITE periodic
+        TEST_SERIAL
+        PATH ${CMAKE_CURRENT_LIST_DIR}/PythonAssetBuilder
+        TIMEOUT 3600
+        RUNTIME_DEPENDENCIES
+            Legacy::Editor
+            Legacy::CryRenderNULL
+            AZ::AssetProcessor
+            AutomatedTesting.Assets
+            Gem::EditorPythonBindings.Editor
+            Gem::PythonAssetBuilder.Editor
+        COMPONENT TestTools
+    )
+endif()
+
 ## Blast ##
 if(PAL_TRAIT_BUILD_TESTS_SUPPORTED AND PAL_TRAIT_BUILD_HOST_TOOLS)
     ly_add_pytest(

AutomatedTesting/Gem/PythonTests/PythonAssetBuilder/AssetBuilder_test.py

@@ -0,0 +1,57 @@
+"""
+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.
+"""
+#
+# This launches the AssetProcessor and Editor then attempts to find the expected
+# assets created by a Python Asset Builder and the output of a scene pipeline script
+#
+import sys
+import os
+import pytest
+import logging
+pytest.importorskip('ly_test_tools')
+
+import ly_test_tools.environment.file_system as file_system
+import ly_test_tools.log.log_monitor
+import ly_test_tools.environment.waiter as waiter
+
+@pytest.mark.SUITE_sandbox
+@pytest.mark.parametrize('launcher_platform', ['windows_editor'])
+@pytest.mark.parametrize('project', ['AutomatedTesting'])
+@pytest.mark.parametrize('level', ['auto_test'])
+class TestPythonAssetProcessing(object):
+    def test_DetectPythonCreatedAsset(self, request, editor, level, launcher_platform):
+        unexpected_lines = []
+        expected_lines = [
+            'Mock asset exists',
+            'Expected subId for asset (gem/pythontests/pythonassetbuilder/geom_group_fbx_cube_100cm_center.azmodel) found',
+            'Expected subId for asset (gem/pythontests/pythonassetbuilder/geom_group_fbx_cube_100cm_X_negative.azmodel) found',
+            'Expected subId for asset (gem/pythontests/pythonassetbuilder/geom_group_fbx_cube_100cm_X_positive.azmodel) found',
+            'Expected subId for asset (gem/pythontests/pythonassetbuilder/geom_group_fbx_cube_100cm_center.azmodel) found',
+            'Expected subId for asset (gem/pythontests/pythonassetbuilder/geom_group_fbx_cube_100cm_center.azmodel) found',
+            'Expected subId for asset (gem/pythontests/pythonassetbuilder/geom_group_fbx_cube_100cm_center.azmodel) found',
+            'Expected subId for asset (gem/pythontests/pythonassetbuilder/geom_group_fbx_cube_100cm_center.azmodel) found',
+            'Expected subId for asset (gem/pythontests/pythonassetbuilder/geom_group_fbx_cube_100cm_center.azmodel) found'
+        ]
+        timeout = 180
+        halt_on_unexpected = False
+        test_directory = os.path.join(os.path.dirname(__file__))
+        testFile = os.path.join(test_directory, 'AssetBuilder_test_case.py')
+        editor.args.extend(['-NullRenderer', "--skipWelcomeScreenDialog", "--autotest_mode", "--runpythontest", testFile])
+
+        with editor.start():
+            editorlog_file = os.path.join(editor.workspace.paths.project_log(), 'Editor.log')
+            log_monitor = ly_test_tools.log.log_monitor.LogMonitor(editor, editorlog_file)
+            waiter.wait_for(
+                lambda: editor.is_alive(),
+                timeout,
+                exc=("Log file '{}' was never opened by another process.".format(editorlog_file)),
+                interval=1)
+            log_monitor.monitor_log_for_lines(expected_lines, unexpected_lines, halt_on_unexpected, timeout)

AutomatedTesting/Gem/PythonTests/PythonAssetBuilder/AssetBuilder_test_case.py

@@ -0,0 +1,52 @@
+"""
+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.
+"""
+import azlmbr.bus
+import azlmbr.asset
+import azlmbr.editor
+import azlmbr.math
+import azlmbr.legacy.general
+
+def raise_and_stop(msg):
+    print (msg)
+    azlmbr.editor.EditorToolsApplicationRequestBus(azlmbr.bus.Broadcast, 'ExitNoPrompt')
+
+# These tests are meant to check that the test_asset.mock source asset turned into
+# a test_asset.mock_asset product asset via the Python asset builder system
+mockAssetType = azlmbr.math.Uuid_CreateString('{9274AD17-3212-4651-9F3B-7DCCB080E467}', 0)
+mockAssetPath = 'gem/pythontests/pythonassetbuilder/test_asset.mock_asset'
+assetId = azlmbr.asset.AssetCatalogRequestBus(azlmbr.bus.Broadcast, 'GetAssetIdByPath', mockAssetPath, mockAssetType, False)
+if (assetId.is_valid() is False):
+    raise_and_stop(f'Mock AssetId is not valid! Got {assetId.to_string()} instead')
+
+if (assetId.to_string().endswith(':54c06b89') is False):
+    raise_and_stop(f'Mock AssetId has unexpected sub-id for {mockAssetPath}!')
+
+print ('Mock asset exists')
+
+# These tests detect if the geom_group.fbx file turns into a number of azmodel product assets
+def test_azmodel_product(generatedModelAssetPath, expectedSubId):
+    azModelAssetType = azlmbr.math.Uuid_CreateString('{2C7477B6-69C5-45BE-8163-BCD6A275B6D8}', 0)
+    assetId = azlmbr.asset.AssetCatalogRequestBus(azlmbr.bus.Broadcast, 'GetAssetIdByPath', generatedModelAssetPath, azModelAssetType, False)
+    assetIdString = assetId.to_string()
+    if (assetIdString.endswith(':' + expectedSubId) is False):
+        raise_and_stop(f'Asset has unexpected asset ID ({assetIdString}) for ({generatedModelAssetPath})!')
+    else:
+        print(f'Expected subId for asset ({generatedModelAssetPath}) found')
+
+test_azmodel_product('gem/pythontests/pythonassetbuilder/geom_group_fbx_cube_100cm_center.azmodel', '10412075')
+test_azmodel_product('gem/pythontests/pythonassetbuilder/geom_group_fbx_cube_100cm_X_positive.azmodel', '10d16e68')
+test_azmodel_product('gem/pythontests/pythonassetbuilder/geom_group_fbx_cube_100cm_X_negative.azmodel', '10a71973')
+test_azmodel_product('gem/pythontests/pythonassetbuilder/geom_group_fbx_cube_100cm_Y_positive.azmodel', '10130556')
+test_azmodel_product('gem/pythontests/pythonassetbuilder/geom_group_fbx_cube_100cm_Y_negative.azmodel', '1065724d')
+test_azmodel_product('gem/pythontests/pythonassetbuilder/geom_group_fbx_cube_100cm_Z_positive.azmodel', '1024be55')
+test_azmodel_product('gem/pythontests/pythonassetbuilder/geom_group_fbx_cube_100cm_Z_negative.azmodel', '1052c94e')
+
+azlmbr.editor.EditorToolsApplicationRequestBus(azlmbr.bus.Broadcast, 'ExitNoPrompt')

AutomatedTesting/Gem/PythonTests/PythonAssetBuilder/__init__.py

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

AutomatedTesting/Gem/PythonTests/PythonAssetBuilder/bootstrap_tests.py

@@ -0,0 +1,17 @@
+"""
+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.
+"""
+import os
+import sys
+try:
+    sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+    import mock_asset_builder
+except:
+    print ('skipping asset builder testing via mock_asset_builder')

AutomatedTesting/Gem/PythonTests/PythonAssetBuilder/export_chunks_builder.py

@@ -0,0 +1,88 @@
+"""
+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.
+"""
+import uuid,  os
+import azlmbr.scene as sceneApi
+import azlmbr.scene.graph
+from scene_api import scene_data as sceneData
+
+def get_mesh_node_names(sceneGraph):
+    meshDataList = []
+    node = sceneGraph.get_root()
+    children = []
+
+    while node.IsValid():
+        # store children to process after siblings
+        if sceneGraph.has_node_child(node):
+            children.append(sceneGraph.get_node_child(node))
+
+        # store any node that has mesh data content
+        nodeContent = sceneGraph.get_node_content(node)
+        if nodeContent is not None and nodeContent.CastWithTypeName('MeshData'):
+            if sceneGraph.is_node_end_point(node) is False:
+                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
+
+def update_manifest(scene):
+    graph = sceneData.SceneGraph(scene.graph)
+    meshNameList = get_mesh_node_names(graph)
+    sceneManifest = sceneData.SceneManifest()
+    sourceFilenameOnly = os.path.basename(scene.sourceFilename)
+    sourceFilenameOnly = sourceFilenameOnly.replace('.','_')
+
+    for activeMeshIndex in range(len(meshNameList)):
+        chunkName = meshNameList[activeMeshIndex]
+        chunkPath = chunkName.get_path()
+        meshGroupName = '{}_{}'.format(sourceFilenameOnly, chunkName.get_name())
+        meshGroup = sceneManifest.add_mesh_group(meshGroupName)
+        meshGroup['id'] = '{' + str(uuid.uuid5(uuid.NAMESPACE_DNS, sourceFilenameOnly + chunkPath)) + '}'
+        sceneManifest.mesh_group_add_comment(meshGroup, 'auto generated by scene manifest')
+        sceneManifest.mesh_group_add_advanced_coordinate_system(meshGroup, None, None, None, 1.0)
+
+        # create selection node list
+        pathSet = set()
+        for meshIndex in range(len(meshNameList)):
+            targetPath = meshNameList[meshIndex].get_path()
+            if (activeMeshIndex == meshIndex):
+                sceneManifest.mesh_group_select_node(meshGroup, targetPath)
+            else:
+                if targetPath not in pathSet:
+                    pathSet.update(targetPath)
+                    sceneManifest.mesh_group_unselect_node(meshGroup, targetPath)
+
+    return sceneManifest.export()
+
+mySceneJobHandler = None
+
+def on_update_manifest(args):
+    scene = args[0]
+    result = update_manifest(scene)
+    global mySceneJobHandler
+    mySceneJobHandler.disconnect()
+    mySceneJobHandler = None
+    return result
+
+def main():
+    global mySceneJobHandler
+    mySceneJobHandler = sceneApi.ScriptBuildingNotificationBusHandler()
+    mySceneJobHandler.connect()
+    mySceneJobHandler.add_callback('OnUpdateManifest', on_update_manifest)
+
+if __name__ == "__main__":
+    main()

AutomatedTesting/Gem/PythonTests/PythonAssetBuilder/geom_group.fbx

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

AutomatedTesting/Gem/PythonTests/PythonAssetBuilder/geom_group.fbx.assetinfo

@@ -0,0 +1,9 @@
+{
+    "values":
+    [
+        {
+            "$type": "ScriptProcessorRule",
+            "scriptFilename": "Gem/PythonTests/PythonAssetBuilder/export_chunks_builder.py"
+        }
+    ]
+}

AutomatedTesting/Gem/PythonTests/PythonAssetBuilder/mock_asset_builder.py

@@ -0,0 +1,121 @@
+"""
+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.
+"""
+import azlmbr.asset
+import azlmbr.asset.builder
+import azlmbr.bus
+import azlmbr.math
+import os, traceback, binascii, sys
+
+jobKeyName = 'Mock Asset'
+
+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))
+
+# creates a single job to compile for each platform
+def create_jobs(request):
+    # create job descriptor for each platform
+    jobDescriptorList = []
+    for platformInfo in request.enabledPlatforms:
+        jobDesc = azlmbr.asset.builder.JobDescriptor()
+        jobDesc.jobKey = jobKeyName
+        jobDesc.set_platform_identifier(platformInfo.identifier)
+        jobDescriptorList.append(jobDesc)
+
+    response = azlmbr.asset.builder.CreateJobsResponse()
+    response.result = azlmbr.asset.builder.CreateJobsResponse_ResultSuccess
+    response.createJobOutputs = jobDescriptorList
+    return response
+
+def on_create_jobs(args):
+    try:
+        request = args[0]
+        return create_jobs(request)
+    except:
+        log_exception_traceback()
+    # returing back a default CreateJobsResponse() records an asset error
+    return azlmbr.asset.builder.CreateJobsResponse()
+
+def process_file(request):
+    # prepare output folder
+    basePath, _ = os.path.split(request.sourceFile)
+    outputPath = os.path.join(request.tempDirPath, basePath)
+    os.makedirs(outputPath, exist_ok=True)
+
+    # write out a mock file
+    basePath, sourceFile = os.path.split(request.sourceFile)
+    mockFilename = os.path.splitext(sourceFile)[0] + '.mock_asset'
+    mockFilename = os.path.join(basePath, mockFilename)
+    mockFilename = mockFilename.replace('\\', '/')
+    tempFilename = os.path.join(request.tempDirPath, mockFilename)
+
+    # write out a tempFilename like a JSON
+    fileOutput = open(tempFilename, "w")
+    fileOutput.write('{}')
+    fileOutput.close()
+
+    # generate a product asset file entry
+    subId = binascii.crc32(mockFilename.encode())
+    mockAssetType = azlmbr.math.Uuid_CreateString('{9274AD17-3212-4651-9F3B-7DCCB080E467}', 0)
+    product = azlmbr.asset.builder.JobProduct(mockFilename, mockAssetType, subId)
+    product.dependenciesHandled = True
+    productOutputs = []
+    productOutputs.append(product)
+
+    # fill out response object
+    response = azlmbr.asset.builder.ProcessJobResponse()
+    response.outputProducts = productOutputs
+    response.resultCode = azlmbr.asset.builder.ProcessJobResponse_Success
+    response.dependenciesHandled = True
+    return response
+
+# using the incoming 'request' find the type of job via 'jobKey' to determine what to do
+def on_process_job(args):
+    try:
+        request = args[0]
+        if (request.jobDescription.jobKey.startswith(jobKeyName)):
+            return process_file(request)
+    except:
+        log_exception_traceback()
+    # returning back an empty ProcessJobResponse() will record an error
+    return azlmbr.asset.builder.ProcessJobResponse()
+
+# register asset builder
+def register_asset_builder(busId):
+    assetPattern = azlmbr.asset.builder.AssetBuilderPattern()
+    assetPattern.pattern = '*.mock'
+    assetPattern.type = azlmbr.asset.builder.AssetBuilderPattern_Wildcard
+
+    builderDescriptor = azlmbr.asset.builder.AssetBuilderDesc()
+    builderDescriptor.name = "Mock Builder"
+    builderDescriptor.patterns = [assetPattern]
+    builderDescriptor.busId = busId
+    builderDescriptor.version = 1
+
+    outcome = azlmbr.asset.builder.PythonAssetBuilderRequestBus(azlmbr.bus.Broadcast, 'RegisterAssetBuilder', builderDescriptor)
+    if outcome.IsSuccess():
+        # created the asset builder to hook into the notification bus
+        handler = azlmbr.asset.builder.PythonBuilderNotificationBusHandler()
+        handler.connect(busId)
+        handler.add_callback('OnCreateJobsRequest', on_create_jobs)
+        handler.add_callback('OnProcessJobRequest', on_process_job)
+        return handler
+
+# create the asset builder handler
+busIdString = '{CF5C74C1-9ED4-5851-95B1-0B15090DBEC7}'
+busId = azlmbr.math.Uuid_CreateString(busIdString, 0)
+handler = None
+try:
+    handler = register_asset_builder(busId)
+except:
+    handler = None
+    log_exception_traceback()

AutomatedTesting/Gem/PythonTests/PythonAssetBuilder/test_asset.mock

@@ -0,0 +1 @@
+mock data

AutomatedTesting/LightingPresets/greenwich_park_02.lightingconfig.json

@@ -1,7 +1,6 @@
 {
     "configurations": [
         {
-            "autoSelect": false,
             "displayName": "Greenwich Park 02",
             "skyboxImageAsset": {
                 "assetId": {
@@ -64,7 +63,6 @@
             "shadowCatcherOpacity": 0.20000000298023225
         },
         {
-            "autoSelect": false,
             "displayName": "Greenwich Park 02 (Alt)",
             "skyboxImageAsset": {
                 "assetId": {

Code/Framework/AzCore/AzCore/Settings/SettingsRegistryMergeUtils.cpp

@@ -506,6 +506,7 @@ namespace AZ::SettingsRegistryMergeUtils
 
     void MergeSettingsToRegistry_AddRuntimeFilePaths(SettingsRegistryInterface& registry)
     {
+        using FixedValueString = AZ::SettingsRegistryInterface::FixedValueString;
         // Binary folder
         AZ::IO::FixedMaxPath path = AZ::Utils::GetExecutableDirectory();
         registry.Set(FilePathKey_BinaryFolder, path.LexicallyNormal().Native());
@@ -514,28 +515,25 @@ namespace AZ::SettingsRegistryMergeUtils
         AZ::IO::FixedMaxPath engineRoot = FindEngineRoot(registry);
         registry.Set(FilePathKey_EngineRootFolder, engineRoot.LexicallyNormal().Native());
 
-        constexpr size_t bufferSize = 64;
-        auto buffer = AZStd::fixed_string<bufferSize>::format("%s/project_path", BootstrapSettingsRootKey);
-
-        AZ::SettingsRegistryInterface::FixedValueString projectPathKey(buffer);
+        auto projectPathKey = FixedValueString::format("%s/project_path", BootstrapSettingsRootKey);
         SettingsRegistryInterface::FixedValueString projectPathValue;
         if (registry.Get(projectPathValue, projectPathKey))
         {
             // Cache folder
             // Get the name of the asset platform assigned by the bootstrap. First check for platform version such as "windows_assets"
             // and if that's missing just get "assets".
-            constexpr char platformName[] = AZ_TRAIT_OS_PLATFORM_CODENAME_LOWER;
-
-            buffer = AZStd::fixed_string<bufferSize>::format("%s/%s_assets", BootstrapSettingsRootKey, platformName);
-            AZStd::string_view assetPlatformKey(buffer);
-            // Use the platform codename to retrieve the default asset platform value
-            SettingsRegistryInterface::FixedValueString assetPlatform = AZ::OSPlatformToDefaultAssetPlatform(AZ_TRAIT_OS_PLATFORM_CODENAME);
-            if (!registry.Get(assetPlatform, assetPlatformKey))
+            FixedValueString assetPlatform;
+            if (auto assetPlatformKey = FixedValueString::format("%s/%s_assets", BootstrapSettingsRootKey, AZ_TRAIT_OS_PLATFORM_CODENAME_LOWER);
+                !registry.Get(assetPlatform, assetPlatformKey))
             {
-                buffer = AZStd::fixed_string<bufferSize>::format("%s/assets", BootstrapSettingsRootKey);
-                assetPlatformKey = AZStd::string_view(buffer);
+                assetPlatformKey = FixedValueString::format("%s/assets", BootstrapSettingsRootKey);
                 registry.Get(assetPlatform, assetPlatformKey);
             }
+            if (assetPlatform.empty())
+            {
+                // Use the platform codename to retrieve the default asset platform value
+                assetPlatform = AZ::OSPlatformToDefaultAssetPlatform(AZ_TRAIT_OS_PLATFORM_CODENAME);
+            }
 
             // Project path - corresponds to the @devassets@ alias
             // NOTE: Here we append to engineRoot, but if projectPathValue is absolute then engineRoot is discarded.
@@ -575,8 +573,7 @@ namespace AZ::SettingsRegistryMergeUtils
             {
                 // Cache: project root - no corresponding fileIO alias, but this is where the asset database lives.
                 // A registry override is accepted using the "project_cache_path" key.
-                buffer = AZStd::fixed_string<bufferSize>::format("%s/project_cache_path", BootstrapSettingsRootKey);
-                AZStd::string_view projectCacheRootOverrideKey(buffer);
+                auto projectCacheRootOverrideKey = FixedValueString::format("%s/project_cache_path", BootstrapSettingsRootKey);
                 // Clear path to make sure that the `project_cache_path` value isn't concatenated to the project path
                 path.clear();
                 if (registry.Get(path.Native(), projectCacheRootOverrideKey))

Code/Framework/AzToolsFramework/AzToolsFramework/Entity/EditorEntityHelpers.cpp

@@ -136,6 +136,48 @@ namespace AzToolsFramework
         return entity->GetName();
     }
 
+    EntityList EntityIdListToEntityList(const EntityIdList& inputEntityIds)
+    {
+        EntityList entities;
+        entities.reserve(inputEntityIds.size());
+
+        for (AZ::EntityId entityId : inputEntityIds)
+        {
+            if (!entityId.IsValid())
+            {
+                continue;
+            }
+
+            if (auto entity = GetEntityById(entityId))
+            {
+                entities.emplace_back(entity);
+            }
+        }
+
+        return entities;
+    }
+
+    EntityList EntityIdSetToEntityList(const EntityIdSet& inputEntityIds)
+    {
+        EntityList entities;
+        entities.reserve(inputEntityIds.size());
+
+        for (AZ::EntityId entityId : inputEntityIds)
+        {
+            if (!entityId.IsValid())
+            {
+                continue;
+            }
+
+            if (auto entity = GetEntityById(entityId))
+            {
+                entities.emplace_back(entity);
+            }
+        }
+
+        return entities;
+    }
+
     void GetAllComponentsForEntity(const AZ::Entity* entity, AZ::Entity::ComponentArrayType& componentsOnEntity)
     {
         if (entity)
@@ -1068,6 +1110,45 @@ namespace AzToolsFramework
         return !allEntityClonesContainer.m_entities.empty();
     }
 
+    EntityIdSet GetCulledEntityHierarchy(const EntityIdList& entities)
+    {
+        EntityIdSet culledEntities;
+
+        for (const AZ::EntityId& entityId : entities)
+        {
+            bool selectionIncludesTransformHeritage = false;
+            AZ::EntityId parentEntityId = entityId;
+            do
+            {
+                AZ::EntityId nextParentId;
+                AZ::TransformBus::EventResult(
+                    /*result*/ nextParentId,
+                    /*address*/ parentEntityId,
+                    &AZ::TransformBus::Events::GetParentId);
+                parentEntityId = nextParentId;
+                if (!parentEntityId.IsValid())
+                {
+                    break;
+                }
+                for (const AZ::EntityId& parentCheck : entities)
+                {
+                    if (parentCheck == parentEntityId)
+                    {
+                        selectionIncludesTransformHeritage = true;
+                        break;
+                    }
+                }
+            } while (parentEntityId.IsValid() && !selectionIncludesTransformHeritage);
+
+            if (!selectionIncludesTransformHeritage)
+            {
+                culledEntities.insert(entityId);
+            }
+        }
+
+        return culledEntities;
+    }
+
     namespace Internal
     {
         void CloneSliceEntitiesAndChildren(

Code/Framework/AzToolsFramework/AzToolsFramework/Entity/EditorEntityHelpers.h

@@ -47,6 +47,9 @@ namespace AzToolsFramework
 
     AZStd::string GetEntityName(const AZ::EntityId& entityId, const AZStd::string_view& nameOverride = {});
 
+    EntityList EntityIdListToEntityList(const EntityIdList& inputEntityIds);
+    EntityList EntityIdSetToEntityList(const EntityIdSet& inputEntityIds);
+
     template <typename... ComponentTypes>
     struct AddComponents
     {
@@ -202,4 +205,8 @@ namespace AzToolsFramework
     /// Wrap EBus SetSelectedEntities call.
     void SelectEntities(const AzToolsFramework::EntityIdList& entities);
 
+    /// Return a set of entities, culling any that have an ancestor in the list.
+    /// e.g. This is useful for getting a concise set of entities that need to be duplicated.
+    EntityIdSet GetCulledEntityHierarchy(const EntityIdList& entities);
+
 }; // namespace AzToolsFramework

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicHandler.cpp

@@ -61,8 +61,7 @@ namespace AzToolsFramework
         PrefabOperationResult PrefabPublicHandler::CreatePrefab(const AZStd::vector<AZ::EntityId>& entityIds, AZ::IO::PathView filePath)
         {
             // Retrieve entityList from entityIds
-            EntityList inputEntityList;
-            EntityIdListToEntityList(entityIds, inputEntityList);
+            EntityList inputEntityList = EntityIdListToEntityList(entityIds);
 
             // Find common root and top level entities
             bool entitiesHaveCommonRoot = false;
@@ -419,8 +418,7 @@ namespace AzToolsFramework
             InstanceOptionalReference instance = GetOwnerInstanceByEntityId(entityIds[0]);
 
             // Retrieve entityList from entityIds
-            EntityList inputEntityList;
-            EntityIdListToEntityList(entityIds, inputEntityList);
+            EntityList inputEntityList = EntityIdListToEntityList(entityIds);
 
             AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
 
@@ -767,18 +765,5 @@ namespace AzToolsFramework
 
             return true;
         }
-
-        void PrefabPublicHandler::EntityIdListToEntityList(const EntityIdList& inputEntityIds, EntityList& outEntities)
-        {
-            outEntities.reserve(inputEntityIds.size());
-
-            for (AZ::EntityId entityId : inputEntityIds)
-            {
-                if (entityId.IsValid())
-                {
-                    outEntities.emplace_back(GetEntityById(entityId));
-                }
-            }
-        }
     }
 }

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicHandler.h

@@ -70,7 +70,6 @@ namespace AzToolsFramework
             static Instance* GetParentInstance(Instance* instance);
             static Instance* GetAncestorOfInstanceThatIsChildOfRoot(const Instance* ancestor, Instance* descendant);
             static void GenerateContainerEntityTransform(const EntityList& topLevelEntities, AZ::Vector3& translation, AZ::Quaternion& rotation);
-            static void EntityIdListToEntityList(const EntityIdList& inputEntityIds, EntityList& outEntities);
 
             InstanceEntityMapperInterface* m_instanceEntityMapperInterface = nullptr;
             InstanceToTemplateInterface* m_instanceToTemplateInterface = nullptr;

Code/Framework/AzToolsFramework/Tests/Entity/EditorEntityHelpersTests.cpp

@@ -0,0 +1,57 @@
+/*
+* 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 <AzTest/AzTest.h>
+
+#include <AzToolsFramework/Application/ToolsApplication.h>
+#include <AzToolsFramework/Entity/EditorEntityHelpers.h>
+#include <AzToolsFramework/UnitTest/AzToolsFrameworkTestHelpers.h>
+
+namespace UnitTest
+{
+    class EditorEntityHelpersTest
+        : public ToolsApplicationFixture
+    {
+        void SetUpEditorFixtureImpl() override
+        {
+            m_parent1 = CreateDefaultEditorEntity("Parent1");
+            m_child1 = CreateDefaultEditorEntity("Child1");
+            m_child2 = CreateDefaultEditorEntity("Child2");
+            m_grandChild1 = CreateDefaultEditorEntity("GrandChild1");
+            m_parent2 = CreateDefaultEditorEntity("Parent2");
+
+            AZ::TransformBus::Event(m_child1, &AZ::TransformBus::Events::SetParent, m_parent1);
+            AZ::TransformBus::Event(m_child2, &AZ::TransformBus::Events::SetParent, m_parent1);
+            AZ::TransformBus::Event(m_grandChild1, &AZ::TransformBus::Events::SetParent, m_child1);
+        }
+
+    public:
+        AZ::EntityId m_parent1;
+        AZ::EntityId m_child1;
+        AZ::EntityId m_child2;
+        AZ::EntityId m_grandChild1;
+        AZ::EntityId m_parent2;
+    };
+
+    TEST_F(EditorEntityHelpersTest, EditorEntityHelpersTests_GetCulledEntityHierarchy)
+    {
+        AzToolsFramework::EntityIdList testEntityIds{ m_parent1, m_child1, m_child2, m_grandChild1, m_parent2 };
+
+        AzToolsFramework::EntityIdSet culledSet = AzToolsFramework::GetCulledEntityHierarchy(testEntityIds);
+
+        // There should only be two EntityIds returned (m_parent1, and m_parent2),
+        // since all the others should be culled out since they have a common ancestor
+        // in the list already
+        using ::testing::UnorderedElementsAre;
+        EXPECT_THAT(culledSet, UnorderedElementsAre(m_parent1, m_parent2));
+    }
+}

Code/Framework/AzToolsFramework/Tests/aztoolsframeworktests_files.cmake

@@ -85,7 +85,9 @@ set(FILES
     Prefab/SpawnableSortEntitiesTestFixture.cpp
     Prefab/SpawnableSortEntitiesTestFixture.h
     Entity/EditorEntityContextComponentTests.cpp
+    Entity/EditorEntityHelpersTests.cpp
     Entity/EditorEntitySearchComponentTests.cpp
+    Entity/EditorEntitySelectionTests.cpp
     SliceStabilityTests/SliceStabilityTestFramework.h
     SliceStabilityTests/SliceStabilityTestFramework.cpp
     SliceStabilityTests/SliceStabilityCreateTests.cpp

Code/Sandbox/Plugins/ComponentEntityEditorPlugin/SandboxIntegration.cpp

@@ -670,9 +670,13 @@ void SandboxIntegrationManager::PopulateEditorGlobalContextMenu(QMenu* menu, con
         action = menu->addAction(QObject::tr("Create layer"));
         QObject::connect(action, &QAction::triggered, [this] { ContextMenu_NewLayer(); });
 
+        AzToolsFramework::EntityIdList entities;
+        AzToolsFramework::ToolsApplicationRequests::Bus::BroadcastResult(
+            entities,
+            &AzToolsFramework::ToolsApplicationRequests::GetSelectedEntities);
+
         SetupLayerContextMenu(menu);
-        AzToolsFramework::EntityIdSet flattenedSelection;
-        GetSelectedEntitiesSetWithFlattenedHierarchy(flattenedSelection);
+        AzToolsFramework::EntityIdSet flattenedSelection = AzToolsFramework::GetCulledEntityHierarchy(entities);
         AzToolsFramework::SetupAddToLayerMenu(menu, flattenedSelection, [this] { return ContextMenu_NewLayer(); });
 
         SetupSliceContextMenu(menu);
@@ -1220,10 +1224,14 @@ void SandboxIntegrationManager::CloneSelection(bool& handled)
 {
     AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
 
-    AzToolsFramework::EntityIdSet duplicationSet;
-    GetSelectedEntitiesSetWithFlattenedHierarchy(duplicationSet);
+    AzToolsFramework::EntityIdList entities;
+    AzToolsFramework::ToolsApplicationRequests::Bus::BroadcastResult(
+        entities,
+        &AzToolsFramework::ToolsApplicationRequests::GetSelectedEntities);
 
-    if (duplicationSet.size() > 0)
+    AzToolsFramework::EntityIdSet duplicationSet = AzToolsFramework::GetCulledEntityHierarchy(entities);
+
+    if (!duplicationSet.empty())
     {
         AZStd::unordered_set<AZ::EntityId> clonedEntities;
         handled = AzToolsFramework::CloneInstantiatedEntities(duplicationSet, clonedEntities);

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

@@ -42,7 +42,108 @@ namespace AZ
 
             // Downstream only supports 30 frames per second sample rate. Adjusting to 60 doubles the
             // length of the animations, they still play back at 30 frames per second.
-            const double AssImpAnimationImporter::s_defaultTimeStepSampleRate = 1.0 / 30.0;
+            const double AssImpAnimationImporter::s_defaultTimeStepBetweenFrames = 1.0 / 30.0;
+
+            AZ::u32 GetNumKeyFrames(AZ::u32 keysSize, double duration, double ticksPerSecond)
+            {
+                if (AZ::IsClose(ticksPerSecond, 0))
+                {
+                    AZ_Warning("AnimationImporter", false, "Animation ticks per second should not be zero, defaulting to %d keyframes for animation.", keysSize);
+                    return keysSize;
+                }
+                const double totalTicks = duration / ticksPerSecond;
+                AZ::u32 numKeys = keysSize;
+                // +1 because the animation is from [0, duration] - we have a keyframe at the end of the duration which needs to be included
+                double totalFramesAtDefaultTimeStep = totalTicks / AssImpAnimationImporter::s_defaultTimeStepBetweenFrames + 1;
+                if (!AZ::IsClose(totalFramesAtDefaultTimeStep, numKeys, 1))
+                {
+                    numKeys = AZStd::ceilf(totalFramesAtDefaultTimeStep);
+                }
+                return numKeys;
+            }
+
+            double GetTimeForFrame(AZ::u32 frame, double ticksPerSecond)
+            {
+                return frame * AssImpAnimationImporter::s_defaultTimeStepBetweenFrames * ticksPerSecond;
+            }
+
+            // Helper class to store key data, when translating from AssImp layout to the engine's scene format.
+            struct KeyData
+            {
+                KeyData(float value, float time) :
+                    mValue(value),
+                    mTime(time)
+                {
+
+                }
+
+                bool operator<(const KeyData& other) const
+                {
+                    return mTime < other.mTime;
+                }
+
+                float mValue = 0;
+                float mTime = 0;
+            };
+
+            template<class T>
+            void LerpTemplate(T& start, const T& end, float t)
+            {
+                start = start * (1.0f - t) + end * t;
+            }
+
+            template<>
+            void LerpTemplate(aiQuaternion& start, const aiQuaternion& end, float t)
+            {
+                aiQuaternion::Interpolate(start, start, end, t);
+            }
+
+            template<>
+            void LerpTemplate(float& start, const float& end, float t)
+            {
+                start = AZ::Lerp(start, end, t);
+            }
+
+            template<class KeyContainerType, class FrameValueType>
+            bool SampleKeyFrame(FrameValueType& result, const KeyContainerType& keys, AZ::u32 numKeys, double time, AZ::u32& lastIndex)
+            {
+                if (numKeys == 0)
+                {
+                    AZ_Error("AnimationImporter", numKeys > 0, "Animation key set must have at least 1 key");
+                    return false;
+                }
+                if (numKeys == 1)
+                {
+                    result = keys[0].mValue;
+                    return true;
+                }
+
+                while (lastIndex < numKeys - 1 && time >= keys[lastIndex + 1].mTime)
+                {
+                    ++lastIndex;
+                }
+                result = keys[lastIndex].mValue;
+                if (lastIndex < numKeys - 1)
+                {
+                    auto nextValue = keys[lastIndex + 1].mValue;
+                    float normalizedTimeBetweenFrames = 0;
+                    if (keys[lastIndex + 1].mTime != keys[lastIndex].mTime)
+                    {
+                        normalizedTimeBetweenFrames =
+                            (time - keys[lastIndex].mTime) / (keys[lastIndex + 1].mTime - keys[lastIndex].mTime);
+                    }
+                    else
+                    {
+                        AZ_Warning("AnimationImporter", false,
+                            "Animation has keys with duplicate time %5.5f, at indices %d and %d. The second will be ignored.",
+                            keys[lastIndex].mTime,
+                            lastIndex,
+                            lastIndex + 1);
+                    }
+                    LerpTemplate(result, nextValue, normalizedTimeBetweenFrames);
+                }
+                return true;
+            }
 
             AssImpAnimationImporter::AssImpAnimationImporter()
             {
@@ -199,6 +300,14 @@ namespace AZ
                 for (AZ::u32 animIndex = 0; animIndex < scene->mNumAnimations; ++animIndex)
                 {
                     const aiAnimation* animation = scene->mAnimations[animIndex];
+                    if (animation->mTicksPerSecond == 0)
+                    {
+                        AZ_Error(
+                            "AnimationImporter", false,
+                            "Animation name %s has a sample rate of 0 ticks per second and cannot be processed.",
+                            animation->mName.C_Str());
+                        return Events::ProcessingResult::Failure;
+                    }
                     
                     mapAnimationsFunc(animation->mNumChannels, animation->mChannels, animation, boneAnimations);
 
@@ -410,70 +519,38 @@ namespace AZ
                             anim->mNumPositionKeys, anim->mNumRotationKeys, anim->mNumScalingKeys);
                         return Events::ProcessingResult::Failure;
                     }
-                    
-                    auto sampleKeyFrame = [](const auto& keys, AZ::u32 numKeys, double time, AZ::u32& lastIndex)
-                    {
-                        AZ_Error("AnimationImporter", numKeys > 0, "Animation key set must have at least 1 key");
-
-                        if (numKeys == 1)
-                        {
-                            return keys[0].mValue;
-                        }
-
-                        auto returnValue = keys[0].mValue;
-
-                        for (AZ::u32 keyIndex = lastIndex; keyIndex < numKeys; ++keyIndex)
-                        {
-                            const auto& key = keys[keyIndex];
-                            lastIndex = keyIndex;
-
-                            // We want to return the key that exactly matches the time if possible, otherwise we'll keep track of the previous time
-                            // If we don't find an exact match and end up going past the desired time (or run out of keyframes) then we return the previous key
-                            if (key.mTime < time)
-                            {
-                                returnValue = key.mValue;
-                            }
-                            else if (AZ::IsClose(key.mTime, time))
-                            {
-                                return key.mValue;
-                            }
-                            else
-                            {
-                                return returnValue;
-                            }
-                        }
-                        
-                        return returnValue;
-                    };
 
                     // Resample the animations at a fixed time step. This matches the behaviour of
                     // the previous SDK used. Longer term, this could be data driven, or based on the
                     // smallest time step between key frames.
                     // AssImp has an animation->mTicksPerSecond and animation->mDuration, but those
                     // are less predictable than just using a fixed time step.
-                    const double duration = animation->mDuration / animation->mTicksPerSecond;
+                    // AssImp documentation claims animation->mDuration is the duration of the animation in ticks, but
+                    // not all animations we've tested follow that pattern. Sometimes duration is in seconds.
+                    const AZ::u32 numKeyFrames = GetNumKeyFrames(
+                        AZStd::max(AZStd::max(anim->mNumScalingKeys, anim->mNumPositionKeys), anim->mNumRotationKeys),
+                        animation->mDuration,
+                        animation->mTicksPerSecond);
 
-                    AZ::u32 numKeyFrames = AZStd::max(AZStd::max(anim->mNumScalingKeys, anim->mNumPositionKeys), anim->mNumRotationKeys);
-                    if (!AZ::IsClose(duration / s_defaultTimeStepSampleRate, numKeyFrames, 1))
-                    {
-                        double dT = duration / s_defaultTimeStepSampleRate;
-                        numKeyFrames = AZStd::ceilf(dT) + 1; // +1 because the animation is from [0, duration] - we have a keyframe at the end of the duration which needs to be included
-                    }
-                    
                     AZStd::shared_ptr<SceneData::GraphData::AnimationData> createdAnimationData =
                        AZStd::make_shared<SceneData::GraphData::AnimationData>();
                     createdAnimationData->ReserveKeyFrames(numKeyFrames);
-                    createdAnimationData->SetTimeStepBetweenFrames(s_defaultTimeStepSampleRate);
+                    createdAnimationData->SetTimeStepBetweenFrames(s_defaultTimeStepBetweenFrames);
 
                     AZ::u32 lastScaleIndex = 0;
                     AZ::u32 lastPositionIndex = 0;
                     AZ::u32 lastRotationIndex = 0;
                     for (AZ::u32 frame = 0; frame < numKeyFrames; ++frame)
                     {
-                        double time = frame * s_defaultTimeStepSampleRate * animation->mTicksPerSecond;
-                        aiVector3D scale = sampleKeyFrame(anim->mScalingKeys, anim->mNumScalingKeys, time, lastScaleIndex);
-                        aiVector3D position = sampleKeyFrame(anim->mPositionKeys, anim->mNumPositionKeys, time, lastPositionIndex);
-                        aiQuaternion rotation = sampleKeyFrame(anim->mRotationKeys, anim->mNumRotationKeys, time, lastRotationIndex);
+                        const double time = GetTimeForFrame(frame, animation->mTicksPerSecond);
+                        aiVector3D scale = aiVector3D(1.f, 1.f, 1.f), position = aiVector3D(0.f, 0.f, 0.f);
+                        aiQuaternion rotation(1.f, 0.f, 0.f, 0.f);
+                        if (!SampleKeyFrame(scale, anim->mScalingKeys, anim->mNumScalingKeys, time, lastScaleIndex) ||
+                            !SampleKeyFrame(position, anim->mPositionKeys, anim->mNumPositionKeys, time, lastPositionIndex) ||
+                            !SampleKeyFrame(rotation, anim->mRotationKeys, anim->mNumRotationKeys, time, lastRotationIndex))
+                        {
+                            return Events::ProcessingResult::Failure;
+                        }
                         
                         aiMatrix4x4 transform(scale, rotation, position);
                         
@@ -520,28 +597,6 @@ namespace AZ
                 //      SetTimeStepBetweenFrames set on the animation data
                 //      Keyframes. Weights (Values in FBX SDK) per key time.
                 //      Keyframes generated for every single frame of the animation.
-
-                // Helper class to store key data, when translating from AssImp layout to the engine's scene format.
-                struct KeyData
-                {
-                    KeyData(float weight, float time) :
-                        m_weight(weight),
-                        m_time(time)
-                    {
-
-                    }
-
-                    bool operator<(const KeyData& other) const
-                    {
-                        return m_time < other.m_time;
-                    }
-
-                    // Naming in the previous SDK (FBX SDK) and in the engine's scene format
-                    // doesn't match AssImp's naming convention.
-                    // weight here is the AssImp's name for the data, it was named value in FBX SDK.
-                    float m_weight = 0;
-                    float m_time = 0;
-                };
                 typedef AZStd::map<int, AZStd::vector<KeyData>> ValueToKeyDataMap;
                 ValueToKeyDataMap valueToKeyDataMap;
 
@@ -562,44 +617,27 @@ namespace AZ
                 {
                     AZStd::shared_ptr<SceneData::GraphData::BlendShapeAnimationData> morphAnimNode =
                         AZStd::make_shared<SceneData::GraphData::BlendShapeAnimationData>();
-                    morphAnimNode->ReserveKeyFrames(animation->mDuration + 1);
-                    morphAnimNode->SetTimeStepBetweenFrames(1.0 / animation->mTicksPerSecond);
+
+                    const AZ::u32 numKeyFrames = GetNumKeyFrames(keys.size(), animation->mDuration, animation->mTicksPerSecond);
+                    morphAnimNode->ReserveKeyFrames(numKeyFrames);
+                    morphAnimNode->SetTimeStepBetweenFrames(s_defaultTimeStepBetweenFrames);
 
                     aiAnimMesh* aiAnimMesh = mesh->mAnimMeshes[meshIdx];
                     AZStd::string_view nodeName(aiAnimMesh->mName.C_Str());
 
                     const AZ::u32 maxKeys = keys.size();
                     AZ::u32 keyIdx = 0;
-                    for (AZ::u32 time = 0; time <= animation->mDuration; ++time)
+                    for (AZ::u32 frame = 0; frame <= numKeyFrames; ++frame)
                     {
-                        if (keyIdx < maxKeys - 1 && time >= keys[keyIdx+1].m_time)
-                        {
-                            ++keyIdx;
-                        }
-                        float weight_value = keys[keyIdx].m_weight;
-                        if (keyIdx < maxKeys - 1)
-                        {
-                            float nextWeight = keys[keyIdx+1].m_weight;
-                            float normalizedTimeBetweenFrames = 0;
+                        const double time = GetTimeForFrame(frame, animation->mTicksPerSecond);
 
-                            if (keys[keyIdx + 1].m_time != keys[keyIdx].m_time)
-                            {
-                                normalizedTimeBetweenFrames =
-                                    (time - keys[keyIdx].m_time) / (keys[keyIdx + 1].m_time - keys[keyIdx].m_time);
-                            }
-                            else
-                            {
-                                AZ_Warning("AnimationImporter", false,
-                                    "Morph target mesh %s has keys with duplicate time, at indices %d and %d. The second will be ignored.",
-                                    nodeName.data(),
-                                    keyIdx,
-                                    keyIdx+1);
-                            }
-
-                            // AssImp and FBX both only support linear interpolation for blend shapes.
-                            weight_value = AZ::Lerp(weight_value, nextWeight, normalizedTimeBetweenFrames);
+                        float weight = 0;
+                        if (!SampleKeyFrame(weight, keys, keys.size(), time, keyIdx))
+                        {
+                            return Events::ProcessingResult::Failure;
                         }
-                        morphAnimNode->AddKeyFrame(weight_value);
+
+                        morphAnimNode->AddKeyFrame(weight);
                     }
 
 

Code/Tools/SceneAPI/FbxSceneBuilder/Importers/AssImpAnimationImporter.h

@@ -45,7 +45,7 @@ namespace AZ
                     const aiMeshMorphAnim* meshMorphAnim,
                     const aiMesh* mesh);
 
-                static const double s_defaultTimeStepSampleRate;
+                static const double s_defaultTimeStepBetweenFrames;
 
             protected:
                 static const char* s_animationNodeName;

Code/Tools/SceneAPI/SceneCore/Containers/SceneGraph.cpp

@@ -43,7 +43,7 @@ namespace AZ
                 AZ::BehaviorContext* behaviorContext = azrtti_cast<AZ::BehaviorContext*>(context);
                 if (behaviorContext)
                 {
-                    behaviorContext->Class<SceneGraph::NodeIndex>()
+                    behaviorContext->Class<SceneGraph::NodeIndex>("NodeIndex")
                         ->Attribute(AZ::Script::Attributes::Scope, AZ::Script::Attributes::ScopeFlags::Common)
                         ->Attribute(AZ::Script::Attributes::Module, "scene.graph")
                         ->Constructor<>()
@@ -57,7 +57,7 @@ namespace AZ
                             ->Attribute(AZ::Script::Attributes::Operator, AZ::Script::Attributes::OperatorType::ToString)
                         ;
 
-                    behaviorContext->Class<SceneGraph::Name>()
+                    behaviorContext->Class<SceneGraph::Name>("SceneGraphName")
                         ->Attribute(AZ::Script::Attributes::Scope, AZ::Script::Attributes::ScopeFlags::Common)
                         ->Attribute(AZ::Script::Attributes::Module, "scene.graph")
                         ->Constructor()

Gems/AWSClientAuth/Code/Source/Authentication/AuthenticationProviderManager.cpp

@@ -48,7 +48,7 @@ namespace AWSClientAuth
         m_settingsRegistry = AZStd::make_shared<AZ::SettingsRegistryImpl>();
 
         AZStd::array<char, AZ::IO::MaxPathLength> resolvedPath{};
-        AZ::IO::FileIOBase::GetInstance()->ResolvePath(settingsRegistryPath.data(), resolvedPath.data(), resolvedPath.size());
+        fileIO->ResolvePath(settingsRegistryPath.data(), resolvedPath.data(), resolvedPath.size());
 
 
         if (!m_settingsRegistry->MergeSettingsFile(resolvedPath.data(), AZ::SettingsRegistryInterface::Format::JsonMergePatch))

Gems/Atom/Feature/Common/Code/Include/Atom/Feature/Utils/LightingPreset.h

@@ -78,7 +78,6 @@ namespace AZ
             AZ_CLASS_ALLOCATOR(LightingPreset, AZ::SystemAllocator, 0);
             static void Reflect(AZ::ReflectContext* context);
 
-            bool m_autoSelect = false;
             AZStd::string m_displayName;
             AZ::Data::Asset<AZ::RPI::StreamingImageAsset> m_iblDiffuseImageAsset;
             AZ::Data::Asset<AZ::RPI::StreamingImageAsset> m_iblSpecularImageAsset;

Gems/Atom/Feature/Common/Code/Include/Atom/Feature/Utils/ModelPreset.h

@@ -32,7 +32,6 @@ namespace AZ
             AZ_CLASS_ALLOCATOR(ModelPreset, AZ::SystemAllocator, 0);
             static void Reflect(AZ::ReflectContext* context);
 
-            bool m_autoSelect = false;
             AZStd::string m_displayName;
             AZ::Data::Asset<AZ::RPI::ModelAsset> m_modelAsset;
             AZ::Data::Asset<AZ::RPI::StreamingImageAsset> m_previewImageAsset;

Gems/Atom/Feature/Common/Code/Source/Utils/EditorLightingPreset.cpp

@@ -112,7 +112,6 @@ namespace AZ
                         ->ClassElement(AZ::Edit::ClassElements::EditorData, "")
                             ->Attribute(AZ::Edit::Attributes::AutoExpand, true)
                         ->DataElement(AZ::Edit::UIHandlers::Default, &LightingPreset::m_displayName, "Display Name", "Identifier used for display and selection")
-                        ->DataElement(AZ::Edit::UIHandlers::Default, &LightingPreset::m_autoSelect, "Auto Select", "When true, the configuration is automatically selected when loaded")
                         ->DataElement(AZ::Edit::UIHandlers::Default, &LightingPreset::m_iblDiffuseImageAsset, "IBL Diffuse Image Asset", "IBL diffuse image asset reference")
                         ->DataElement(AZ::Edit::UIHandlers::Default, &LightingPreset::m_iblSpecularImageAsset, "IBL Specular Image Asset", "IBL specular image asset reference")
                         ->DataElement(AZ::Edit::UIHandlers::Default, &LightingPreset::m_skyboxImageAsset, "Skybox Image Asset", "Skybox image asset reference")

Gems/Atom/Feature/Common/Code/Source/Utils/EditorModelPreset.cpp

@@ -32,7 +32,6 @@ namespace AZ
                         ->ClassElement(AZ::Edit::ClassElements::EditorData, "")
                             ->Attribute(AZ::Edit::Attributes::AutoExpand, true)
                         ->DataElement(AZ::Edit::UIHandlers::Default, &ModelPreset::m_displayName, "Display Name", "Identifier used for display and selection")
-                        ->DataElement(AZ::Edit::UIHandlers::Default, &ModelPreset::m_autoSelect, "Auto Select", "When true, the configuration is automatically selected when loaded")
                         ->DataElement(AZ::Edit::UIHandlers::Default, &ModelPreset::m_modelAsset, "Model Asset", "Model asset reference")
                         ->DataElement(AZ::Edit::UIHandlers::Default, &ModelPreset::m_previewImageAsset, "Preview Image Asset", "Preview image asset reference")
                         ;

Gems/Atom/Feature/Common/Code/Source/Utils/LightingPreset.cpp

@@ -105,8 +105,7 @@ namespace AZ
                 serializeContext->RegisterGenericType<AZStd::vector<LightConfig>>();
 
                 serializeContext->Class<LightingPreset>()
-                    ->Version(4)
-                    ->Field("autoSelect", &LightingPreset::m_autoSelect)
+                    ->Version(5)
                     ->Field("displayName", &LightingPreset::m_displayName)
                     ->Field("iblDiffuseImageAsset", &LightingPreset::m_iblDiffuseImageAsset)
                     ->Field("iblSpecularImageAsset", &LightingPreset::m_iblSpecularImageAsset)
@@ -128,7 +127,6 @@ namespace AZ
                     ->Attribute(AZ::Script::Attributes::Module, "render")
                     ->Constructor()
                     ->Constructor<const LightingPreset&>()
-                    ->Property("autoSelect", BehaviorValueProperty(&LightingPreset::m_autoSelect))
                     ->Property("displayName", BehaviorValueProperty(&LightingPreset::m_displayName))
                     ->Property("alternateSkyboxImageAsset", BehaviorValueProperty(&LightingPreset::m_alternateSkyboxImageAsset))
                     ->Property("skyboxImageAsset", BehaviorValueProperty(&LightingPreset::m_skyboxImageAsset))

Gems/Atom/Feature/Common/Code/Source/Utils/ModelPreset.cpp

@@ -25,8 +25,7 @@ namespace AZ
             if (auto serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
             {
                 serializeContext->Class<ModelPreset>()
-                    ->Version(2)
-                    ->Field("autoSelect", &ModelPreset::m_autoSelect)
+                    ->Version(3)
                     ->Field("displayName", &ModelPreset::m_displayName)
                     ->Field("modelAsset", &ModelPreset::m_modelAsset)
                     ->Field("previewImageAsset", &ModelPreset::m_previewImageAsset)
@@ -41,7 +40,6 @@ namespace AZ
                     ->Attribute(AZ::Script::Attributes::Module, "render")
                     ->Constructor()
                     ->Constructor<const ModelPreset&>()
-                    ->Property("autoSelect", BehaviorValueProperty(&ModelPreset::m_autoSelect))
                     ->Property("displayName", BehaviorValueProperty(&ModelPreset::m_displayName))
                     ->Property("modelAsset", BehaviorValueProperty(&ModelPreset::m_modelAsset))
                     ->Property("previewImageAsset", BehaviorValueProperty(&ModelPreset::m_previewImageAsset))

Gems/Atom/TestData/TestData/LightingPresets/urban_street_02.lightingpreset.azasset

@@ -3,7 +3,6 @@
     "Version": 1,
     "ClassName": "AZ::Render::LightingPreset",
     "ClassData": {
-        "autoSelect": false,
         "displayName": "Urban Street 02",
         "skyboxImageAsset": {
             "assetId": {

Gems/Atom/Tools/MaterialEditor/Assets/MaterialEditor/LightingPresets/_TEMPLATE_.lightingconfig.json.template

@@ -2,7 +2,6 @@
     "configurations": [
         {
             "displayName": "Substance: <template>",
-            "autoSelect": false,
             "iblSpecularImageFilePath": "materialeditor/lightingpresets/_Substance_/<latlong_image>_iblskyboxcm_iblspecular.exr.streamingimage",
             "iblDiffuseImageFilePath": "materialeditor/lightingpresets/_Substance_/<latlong_image>_iblskyboxcm_ibldiffuse.exr.streamingimage",
             "skyboxFilePath": "materialeditor/lightingpresets/_Substance_/<latlong_image>_iblskyboxcm.exr.streamingimage",
@@ -45,7 +44,6 @@
         },
         {
             "displayName": "Substance: <template> (Alt)",
-            "autoSelect": false,
             "iblSpecularImageFilePath": "materialeditor/lightingpresets/_Substance_/<latlong_image>_iblskyboxcm_iblspecular.exr.streamingimage",
             "iblDiffuseImageFilePath": "materialeditor/lightingpresets/_Substance_/<latlong_image>_iblskyboxcm_ibldiffuse.exr.streamingimage",
             "skyboxFilePath": "materialeditor/lightingpresets/_Substance_/<latlong_image>_iblskyboxcm_ibldiffuse.exr.streamingimage",

Gems/Atom/Tools/MaterialEditor/Assets/MaterialEditor/LightingPresets/neutral_urban.lightingpreset.azasset

@@ -3,7 +3,6 @@
     "Version": 1,
     "ClassName": "AZ::Render::LightingPreset",
     "ClassData": {
-        "autoSelect": true,
         "displayName": "Neutral Urban",
         "iblDiffuseImageAsset": {
             "assetId": {

Gems/Atom/Tools/MaterialEditor/Assets/MaterialEditor/ViewportModels/Shaderball.modelpreset.azasset

@@ -3,7 +3,6 @@
     "Version": 1,
     "ClassName": "AZ::Render::ModelPreset",
     "ClassData": {
-        "autoSelect": true,
         "displayName": "Shader Ball",
         "modelAsset": {
             "assetId": {

Gems/Atom/Tools/MaterialEditor/Code/Source/Viewport/MaterialViewportComponent.cpp

@@ -278,7 +278,7 @@ namespace MaterialEditor
 
         MaterialViewportNotificationBus::Broadcast(&MaterialViewportNotificationBus::Events::OnLightingPresetAdded, presetPtr);
 
-        if (preset.m_autoSelect || m_lightingPresetVector.size() == 1)
+        if (m_lightingPresetVector.size() == 1)
         {
             SelectLightingPreset(presetPtr);
         }
@@ -373,7 +373,7 @@ namespace MaterialEditor
 
         MaterialViewportNotificationBus::Broadcast(&MaterialViewportNotificationBus::Events::OnModelPresetAdded, presetPtr);
 
-        if (preset.m_autoSelect || m_modelPresetVector.size() == 1)
+        if (m_modelPresetVector.size() == 1)
         {
             SelectModelPreset(presetPtr);
         }
@@ -510,6 +510,13 @@ namespace MaterialEditor
 
     void MaterialViewportComponent::OnCatalogLoaded([[maybe_unused]] const char* catalogFile)
     {
-        AZ::TickBus::QueueFunction([this]() { ReloadContent(); });
+        AZ::TickBus::QueueFunction([this]() {
+            ReloadContent();
+
+            // Automatically select preferred default presets if they exist
+            // We will later data drive this with editor settings
+            SelectLightingPresetByName("Neutral Urban");
+            SelectModelPresetByName("Shader Ball");
+        });
     }
 }

Gems/Atom/Tools/MaterialEditor/Code/Source/Window/MaterialBrowserWidget.cpp

@@ -10,36 +10,32 @@
 *
 */
 
-#include <AzQtComponents/Utilities/DesktopUtilities.h>
-
-#include <AzToolsFramework/AssetBrowser/AssetBrowserModel.h>
-#include <AzToolsFramework/AssetBrowser/AssetBrowserFilterModel.h>
-#include <AzToolsFramework/AssetBrowser/Views/AssetBrowserTreeView.h>
-#include <AzToolsFramework/AssetBrowser/AssetBrowserEntry.h>
-#include <AzToolsFramework/AssetBrowser/Search/Filter.h>
-#include <AzToolsFramework/AssetBrowser/AssetSelectionModel.h>
-#include <AzToolsFramework/AssetBrowser/AssetBrowserBus.h>
-
-#include <Atom/RPI.Reflect/Material/MaterialAsset.h>
-#include <Atom/RPI.Reflect/Image/StreamingImageAsset.h>
-
-#include <Atom/Document/MaterialDocumentSystemRequestBus.h>
 #include <Atom/Document/MaterialDocumentRequestBus.h>
+#include <Atom/Document/MaterialDocumentSystemRequestBus.h>
+#include <Atom/RPI.Reflect/Image/StreamingImageAsset.h>
+#include <Atom/RPI.Reflect/Material/MaterialAsset.h>
+#include <AzQtComponents/Utilities/DesktopUtilities.h>
+#include <AzToolsFramework/AssetBrowser/AssetBrowserBus.h>
+#include <AzToolsFramework/AssetBrowser/AssetBrowserEntry.h>
+#include <AzToolsFramework/AssetBrowser/AssetBrowserFilterModel.h>
+#include <AzToolsFramework/AssetBrowser/AssetBrowserModel.h>
+#include <AzToolsFramework/AssetBrowser/AssetSelectionModel.h>
+#include <AzToolsFramework/AssetBrowser/Search/Filter.h>
+#include <AzToolsFramework/AssetBrowser/Views/AssetBrowserTreeView.h>
 
 #include <Source/Window/MaterialBrowserWidget.h>
-
 #include <Source/Window/ui_MaterialBrowserWidget.h>
 
 AZ_PUSH_DISABLE_WARNING(4251 4800, "-Wunknown-warning-option") // disable warnings spawned by QT
-#include <QDesktopServices>
-#include <QUrl>
-#include <QMessageBox>
-#include <QMenu>
 #include <QAction>
-#include <QCursor>
-#include <QPushButton>
-#include <QList>
 #include <QByteArray>
+#include <QCursor>
+#include <QDesktopServices>
+#include <QList>
+#include <QMenu>
+#include <QMessageBox>
+#include <QPushButton>
+#include <QUrl>
 AZ_POP_DISABLE_WARNING
 
 namespace MaterialEditor
@@ -73,7 +69,7 @@ namespace MaterialEditor
         m_filterModel->SetFilter(CreateFilter());
 
         m_ui->m_assetBrowserTreeViewWidget->setModel(m_filterModel);
-        m_ui->m_assetBrowserTreeViewWidget->SetShowSourceControlIcons(true);
+        m_ui->m_assetBrowserTreeViewWidget->SetShowSourceControlIcons(false);
         m_ui->m_assetBrowserTreeViewWidget->setSelectionMode(QAbstractItemView::SelectionMode::ExtendedSelection);
 
         // Maintains the tree expansion state between runs
@@ -99,7 +95,6 @@ namespace MaterialEditor
             }
         });
 
-        AssetBrowserModelNotificationBus::Handler::BusConnect();
         MaterialDocumentNotificationBus::Handler::BusConnect();
     }
 
@@ -108,7 +103,7 @@ namespace MaterialEditor
         // Maintains the tree expansion state between runs
         m_ui->m_assetBrowserTreeViewWidget->SaveState();
         MaterialDocumentNotificationBus::Handler::BusDisconnect();
-        AssetBrowserModelNotificationBus::Handler::BusDisconnect();
+        AZ::TickBus::Handler::BusDisconnect();
     }
 
     AzToolsFramework::AssetBrowser::FilterConstType MaterialBrowserWidget::CreateFilter() const
@@ -151,72 +146,65 @@ namespace MaterialEditor
 
         for (const AssetBrowserEntry* entry : entries)
         {
-            const SourceAssetBrowserEntry* sourceEntry = azrtti_cast<const SourceAssetBrowserEntry*>(entry);
-            if (!sourceEntry)
+            if (entry)
             {
-                const ProductAssetBrowserEntry* productEntry = azrtti_cast<const ProductAssetBrowserEntry*>(entry);
-                if (productEntry)
+                if (AzFramework::StringFunc::Path::IsExtension(entry->GetFullPath().c_str(), MaterialExtension))
                 {
-                    sourceEntry = azrtti_cast<const SourceAssetBrowserEntry*>(productEntry->GetParent());
+                    MaterialDocumentSystemRequestBus::Broadcast(&MaterialDocumentSystemRequestBus::Events::OpenDocument, entry->GetFullPath());
                 }
-            }
-
-            if (sourceEntry)
-            {
-                if (AzFramework::StringFunc::Path::IsExtension(sourceEntry->GetFullPath().c_str(), MaterialExtension))
-                {
-                    MaterialDocumentSystemRequestBus::Broadcast(&MaterialDocumentSystemRequestBus::Events::OpenDocument, sourceEntry->GetFullPath());
-                }
-                else if (AzFramework::StringFunc::Path::IsExtension(sourceEntry->GetFullPath().c_str(), MaterialTypeExtension))
+                else if (AzFramework::StringFunc::Path::IsExtension(entry->GetFullPath().c_str(), MaterialTypeExtension))
                 {
                     //ignore MaterialTypeExtension
                 }
                 else
                 {
-                    QDesktopServices::openUrl(QUrl::fromLocalFile(sourceEntry->GetFullPath().c_str()));
+                    QDesktopServices::openUrl(QUrl::fromLocalFile(entry->GetFullPath().c_str()));
                 }
             }
         }
     }
 
-    void MaterialBrowserWidget::EntryAdded(const AssetBrowserEntry* entry)
-    {
-        if (m_pathToSelect.empty())
-        {
-            return;
-        }
-
-        const SourceAssetBrowserEntry* sourceEntry = azrtti_cast<const SourceAssetBrowserEntry*>(entry);
-        if (!sourceEntry)
-        {
-            const ProductAssetBrowserEntry* productEntry = azrtti_cast<const ProductAssetBrowserEntry*>(entry);
-            if (productEntry)
-            {
-                sourceEntry = azrtti_cast<const SourceAssetBrowserEntry*>(productEntry->GetParent());
-            }
-        }
-
-        if (sourceEntry)
-        {
-            AZStd::string sourcePath = sourceEntry->GetFullPath();
-            AzFramework::StringFunc::Path::Normalize(sourcePath);
-            if (m_pathToSelect == sourcePath)
-            {
-                m_ui->m_assetBrowserTreeViewWidget->SelectFileAtPath(m_pathToSelect);
-                m_pathToSelect.clear();
-            }
-        }
-    }
-
     void MaterialBrowserWidget::OnDocumentOpened(const AZ::Uuid& documentId)
     {
         AZStd::string absolutePath;
         MaterialDocumentRequestBus::EventResult(absolutePath, documentId, &MaterialDocumentRequestBus::Events::GetAbsolutePath);
         if (!absolutePath.empty())
         {
+            // Selecting a new asset in the browser is not guaranteed to happen immediately.
+            // The asset browser model notifications are sent before the model is updated.
+            // Instead of relying on the notifications, queue the selection and process it on tick until this change occurs.
             m_pathToSelect = absolutePath;
             AzFramework::StringFunc::Path::Normalize(m_pathToSelect);
-            m_ui->m_assetBrowserTreeViewWidget->SelectFileAtPath(m_pathToSelect);
+            AZ::TickBus::Handler::BusConnect();
+        }
+    }
+
+    void MaterialBrowserWidget::OnTick(float deltaTime, AZ::ScriptTimePoint time)
+    {
+        AZ_UNUSED(time);
+        AZ_UNUSED(deltaTime);
+
+        if (!m_pathToSelect.empty())
+        {
+            // Attempt to select the new path
+            AzToolsFramework::AssetBrowser::AssetBrowserViewRequestBus::Broadcast(
+                &AzToolsFramework::AssetBrowser::AssetBrowserViewRequestBus::Events::SelectFileAtPath, m_pathToSelect);
+
+            // Iterate over the selected entries to verify if the selection was made 
+            for (const AssetBrowserEntry* entry : m_ui->m_assetBrowserTreeViewWidget->GetSelectedAssets())
+            {
+                if (entry)
+                {
+                    AZStd::string sourcePath = entry->GetFullPath();
+                    AzFramework::StringFunc::Path::Normalize(sourcePath);
+                    if (m_pathToSelect == sourcePath)
+                    {
+                        // Once the selection is confirmed, cancel the operation and disconnect
+                        AZ::TickBus::Handler::BusDisconnect();
+                        m_pathToSelect.clear();
+                    }
+                }
+            }
         }
     }
 

Gems/Atom/Tools/MaterialEditor/Code/Source/Window/MaterialBrowserWidget.h

@@ -13,11 +13,11 @@
 #pragma once
 
 #if !defined(Q_MOC_RUN)
+#include <Atom/Document/MaterialDocumentNotificationBus.h>
+#include <AzCore/Component/TickBus.h>
 #include <AzToolsFramework/AssetBrowser/AssetBrowserBus.h>
-#include <AzToolsFramework/AssetBrowser/Search/Filter.h>
 #include <AzToolsFramework/AssetBrowser/Entries/AssetBrowserEntry.h>
 #include <AzToolsFramework/AssetBrowser/Search/Filter.h>
-#include <Atom/Document/MaterialDocumentNotificationBus.h>
 
 AZ_PUSH_DISABLE_WARNING(4251 4800, "-Wunknown-warning-option") // disable warnings spawned by QT
 #include <QWidget>
@@ -26,8 +26,6 @@ AZ_POP_DISABLE_WARNING
 
 #endif
 
-
-
 namespace AzToolsFramework
 {
     namespace AssetBrowser
@@ -50,8 +48,8 @@ namespace MaterialEditor
     //! Provides a tree view of all available materials and other assets exposed by the MaterialEditor.
     class MaterialBrowserWidget
         : public QWidget
-        , public AzToolsFramework::AssetBrowser::AssetBrowserModelNotificationBus::Handler
-        , public MaterialDocumentNotificationBus::Handler
+        , protected AZ::TickBus::Handler
+        , protected MaterialDocumentNotificationBus::Handler
     {
         Q_OBJECT
     public:
@@ -62,20 +60,20 @@ namespace MaterialEditor
         AzToolsFramework::AssetBrowser::FilterConstType CreateFilter() const;
         void OpenSelectedEntries();
 
+        // MaterialDocumentNotificationBus::Handler implementation
+        void OnDocumentOpened(const AZ::Uuid& documentId) override;
+
+        // AZ::TickBus::Handler
+        void OnTick(float deltaTime, AZ::ScriptTimePoint time) override;
+
+        void OpenOptionsMenu();
+
         QScopedPointer<Ui::MaterialBrowserWidget> m_ui;
         AzToolsFramework::AssetBrowser::AssetBrowserFilterModel* m_filterModel = nullptr;
 
         //! if new asset is being created with this path it will automatically be selected
         AZStd::string m_pathToSelect;
 
-        // AssetBrowserModelNotificationBus::Handler implementation
-        void EntryAdded(const AzToolsFramework::AssetBrowser::AssetBrowserEntry* entry) override;
-
-        // MaterialDocumentNotificationBus::Handler implementation
-        void OnDocumentOpened(const AZ::Uuid& documentId) override;
-
-        void OpenOptionsMenu();
-
         QByteArray m_materialBrowserState;
     };
 } // namespace MaterialEditor

Gems/AtomLyIntegration/CommonFeatures/Assets/EnvHDRi/photo_studio_01.lightingconfig.json

@@ -1,7 +1,6 @@
 {
     "configurations": [
         {
-            "autoSelect": false,
             "displayName": "Photo Studio 01",
             "skyboxImageAsset": {
                 "assetId": {
@@ -64,7 +63,6 @@
             "shadowCatcherOpacity": 0.25
         },
         {
-            "autoSelect": false,
             "displayName": "Photo Studio 01 (Alt)",
             "skyboxImageAsset": {
                 "assetId": {

Gems/Blast/Code/Source/BlastModule.cpp

@@ -69,4 +69,4 @@ namespace Blast
 // DO NOT MODIFY THIS LINE UNLESS YOU RENAME THE GEM
 // The first parameter should be GemName_GemIdLower
 // The second should be the fully qualified name of the class above
-AZ_DECLARE_MODULE_CLASS(Blast_414bd211c99d4f74aef3a266b9ca208c, Blast::BlastModule)
+AZ_DECLARE_MODULE_CLASS(Gem_Blast, Blast::BlastModule)

Gems/Blast/Code/Source/BlastModuleUnsupported.cpp

@@ -14,4 +14,4 @@
 // DO NOT MODIFY THIS LINE UNLESS YOU RENAME THE GEM
 // The first parameter should be GemName_GemIdLower
 // The second should be the fully qualified name of the class above
-AZ_DECLARE_MODULE_CLASS(Blast_414bd211c99d4f74aef3a266b9ca208c, AZ::Module)
+AZ_DECLARE_MODULE_CLASS(Gem_Blast, AZ::Module)

Gems/Blast/Editor/Scripts/bootstrap.py

@@ -9,5 +9,5 @@ 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.
 """
 
-import asset_builder_blast
-
+# LYN-652 to re-enable the next line
+# import asset_builder_blast

Gems/EMotionFX/Code/EMotionFX/Source/KeyTrackLinearDynamic.h

@@ -229,7 +229,7 @@ namespace EMotionFX
         void MakeLoopable(float fadeTime = 0.3f);
 
         /**
-         * Optimize the keytrack by removing redundent frames.
+         * Optimize the keytrack by removing redundant frames.
          * The way this is done is by comparing differences between the resulting curves when removing specific keyframes.
          * If the error (difference) between those curve before and after keyframe removal is within a given maximum error value, the keyframe can be
          * safely removed since there will not be much "visual" difference.

Gems/EMotionFX/Code/Source/Integration/Components/AnimGraphComponent.cpp

@@ -346,13 +346,20 @@ namespace EMotionFX
 
         void AnimGraphComponent::CreateSnapshot(bool isAuthoritative)
         {
-            AZ_Error("EMotionFX", m_animGraphInstance, "Call create snapshot function only when anim graph is ready in this component.");
-            m_animGraphInstance->CreateSnapshot(isAuthoritative);
-            m_animGraphInstance->OnNetworkConnected();
+            if (m_animGraphInstance)
+            {
+                m_animGraphInstance->CreateSnapshot(isAuthoritative);
+                m_animGraphInstance->OnNetworkConnected();
 
-            // This will stop the MCore Job schedule update the actor instance and anim graph for authoritative entity.
-            // After doing so, we will have to update this actor manuelly in the networking update.
-            m_animGraphInstance->GetActorInstance()->SetIsEnabled(!isAuthoritative);
+                // This will stop the MCore Job schedule update the actor instance and anim graph for authoritative entity.
+                // After doing so, we will have to update this actor manually in the networking update.
+                m_animGraphInstance->GetActorInstance()->SetIsEnabled(!isAuthoritative);
+            }
+            else
+            {
+                AZ_Error("EMotionFX", false, "Cannot create snapshot as anim graph instance has not been created yet. "
+                    "Please make sure you selected an anim graph in the anim graph component.");
+            }
         }
 
         void AnimGraphComponent::SetActiveStates(const AZStd::vector<AZ::u32>& activeStates)

Gems/GraphCanvas/Code/Source/Widgets/GraphCanvasLabel.cpp

@@ -437,5 +437,7 @@ namespace GraphCanvas
         default:
             return QGraphicsWidget::sizeHint(which, constraint);
         }
+
+        return QGraphicsWidget::sizeHint(which, constraint);
     }
 }

Gems/PythonAssetBuilder/Editor/Scripts/scene_api/scene_data.py

@@ -114,12 +114,17 @@ class SceneManifest():
     def mesh_group_unselect_node(self, meshGroup, nodeName):
         meshGroup['nodeSelectionList']['unselectedNodes'].append(nodeName)
 
-    def mesh_group_set_origin(self, meshGroup, originNodeName, x, y, z, scale):
+    def mesh_group_add_advanced_coordinate_system(self, meshGroup, originNodeName, translation, rotation, scale):
         originRule =  {}
-        originRule['$type'] = 'OriginRule'
-        originRule['originNodeName'] = 'World' if originNodeName is None else originNodeName
-        originRule['translation'] = [x, y, z]
-        originRule['scale'] = scale
+        originRule['$type'] = 'CoordinateSystemRule'
+        originRule['useAdvancedData'] = True
+        originRule['originNodeName'] = '' if originNodeName is None else originNodeName
+        if translation is not None:
+            originRule['translation'] = translation
+        if rotation is not None:
+            originRule['rotation'] = rotation
+        if scale != 1.0:
+            originRule['scale'] = scale
         meshGroup['rules']['rules'].append(originRule)
 
     def mesh_group_add_comment(self, meshGroup, comment):

Gems/ScriptCanvas/Code/Editor/Components/EditorGraph.cpp

@@ -2347,7 +2347,7 @@ namespace ScriptCanvasEditor
         AZ::Outcome<ScriptCanvas::VariableId, AZStd::string> addOutcome;
 
         // #functions2 slot<->variable re-use the activeDatum, send the pointer (actually, all of the source slot information, and make a special conversion)
-        ScriptCanvas::GraphVariableManagerRequestBus::EventResult(addOutcome, GetScriptCanvasId(), &ScriptCanvas::GraphVariableManagerRequests::AddVariable, variableName, variableDatum);
+        ScriptCanvas::GraphVariableManagerRequestBus::EventResult(addOutcome, GetScriptCanvasId(), &ScriptCanvas::GraphVariableManagerRequests::AddVariable, variableName, variableDatum, true);
 
         if (addOutcome.IsSuccess())
         {

Gems/ScriptCanvas/Code/Editor/Model/EntityMimeDataHandler.cpp

@@ -172,7 +172,7 @@ namespace ScriptCanvasEditor
                     {
                         ScriptCanvas::Datum datum = ScriptCanvas::Datum(entityId);
 
-                        AZ::Outcome<ScriptCanvas::VariableId, AZStd::string > addVariableOutcome = variableManagerRequests->AddVariable(variableName, datum);
+                        AZ::Outcome<ScriptCanvas::VariableId, AZStd::string > addVariableOutcome = variableManagerRequests->AddVariable(variableName, datum, false);
 
                         if (addVariableOutcome.IsSuccess())
                         {

Gems/ScriptCanvas/Code/Editor/View/Widgets/NodePalette/NodePaletteModel.cpp

@@ -578,6 +578,14 @@ namespace
                     categoryPath.append(displayName.c_str());
                 }
 
+                for (auto property : behaviorClass->m_properties)
+                {
+                    if (property.second->m_setter)
+                    {
+                        RegisterMethod(nodePaletteModel, behaviorContext, categoryPath, behaviorClass, property.first, *property.second->m_setter, behaviorClass->IsMethodOverloaded(property.first));
+                    }
+                }
+
                 for (auto methodIter : behaviorClass->m_methods)
                 {
                     if (!IsExplicitOverload(*methodIter.second))

Gems/ScriptCanvas/Code/Editor/View/Widgets/ValidationPanel/GraphValidationDockWidget.cpp

@@ -1011,7 +1011,7 @@ namespace ScriptCanvasEditor
             ScriptCanvas::Datum datum(variableType, ScriptCanvas::Datum::eOriginality::Original);
 
             AZ::Outcome<ScriptCanvas::VariableId, AZStd::string> outcome = AZ::Failure(AZStd::string());
-            ScriptCanvas::GraphVariableManagerRequestBus::EventResult(outcome, m_activeGraphIds.scriptCanvasId, &ScriptCanvas::GraphVariableManagerRequests::AddVariable, varName, datum);
+            ScriptCanvas::GraphVariableManagerRequestBus::EventResult(outcome, m_activeGraphIds.scriptCanvasId, &ScriptCanvas::GraphVariableManagerRequests::AddVariable, varName, datum, false);
 
             if (outcome.IsSuccess())
             {

Gems/ScriptCanvas/Code/Editor/View/Widgets/VariablePanel/GraphVariablesTableView.cpp

@@ -41,6 +41,7 @@
 #include <ScriptCanvas/Bus/EditorScriptCanvasBus.h>
 
 #include <AzToolsFramework/API/ToolsApplicationAPI.h>
+#include <ScriptCanvas/Variable/GraphVariable.h>
 
 namespace ScriptCanvasEditor
 {
@@ -538,7 +539,24 @@ namespace ScriptCanvasEditor
             }
             else if (index.column() == ColumnIndex::Scope)
             {
-                // Scope is not changed by users
+                ScriptCanvas::GraphVariable* graphVariable = nullptr;
+                ScriptCanvas::GraphVariableManagerRequestBus::EventResult(graphVariable, m_scriptCanvasId, &ScriptCanvas::GraphVariableManagerRequests::FindVariableById, varId.m_identifier);
+
+                if (graphVariable)
+                {
+                    QString comboBoxValue = value.toString();
+
+                    if (!comboBoxValue.isEmpty())
+                    {
+                        AZStd::string scopeLabel = ScriptCanvas::VariableFlags::GetScopeDisplayLabel(graphVariable->GetScope());
+                        if (scopeLabel.compare(comboBoxValue.toUtf8().data()) != 0)
+                        {
+                            modifiedData = true;
+                            graphVariable->SetScope(ScriptCanvas::VariableFlags::GetScopeFromLabel(comboBoxValue.toUtf8().data()));
+                            AzToolsFramework::PropertyEditorGUIMessages::Bus::Broadcast(&AzToolsFramework::PropertyEditorGUIMessages::RequestRefresh, AzToolsFramework::Refresh_EntireTree);
+                        }
+                    }
+                }
             }
             else if (index.column() == ColumnIndex::InitialValueSource)
             {
@@ -607,8 +625,17 @@ namespace ScriptCanvasEditor
         }
         else if (index.column() == ColumnIndex::Scope)
         {
+            ScriptCanvas::GraphScopedVariableId varId = FindScopedVariableIdForIndex(index);
+
+            ScriptCanvas::GraphVariable* graphVariable = nullptr;
+            ScriptCanvas::GraphVariableManagerRequestBus::EventResult(graphVariable, m_scriptCanvasId, &ScriptCanvas::GraphVariableManagerRequests::FindVariableById, varId.m_identifier);
+
+            if (graphVariable->GetScope() != ScriptCanvas::VariableFlags::Scope::FunctionReadOnly)
+            {
             itemFlags |= Qt::ItemIsEditable;
         }
+
+        }
         else if (index.column() == ColumnIndex::InitialValueSource)
         {
             itemFlags |= Qt::ItemIsEditable;

Gems/ScriptCanvas/Code/Editor/View/Widgets/VariablePanel/SlotTypeSelectorWidget.cpp

@@ -73,6 +73,8 @@ namespace ScriptCanvasEditor
     {
         ui->setupUi(this);
 
+        ui->variablePalette->SetActiveScene(scriptCanvasId);
+
         ui->searchFilter->setClearButtonEnabled(true);
         QObject::connect(ui->searchFilter, &QLineEdit::textChanged, this, &SlotTypeSelectorWidget::OnQuickFilterChanged);
         QObject::connect(ui->slotName, &QLineEdit::returnPressed, this, &SlotTypeSelectorWidget::OnReturnPressed);

Gems/ScriptCanvas/Code/Editor/View/Widgets/VariablePanel/VariableDockWidget.cpp

@@ -812,7 +812,7 @@ namespace ScriptCanvasEditor
         ScriptCanvas::Datum datum(varType, ScriptCanvas::Datum::eOriginality::Original);
 
         AZ::Outcome<ScriptCanvas::VariableId, AZStd::string> outcome = AZ::Failure(AZStd::string());
-        ScriptCanvas::GraphVariableManagerRequestBus::EventResult(outcome, m_scriptCanvasId, &ScriptCanvas::GraphVariableManagerRequests::AddVariable, variableName, datum);
+        ScriptCanvas::GraphVariableManagerRequestBus::EventResult(outcome, m_scriptCanvasId, &ScriptCanvas::GraphVariableManagerRequests::AddVariable, variableName, datum, false);
 
         AZ_Warning("VariablePanel", outcome.IsSuccess(), "Could not create new variable: %s", outcome.GetError().c_str());
         GeneralRequestBus::Broadcast(&GeneralRequests::PostUndoPoint, m_scriptCanvasId);

Gems/ScriptCanvas/Code/Include/ScriptCanvas/Utils/NodeUtils.cpp

@@ -81,6 +81,8 @@ namespace ScriptCanvas
         {
             return ConstructCustomNodeIdentifier(scriptCanvasNode->RTTI_GetType());
         }
+
+        return NodeTypeIdentifier(0);
     }
 
     NodeTypeIdentifier NodeUtils::ConstructEBusIdentifier(ScriptCanvas::EBusBusId ebusIdentifier)

Gems/ScriptCanvas/Code/Include/ScriptCanvas/Variable/GraphVariable.cpp

@@ -43,20 +43,12 @@ namespace ScriptCanvas
     {
         const char* GetScopeDisplayLabel(Scope scopeType)
         {
-            switch (scopeType)
-            {
-            case Scope::Graph:
-                return "Graph";
-            case Scope::Function:
-                return "Function";
-            default:
-                return "?";
-            }
+            return GraphVariable::s_ScopeNames[static_cast<int>(scopeType)];
         }
 
         Scope GetScopeFromLabel(const char* label)
         {
-            if (strcmp("Function", label) == 0)
+            if (strcmp(GraphVariable::s_ScopeNames[static_cast<int>(VariableFlags::Scope::Function)], label) == 0)
             {
                 return Scope::Function;
             }
@@ -71,6 +63,7 @@ namespace ScriptCanvas
             case Scope::Graph:
                 return "Variable is accessible in the entire graph.";
             case Scope::Function:
+            case Scope::FunctionReadOnly:
                 return "Variable is accessible only in the execution path of the function that defined it";
             default:
                 return "?";
@@ -162,6 +155,14 @@ namespace ScriptCanvas
         "From Component"
     };
 
+    const char* GraphVariable::s_ScopeNames[static_cast<int>(VariableFlags::Scope::COUNT)] =
+    {
+        "Graph",
+        "Function",
+        "Function",
+    };
+
+
     void GraphVariable::Reflect(AZ::ReflectContext* context)
     {
         if (auto serializeContext = azrtti_cast<AZ::SerializeContext*>(context))
@@ -197,6 +198,13 @@ namespace ScriptCanvas
                     return choices;
                 };
 
+                auto scopeChoices = [] {
+                    AZStd::vector< AZStd::pair<VariableFlags::Scope, AZStd::string>> choices;
+                    choices.emplace_back(AZStd::make_pair(VariableFlags::Scope::Graph, s_ScopeNames[0]));
+                    choices.emplace_back(AZStd::make_pair(VariableFlags::Scope::Function, s_ScopeNames[1]));
+                    return choices;
+                };
+
                 editContext->Class<GraphVariable>("Variable", "Represents a Variable field within a Script Canvas Graph")
                     ->ClassElement(AZ::Edit::ClassElements::EditorData, "")
                     ->Attribute(AZ::Edit::Attributes::Visibility, &GraphVariable::GetVisibility)
@@ -215,8 +223,8 @@ namespace ScriptCanvas
                     ->Attribute(AZ::Edit::Attributes::ChangeNotify, &GraphVariable::OnValueChanged)
 
                     ->DataElement(AZ::Edit::UIHandlers::ComboBox, &GraphVariable::m_scope, "Scope", "Controls the scope of this variable. i.e. If this is exposed as input to this script, or output from this script, or if the variable is just locally scoped.")
-                    ->Attribute(AZ::Edit::Attributes::Visibility, &GraphVariable::GetInputControlVisibility)
-                    ->Attribute(AZ::Edit::Attributes::GenericValueList, &GraphVariable::GetScopes)
+                    ->Attribute(AZ::Edit::Attributes::Visibility, &GraphVariable::GetScopeControlVisibility)
+                    ->Attribute(AZ::Edit::Attributes::GenericValueList, scopeChoices)
                     ->Attribute(AZ::Edit::Attributes::ChangeNotify, &GraphVariable::OnScopeTypedChanged)
 
                     ->DataElement(AZ::Edit::UIHandlers::Default, &GraphVariable::m_networkProperties, "Network Properties", "Enables whether or not this value should be network synchronized")
@@ -382,6 +390,16 @@ namespace ScriptCanvas
         m_inputControlVisibility = inputControlVisibility;
     }
 
+    AZ::Crc32 GraphVariable::GetScopeControlVisibility() const
+    {
+        if (m_scope == VariableFlags::Scope::FunctionReadOnly)
+        {
+            return AZ::Edit::PropertyVisibility::Hide;
+        }
+
+        return GetInputControlVisibility();
+    }
+
     AZ::Crc32 GraphVariable::GetInputControlVisibility() const
     {
         return m_inputControlVisibility;
@@ -462,6 +480,8 @@ namespace ScriptCanvas
             return m_scope == VariableFlags::Scope::Graph;
             // All graph variables are in function local scope
         case VariableFlags::Scope::Function:
+        case VariableFlags::Scope::FunctionReadOnly:
+
             return true;
         }
 

Gems/ScriptCanvas/Code/Include/ScriptCanvas/Variable/GraphVariable.h

@@ -52,8 +52,10 @@ namespace ScriptCanvas
 
         enum class Scope : AZ::u8
         {
-            Graph = 0,
-            Function = 1,
+            Graph,
+            Function,
+            FunctionReadOnly,
+            COUNT
         };
 
         enum InitialValueSource : AZ::u8
@@ -142,6 +144,7 @@ namespace ScriptCanvas
         void SetScriptInputControlVisibility(const AZ::Crc32& inputControlVisibility);
 
         AZ::Crc32 GetInputControlVisibility() const;
+        AZ::Crc32 GetScopeControlVisibility() const;
         AZ::Crc32 GetScriptInputControlVisibility() const;
         AZ::Crc32 GetNetworkSettingsVisibility() const;
         AZ::Crc32 GetFunctionInputControlVisibility() const;
@@ -181,6 +184,7 @@ namespace ScriptCanvas
         int GetSortPriority() const;
 
         static const char* s_InitialValueSourceNames[VariableFlags::InitialValueSource::COUNT];
+        static const char* s_ScopeNames[static_cast<int>(VariableFlags::Scope::COUNT)];
 
     private:
 

Gems/ScriptCanvas/Code/Include/ScriptCanvas/Variable/GraphVariableManagerComponent.cpp

@@ -225,7 +225,7 @@ namespace ScriptCanvas
     }
 
     // #functions2 slot<->variable add this to the graph, using the old datum
-    AZ::Outcome<VariableId, AZStd::string> GraphVariableManagerComponent::AddVariable(AZStd::string_view name, const Datum& value)
+    AZ::Outcome<VariableId, AZStd::string> GraphVariableManagerComponent::AddVariable(AZStd::string_view name, const Datum& value, bool functionScope)
     {
         if (FindVariable(name))
         {
@@ -245,6 +245,10 @@ namespace ScriptCanvas
 
         GraphVariable* variable = m_variableData.FindVariable(newId);
         variable->SetOwningScriptCanvasId(GetScriptCanvasId());
+        if (functionScope)
+        {
+            variable->SetScope(VariableFlags::Scope::FunctionReadOnly);
+        }
 
         VariableRequestBus::MultiHandler::BusConnect(GraphScopedVariableId(m_scriptCanvasId, newId));
         GraphVariableManagerNotificationBus::Event(GetScriptCanvasId(), &GraphVariableManagerNotifications::OnVariableAddedToGraph, newId, name);
@@ -254,7 +258,7 @@ namespace ScriptCanvas
 
     AZ::Outcome<VariableId, AZStd::string> GraphVariableManagerComponent::AddVariablePair(const AZStd::pair<AZStd::string_view, Datum>& keyValuePair)
     {
-        return AddVariable(keyValuePair.first, keyValuePair.second);
+        return AddVariable(keyValuePair.first, keyValuePair.second, false);
     }
 
     VariableValidationOutcome GraphVariableManagerComponent::IsNameValid(AZStd::string_view varName)

Gems/ScriptCanvas/Code/Include/ScriptCanvas/Variable/GraphVariableManagerComponent.h

@@ -63,7 +63,7 @@ namespace ScriptCanvas
         //// GraphVariableManagerRequestBus
         AZ::Outcome<VariableId, AZStd::string> CloneVariable(const GraphVariable& variableConfiguration) override;
         AZ::Outcome<VariableId, AZStd::string> RemapVariable(const GraphVariable& variableConfiguration) override;
-        AZ::Outcome<VariableId, AZStd::string> AddVariable(AZStd::string_view name, const Datum& value) override;
+        AZ::Outcome<VariableId, AZStd::string> AddVariable(AZStd::string_view name, const Datum& value, bool functionScope) override;
         AZ::Outcome<VariableId, AZStd::string> AddVariablePair(const AZStd::pair<AZStd::string_view, Datum>& nameValuePair) override;
 
         VariableValidationOutcome IsNameValid(AZStd::string_view key) override;

Gems/ScriptCanvas/Code/Include/ScriptCanvas/Variable/VariableBus.h

@@ -90,7 +90,7 @@ namespace ScriptCanvas
         //! returns an AZ::Outcome which on success contains the VariableId and on Failure contains a string with error information
         virtual AZ::Outcome<VariableId, AZStd::string> CloneVariable(const GraphVariable& baseVariable) = 0;
         virtual AZ::Outcome<VariableId, AZStd::string> RemapVariable(const GraphVariable& variableConfiguration) = 0;
-        virtual AZ::Outcome<VariableId, AZStd::string> AddVariable(AZStd::string_view key, const Datum& value) = 0;
+        virtual AZ::Outcome<VariableId, AZStd::string> AddVariable(AZStd::string_view key, const Datum& value, bool functionScope) = 0;
         virtual AZ::Outcome<VariableId, AZStd::string> AddVariablePair(const AZStd::pair<AZStd::string_view, Datum>& keyValuePair) = 0;
 
         virtual VariableValidationOutcome IsNameValid(AZStd::string_view variableName) = 0;

Gems/ScriptCanvasDeveloper/Code/Editor/Source/AutomationActions/VariableListFullCreation.cpp

@@ -63,7 +63,7 @@ namespace ScriptCanvasDeveloperEditor
                 ScriptCanvas::Datum datum(dataType, ScriptCanvas::Datum::eOriginality::Original);
 
                 AZ::Outcome<ScriptCanvas::VariableId, AZStd::string> outcome = AZ::Failure(AZStd::string());
-                m_variableRequests->AddVariable(variableName, datum);
+                m_variableRequests->AddVariable(variableName, datum, false);
 
                 ++m_variableCounter;
             }

Gems/ScriptCanvasDeveloper/Code/Editor/Source/EditorAutomation/EditorAutomationActions/ScriptCanvasActions/VariableActions.cpp

@@ -144,7 +144,7 @@ namespace ScriptCanvasDeveloper
                 {
                     ScriptCanvasEditor::SceneCounterRequestBus::EventResult(variableCounter, m_scriptCanvasId, &ScriptCanvasEditor::SceneCounterRequests::GetNewVariableCounter);
 
-                    // Cribbed from VariableDockWidget. Shuld always be in sync with that.
+                    // From VariableDockWidget, Should always be in sync with that.
                     variableName = AZStd::string::format("Variable %u", variableCounter);
 
                     ScriptCanvas::GraphVariableManagerRequestBus::EventResult(nameAvailable, m_scriptCanvasId, &ScriptCanvas::GraphVariableManagerRequests::IsNameAvailable, variableName);
@@ -154,7 +154,7 @@ namespace ScriptCanvasDeveloper
             ScriptCanvas::Datum datum(m_dataType, ScriptCanvas::Datum::eOriginality::Original);
 
             AZ::Outcome<ScriptCanvas::VariableId, AZStd::string> outcome = AZ::Failure(AZStd::string());
-            ScriptCanvas::GraphVariableManagerRequestBus::EventResult(outcome, m_scriptCanvasId, &ScriptCanvas::GraphVariableManagerRequests::AddVariable, variableName, datum);
+            ScriptCanvas::GraphVariableManagerRequestBus::EventResult(outcome, m_scriptCanvasId, &ScriptCanvas::GraphVariableManagerRequests::AddVariable, variableName, datum, false);
 
             if (outcome)
             {

Gems/ScriptCanvasTesting/Code/Source/Framework/ScriptCanvasTestUtilities.h

@@ -96,7 +96,7 @@ namespace ScriptCanvasTests
     {
         using namespace ScriptCanvas;
         AZ::Outcome<VariableId, AZStd::string> addVariableOutcome = AZ::Failure(AZStd::string());
-        GraphVariableManagerRequestBus::EventResult(addVariableOutcome, scriptCanvasId, &GraphVariableManagerRequests::AddVariable, variableName, Datum(value));
+        GraphVariableManagerRequestBus::EventResult(addVariableOutcome, scriptCanvasId, &GraphVariableManagerRequests::AddVariable, variableName, Datum(value), false);
         if (!addVariableOutcome)
         {
             AZ_Warning("Script Canvas Test", false, "%s", addVariableOutcome.GetError().data());

Gems/ScriptCanvasTesting/Code/Tests/ScriptCanvas_Variables.cpp

@@ -104,27 +104,27 @@ TEST_F(ScriptCanvasTestFixture, CreateVariableTest)
         auto stringArrayDatum = Datum(StringArray());
 
         AZ::Outcome<VariableId, AZStd::string> addPropertyOutcome(AZ::Failure(AZStd::string("Uninitialized")));
-        GraphVariableManagerRequestBus::EventResult(addPropertyOutcome, scriptCanvasId, &GraphVariableManagerRequests::AddVariable, "FirstVector3", vector3Datum1);
+        GraphVariableManagerRequestBus::EventResult(addPropertyOutcome, scriptCanvasId, &GraphVariableManagerRequests::AddVariable, "FirstVector3", vector3Datum1, false);
         EXPECT_TRUE(addPropertyOutcome);
         EXPECT_TRUE(addPropertyOutcome.GetValue().IsValid());
 
         addPropertyOutcome = AZ::Failure(AZStd::string("Uninitialized"));
-        GraphVariableManagerRequestBus::EventResult(addPropertyOutcome, scriptCanvasId, &GraphVariableManagerRequests::AddVariable, "SecondVector3", vector3Datum2);
+        GraphVariableManagerRequestBus::EventResult(addPropertyOutcome, scriptCanvasId, &GraphVariableManagerRequests::AddVariable, "SecondVector3", vector3Datum2, false);
         EXPECT_TRUE(addPropertyOutcome);
         EXPECT_TRUE(addPropertyOutcome.GetValue().IsValid());
 
         addPropertyOutcome = AZ::Failure(AZStd::string("Uninitialized"));
-        GraphVariableManagerRequestBus::EventResult(addPropertyOutcome, scriptCanvasId, &GraphVariableManagerRequests::AddVariable, "FirstVector4", vector4Datum);
+        GraphVariableManagerRequestBus::EventResult(addPropertyOutcome, scriptCanvasId, &GraphVariableManagerRequests::AddVariable, "FirstVector4", vector4Datum, false);
         EXPECT_TRUE(addPropertyOutcome);
         EXPECT_TRUE(addPropertyOutcome.GetValue().IsValid());
 
         addPropertyOutcome = AZ::Failure(AZStd::string("Uninitialized"));
-        GraphVariableManagerRequestBus::EventResult(addPropertyOutcome, scriptCanvasId, &GraphVariableManagerRequests::AddVariable, "ProjectionMatrix", behaviorMatrix4x4Datum);
+        GraphVariableManagerRequestBus::EventResult(addPropertyOutcome, scriptCanvasId, &GraphVariableManagerRequests::AddVariable, "ProjectionMatrix", behaviorMatrix4x4Datum, false);
         EXPECT_TRUE(addPropertyOutcome);
         EXPECT_TRUE(addPropertyOutcome.GetValue().IsValid());
 
         addPropertyOutcome = AZ::Failure(AZStd::string("Uninitialized"));
-        GraphVariableManagerRequestBus::EventResult(addPropertyOutcome, scriptCanvasId, &GraphVariableManagerRequests::AddVariable, "My String Array", stringArrayDatum);
+        GraphVariableManagerRequestBus::EventResult(addPropertyOutcome, scriptCanvasId, &GraphVariableManagerRequests::AddVariable, "My String Array", stringArrayDatum, false);
         EXPECT_TRUE(addPropertyOutcome);
         EXPECT_TRUE(addPropertyOutcome.GetValue().IsValid());
 
@@ -169,12 +169,12 @@ TEST_F(ScriptCanvasTestFixture, AddVariableFailTest)
     const AZStd::string_view propertyName = "SameName";
 
     AZ::Outcome<VariableId, AZStd::string> addPropertyOutcome(AZ::Failure(AZStd::string("Uninitialized")));
-    GraphVariableManagerRequestBus::EventResult(addPropertyOutcome, scriptCanvasId, &GraphVariableManagerRequests::AddVariable, propertyName, vector3Datum1);
+    GraphVariableManagerRequestBus::EventResult(addPropertyOutcome, scriptCanvasId, &GraphVariableManagerRequests::AddVariable, propertyName, vector3Datum1, false);
     EXPECT_TRUE(addPropertyOutcome);
     EXPECT_TRUE(addPropertyOutcome.GetValue().IsValid());
 
     addPropertyOutcome = AZ::Failure(AZStd::string("Uninitialized"));
-    GraphVariableManagerRequestBus::EventResult(addPropertyOutcome, scriptCanvasId, &GraphVariableManagerRequests::AddVariable, propertyName, vector3Datum2);
+    GraphVariableManagerRequestBus::EventResult(addPropertyOutcome, scriptCanvasId, &GraphVariableManagerRequests::AddVariable, propertyName, vector3Datum2, false);
     EXPECT_FALSE(addPropertyOutcome);
 
     propertyEntity.reset();
@@ -208,35 +208,35 @@ TEST_F(ScriptCanvasTestFixture, RemoveVariableTest)
 
         size_t numVariablesAdded = 0U;
         AZ::Outcome<VariableId, AZStd::string> addPropertyOutcome(AZ::Failure(AZStd::string("Uninitialized")));
-        GraphVariableManagerRequestBus::EventResult(addPropertyOutcome, scriptCanvasId, &GraphVariableManagerRequests::AddVariable, "FirstVector3", vector3Datum1);
+        GraphVariableManagerRequestBus::EventResult(addPropertyOutcome, scriptCanvasId, &GraphVariableManagerRequests::AddVariable, "FirstVector3", vector3Datum1, false);
         EXPECT_TRUE(addPropertyOutcome);
         EXPECT_TRUE(addPropertyOutcome.GetValue().IsValid());
         const VariableId firstVector3Id = addPropertyOutcome.GetValue();
         ++numVariablesAdded;
 
         addPropertyOutcome = AZ::Failure(AZStd::string("Uninitialized"));
-        GraphVariableManagerRequestBus::EventResult(addPropertyOutcome, scriptCanvasId, &GraphVariableManagerRequests::AddVariable, "SecondVector3", vector3Datum2);
+        GraphVariableManagerRequestBus::EventResult(addPropertyOutcome, scriptCanvasId, &GraphVariableManagerRequests::AddVariable, "SecondVector3", vector3Datum2, false);
         EXPECT_TRUE(addPropertyOutcome);
         EXPECT_TRUE(addPropertyOutcome.GetValue().IsValid());
         const VariableId secondVector3Id = addPropertyOutcome.GetValue();
         ++numVariablesAdded;
 
         addPropertyOutcome = AZ::Failure(AZStd::string("Uninitialized"));
-        GraphVariableManagerRequestBus::EventResult(addPropertyOutcome, scriptCanvasId, &GraphVariableManagerRequests::AddVariable, "FirstVector4", vector4Datum);
+        GraphVariableManagerRequestBus::EventResult(addPropertyOutcome, scriptCanvasId, &GraphVariableManagerRequests::AddVariable, "FirstVector4", vector4Datum, false);
         EXPECT_TRUE(addPropertyOutcome);
         EXPECT_TRUE(addPropertyOutcome.GetValue().IsValid());
         const VariableId firstVector4Id = addPropertyOutcome.GetValue();
         ++numVariablesAdded;
 
         addPropertyOutcome = AZ::Failure(AZStd::string("Uninitialized"));
-        GraphVariableManagerRequestBus::EventResult(addPropertyOutcome, scriptCanvasId, &GraphVariableManagerRequests::AddVariable, "ProjectionMatrix", behaviorMatrix4x4Datum);
+        GraphVariableManagerRequestBus::EventResult(addPropertyOutcome, scriptCanvasId, &GraphVariableManagerRequests::AddVariable, "ProjectionMatrix", behaviorMatrix4x4Datum, false);
         EXPECT_TRUE(addPropertyOutcome);
         EXPECT_TRUE(addPropertyOutcome.GetValue().IsValid());
         const VariableId projectionMatrixId = addPropertyOutcome.GetValue();
         ++numVariablesAdded;
 
         addPropertyOutcome = AZ::Failure(AZStd::string("Uninitialized"));
-        GraphVariableManagerRequestBus::EventResult(addPropertyOutcome, scriptCanvasId, &GraphVariableManagerRequests::AddVariable, "My String Array", stringArrayDatum);
+        GraphVariableManagerRequestBus::EventResult(addPropertyOutcome, scriptCanvasId, &GraphVariableManagerRequests::AddVariable, "My String Array", stringArrayDatum, false);
         EXPECT_TRUE(addPropertyOutcome);
         EXPECT_TRUE(addPropertyOutcome.GetValue().IsValid());
         const VariableId stringArrayId = addPropertyOutcome.GetValue();
@@ -294,7 +294,7 @@ TEST_F(ScriptCanvasTestFixture, RemoveVariableTest)
         {
             // Re-add removed Property
             addPropertyOutcome = AZ::Failure(AZStd::string("Uninitialized"));
-            GraphVariableManagerRequestBus::EventResult(addPropertyOutcome, scriptCanvasId, &GraphVariableManagerRequests::AddVariable, "ProjectionMatrix", behaviorMatrix4x4Datum);
+            GraphVariableManagerRequestBus::EventResult(addPropertyOutcome, scriptCanvasId, &GraphVariableManagerRequests::AddVariable, "ProjectionMatrix", behaviorMatrix4x4Datum, false);
             EXPECT_TRUE(addPropertyOutcome);
             EXPECT_TRUE(addPropertyOutcome.GetValue().IsValid());
 
@@ -332,7 +332,7 @@ TEST_F(ScriptCanvasTestFixture, FindVariableTest)
     const AZStd::string_view propertyName = "StringProperty";
 
     AZ::Outcome<VariableId, AZStd::string> addPropertyOutcome(AZ::Failure(AZStd::string("Uninitialized")));
-    GraphVariableManagerRequestBus::EventResult(addPropertyOutcome, scriptCanvasId, &GraphVariableManagerRequests::AddVariable, propertyName, stringVariableDatum);
+    GraphVariableManagerRequestBus::EventResult(addPropertyOutcome, scriptCanvasId, &GraphVariableManagerRequests::AddVariable, propertyName, stringVariableDatum, false);
     EXPECT_TRUE(addPropertyOutcome);
     EXPECT_TRUE(addPropertyOutcome.GetValue().IsValid());
     const VariableId stringVariableId = addPropertyOutcome.GetValue();
@@ -391,7 +391,7 @@ TEST_F(ScriptCanvasTestFixture, ModifyVariableTest)
     const AZStd::string_view propertyName = "StringProperty";
 
     AZ::Outcome<VariableId, AZStd::string> addPropertyOutcome(AZ::Failure(AZStd::string("Uninitialized")));
-    GraphVariableManagerRequestBus::EventResult(addPropertyOutcome, scriptCanvasId, &GraphVariableManagerRequests::AddVariable, propertyName, stringVariableDatum);
+    GraphVariableManagerRequestBus::EventResult(addPropertyOutcome, scriptCanvasId, &GraphVariableManagerRequests::AddVariable, propertyName, stringVariableDatum, false);
     EXPECT_TRUE(addPropertyOutcome);
     EXPECT_TRUE(addPropertyOutcome.GetValue().IsValid());
     const VariableId stringVariableId = addPropertyOutcome.GetValue();
@@ -449,7 +449,7 @@ TEST_F(ScriptCanvasTestFixture, SerializationTest)
         auto stringArrayDatum = Datum(StringArray());
 
         AZ::Outcome<VariableId, AZStd::string> addPropertyOutcome(AZ::Failure(AZStd::string("Uninitialized")));
-        GraphVariableManagerRequestBus::EventResult(addPropertyOutcome, scriptCanvasId, &GraphVariableManagerRequests::AddVariable, "My String Array", stringArrayDatum);
+        GraphVariableManagerRequestBus::EventResult(addPropertyOutcome, scriptCanvasId, &GraphVariableManagerRequests::AddVariable, "My String Array", stringArrayDatum, false);
         EXPECT_TRUE(addPropertyOutcome);
         EXPECT_TRUE(addPropertyOutcome.GetValue().IsValid());
 
@@ -493,7 +493,7 @@ TEST_F(ScriptCanvasTestFixture, SerializationTest)
 
         auto identityMatrixDatum = Datum(Data::Matrix3x3Type::CreateIdentity());
         addPropertyOutcome = AZ::Failure(AZStd::string("Uninitialized"));
-        GraphVariableManagerRequestBus::EventResult(addPropertyOutcome, scriptCanvasId, &GraphVariableManagerRequests::AddVariable, "Super Matrix Bros", identityMatrixDatum);
+        GraphVariableManagerRequestBus::EventResult(addPropertyOutcome, scriptCanvasId, &GraphVariableManagerRequests::AddVariable, "Super Matrix Bros", identityMatrixDatum, false);
         EXPECT_TRUE(addPropertyOutcome);
         EXPECT_TRUE(addPropertyOutcome.GetValue().IsValid());