Merge branch 'main' into DetachPrefab

.clang-format

@@ -13,6 +13,7 @@ AllowShortFunctionsOnASingleLine: None
 AllowShortLambdasOnASingleLine: None
 AlwaysBreakAfterReturnType: None
 AlwaysBreakTemplateDeclarations: true
+BinPackParameters: false
 BreakBeforeBraces: Custom
 BraceWrapping:
     AfterClass: true

AutomatedTesting/Gem/PythonTests/AWS/Windows/aws_metrics/__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/AWS/Windows/aws_metrics/aws_metrics_automation_test.py

@@ -0,0 +1,237 @@
+"""
+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 logging
+import os
+import pytest
+import time
+import typing
+
+from datetime import datetime
+import ly_test_tools.log.log_monitor
+
+from assetpipeline.ap_fixtures.asset_processor_fixture import asset_processor as asset_processor
+from AWS.common.aws_utils import aws_utils
+from AWS.common.aws_credentials import aws_credentials
+from AWS.Windows.resource_mappings.resource_mappings import resource_mappings
+from AWS.Windows.cdk.cdk import cdk
+from .aws_metrics_utils import aws_metrics_utils
+
+AWS_METRICS_FEATURE_NAME = 'AWSMetrics'
+GAME_LOG_NAME = 'Game.log'
+
+logger = logging.getLogger(__name__)
+
+
+def setup(launcher: ly_test_tools.launchers.Launcher,
+          cdk: cdk,
+          asset_processor: asset_processor,
+          resource_mappings: resource_mappings,
+          context_variable: str = '') -> typing.Tuple[ly_test_tools.log.log_monitor.LogMonitor, str, str]:
+    """
+    Set up the CDK application and start the log monitor.
+    :param launcher: Client launcher for running the test level.
+    :param cdk: CDK application for deploying the AWS resources.
+    :param asset_processor: asset_processor fixture.
+    :param resource_mappings: resource_mappings fixture.
+    :param context_variable: context_variable for enable optional CDK feature.
+    :return log monitor object, metrics file path and the metrics stack name.
+    """
+    logger.info(f'Cdk stack names:\n{cdk.list()}')
+    stacks = cdk.deploy(context_variable=context_variable)
+    resource_mappings.populate_output_keys(stacks)
+
+    asset_processor.start()
+    asset_processor.wait_for_idle()
+
+    metrics_file_path = os.path.join(launcher.workspace.paths.project(), 'user',
+                                     AWS_METRICS_FEATURE_NAME, 'metrics.json')
+    remove_file(metrics_file_path)
+
+    file_to_monitor = os.path.join(launcher.workspace.paths.project_log(), GAME_LOG_NAME)
+    remove_file(file_to_monitor)
+
+    # Initialize the log monitor.
+    log_monitor = ly_test_tools.log.log_monitor.LogMonitor(launcher=launcher, log_file_path=file_to_monitor)
+
+    return log_monitor, metrics_file_path, stacks[0]
+
+
+def monitor_metrics_submission(log_monitor: ly_test_tools.log.log_monitor.LogMonitor) -> None:
+    """
+    Monitor the messages and notifications for submitting metrics.
+    :param log_monitor: Log monitor to check the log messages.
+    """
+    expected_lines = [
+        '(Script) - Submitted metrics without buffer.',
+        '(Script) - Submitted metrics with buffer.',
+        '(Script) - Metrics is sent successfully.'
+    ]
+
+    unexpected_lines = [
+        '(Script) - Failed to submit metrics without buffer.',
+        '(Script) - Failed to submit metrics with buffer.',
+        '(Script) - Failed to send metrics.'
+    ]
+
+    result = log_monitor.monitor_log_for_lines(
+        expected_lines=expected_lines,
+        unexpected_lines=unexpected_lines,
+        halt_on_unexpected=True)
+
+    # Assert the log monitor detected expected lines and did not detect any unexpected lines.
+    assert result, (
+        f'Log monitoring failed. Used expected_lines values: {expected_lines} & '
+        f'unexpected_lines values: {unexpected_lines}')
+
+
+def remove_file(file_path: str) -> None:
+    """
+    Remove a local file and its directory.
+    :param file_path: Path to the local file.
+    """
+    if os.path.exists(file_path):
+        os.remove(file_path)
+
+    file_dir = os.path.dirname(file_path)
+    if os.path.exists(file_dir) and len(os.listdir(file_dir)) == 0:
+        os.rmdir(file_dir)
+
+
+@pytest.mark.SUITE_periodic
+@pytest.mark.usefixtures('automatic_process_killer')
+@pytest.mark.parametrize('project', ['AutomatedTesting'])
+@pytest.mark.parametrize('level', ['AWS/Metrics'])
+@pytest.mark.parametrize('feature_name', [AWS_METRICS_FEATURE_NAME])
+@pytest.mark.parametrize('resource_mappings_filename', ['aws_resource_mappings.json'])
+@pytest.mark.parametrize('profile_name', ['AWSAutomationTest'])
+@pytest.mark.parametrize('region_name', ['us-west-2'])
+@pytest.mark.parametrize('assume_role_arn', ['arn:aws:iam::645075835648:role/o3de-automation-tests'])
+@pytest.mark.parametrize('session_name', ['o3de-Automation-session'])
+class TestAWSMetrics_Windows(object):
+    def test_AWSMetrics_RealTimeAnalytics_MetricsSentToCloudWatch(self,
+                                                                  level: str,
+                                                                  launcher: ly_test_tools.launchers.Launcher,
+                                                                  asset_processor: pytest.fixture,
+                                                                  workspace: pytest.fixture,
+                                                                  aws_utils: aws_utils,
+                                                                  aws_credentials: aws_credentials,
+                                                                  resource_mappings: resource_mappings,
+                                                                  cdk: cdk,
+                                                                  aws_metrics_utils: aws_metrics_utils,
+                                                                  ):
+        """
+        Tests that the submitted metrics are sent to CloudWatch for real-time analytics.
+        """
+        log_monitor, metrics_file_path, stack_name = setup(launcher, cdk, asset_processor, resource_mappings)
+
+        # Start the Kinesis Data Analytics application for real-time analytics.
+        analytics_application_name = f'{stack_name}-AnalyticsApplication'
+        aws_metrics_utils.start_kinesis_data_analytics_application(analytics_application_name)
+
+        launcher.args = ['+LoadLevel', level]
+        launcher.args.extend(['-rhi=null'])
+
+        with launcher.start(launch_ap=False):
+            start_time = datetime.utcnow()
+            monitor_metrics_submission(log_monitor)
+            # Verify that operational health metrics are delivered to CloudWatch.
+            aws_metrics_utils.verify_cloud_watch_delivery(
+                'AWS/Lambda',
+                'Invocations',
+                [{'Name': 'FunctionName',
+                  'Value': f'{stack_name}-AnalyticsProcessingLambda'}],
+                start_time)
+            logger.info('Operational health metrics sent to CloudWatch.')
+
+            aws_metrics_utils.verify_cloud_watch_delivery(
+                AWS_METRICS_FEATURE_NAME,
+                'TotalLogins',
+                [],
+                start_time)
+            logger.info('Real-time metrics sent to CloudWatch.')
+
+        # Stop the Kinesis Data Analytics application.
+        aws_metrics_utils.stop_kinesis_data_analytics_application(analytics_application_name)
+
+    def test_AWSMetrics_UnauthorizedUser_RequestRejected(self,
+                                                         level: str,
+                                                         launcher: ly_test_tools.launchers.Launcher,
+                                                         cdk: cdk,
+                                                         aws_credentials: aws_credentials,
+                                                         asset_processor: pytest.fixture,
+                                                         resource_mappings: resource_mappings,
+                                                         workspace: pytest.fixture):
+        """
+        Tests that unauthorized users cannot send metrics events to the AWS backed backend.
+        """
+        log_monitor, metrics_file_path, stack_name = setup(launcher, cdk, asset_processor, resource_mappings)
+        # Set invalid AWS credentials.
+        launcher.args = ['+LoadLevel', level, '+cl_awsAccessKey', 'AKIAIOSFODNN7EXAMPLE',
+                         '+cl_awsSecretKey', 'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY']
+        launcher.args.extend(['-rhi=null'])
+
+        with launcher.start(launch_ap=False):
+            result = log_monitor.monitor_log_for_lines(
+                expected_lines=['(Script) - Failed to send metrics.'],
+                unexpected_lines=['(Script) - Metrics is sent successfully.'],
+                halt_on_unexpected=True)
+            assert result, 'Metrics events are sent successfully by unauthorized user'
+            logger.info('Unauthorized user is rejected to send metrics.')
+
+    def test_AWSMetrics_BatchAnalytics_MetricsDeliveredToS3(self,
+                                                            level: str,
+                                                            launcher: ly_test_tools.launchers.Launcher,
+                                                            cdk: cdk,
+                                                            aws_credentials: aws_credentials,
+                                                            asset_processor: pytest.fixture,
+                                                            resource_mappings: resource_mappings,
+                                                            aws_utils: aws_utils,
+                                                            aws_metrics_utils: aws_metrics_utils,
+                                                            workspace: pytest.fixture):
+        """
+        Tests that the submitted metrics are sent to the data lake for batch analytics.
+        """
+        log_monitor, metrics_file_path, stack_name = setup(launcher, cdk, asset_processor, resource_mappings,
+                                                           context_variable='batch_processing=true')
+
+        analytics_bucket_name = aws_metrics_utils.get_analytics_bucket_name(stack_name)
+
+        launcher.args = ['+LoadLevel', level]
+        launcher.args.extend(['-rhi=null'])
+
+        with launcher.start(launch_ap=False):
+            start_time = datetime.utcnow()
+            monitor_metrics_submission(log_monitor)
+            # Verify that operational health metrics are delivered to CloudWatch.
+            aws_metrics_utils.verify_cloud_watch_delivery(
+                'AWS/Lambda',
+                'Invocations',
+                [{'Name': 'FunctionName',
+                  'Value': f'{stack_name}-EventsProcessingLambda'}],
+                start_time)
+            logger.info('Operational health metrics sent to CloudWatch.')
+
+        aws_metrics_utils.verify_s3_delivery(analytics_bucket_name)
+        logger.info('Metrics sent to S3.')
+
+        # Run the glue crawler to populate the AWS Glue Data Catalog with tables.
+        aws_metrics_utils.run_glue_crawler(f'{stack_name}-EventsCrawler')
+        # Run named queries on the table to verify the batch analytics.
+        aws_metrics_utils.run_named_queries(f'{stack_name}-AthenaWorkGroup')
+        logger.info('Query metrics from S3 successfully.')
+
+        # Kinesis Data Firehose buffers incoming data before it delivers it to Amazon S3. Sleep for the
+        # default interval (60s) to make sure that all the metrics are sent to the bucket before cleanup.
+        time.sleep(60)
+        # Empty the S3 bucket. S3 buckets can only be deleted successfully when it doesn't contain any object.
+        aws_metrics_utils.empty_s3_bucket(analytics_bucket_name)
+

AutomatedTesting/Gem/PythonTests/AWS/Windows/aws_metrics/aws_metrics_utils.py

@@ -0,0 +1,252 @@
+"""
+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 logging
+import pathlib
+import pytest
+import typing
+
+from datetime import datetime
+from botocore.exceptions import WaiterError
+
+from AWS.common.aws_utils import AwsUtils
+from .aws_metrics_waiters import KinesisAnalyticsApplicationUpdatedWaiter, \
+    CloudWatchMetricsDeliveredWaiter, DataLakeMetricsDeliveredWaiter, GlueCrawlerReadyWaiter
+
+logging.getLogger('boto').setLevel(logging.CRITICAL)
+
+# Expected directory and file extension for the S3 objects.
+EXPECTED_S3_DIRECTORY = 'firehose_events/'
+EXPECTED_S3_OBJECT_EXTENSION = '.parquet'
+
+
+class AWSMetricsUtils:
+    """
+    Provide utils functions for the AWSMetrics gem to interact with the deployed resources.
+    """
+
+    def __init__(self, aws_utils: AwsUtils):
+        self._aws_util = aws_utils
+
+    def start_kinesis_data_analytics_application(self, application_name: str) -> None:
+        """
+        Start the Kenisis Data Analytics application for real-time analytics.
+        :param application_name: Name of the Kenisis Data Analytics application.
+        """
+        input_id = self.get_kinesis_analytics_application_input_id(application_name)
+        assert input_id, 'invalid Kinesis Data Analytics application input.'
+
+        client = self._aws_util.client('kinesisanalytics')
+        try:
+            client.start_application(
+                ApplicationName=application_name,
+                InputConfigurations=[
+                    {
+                        'Id': input_id,
+                        'InputStartingPositionConfiguration': {
+                            'InputStartingPosition': 'NOW'
+                        }
+                    },
+                ]
+            )
+        except client.exceptions.ResourceInUseException:
+            # The application has been started.
+            return
+
+        try:
+            KinesisAnalyticsApplicationUpdatedWaiter(client, 'RUNNING').wait(application_name=application_name)
+        except WaiterError as e:
+            assert False, f'Failed to start the Kinesis Data Analytics application: {str(e)}.'
+
+    def get_kinesis_analytics_application_input_id(self, application_name: str) -> str:
+        """
+        Get the input ID for the Kenisis Data Analytics application.
+        :param application_name: Name of the Kenisis Data Analytics application.
+        :return: Input ID for the Kenisis Data Analytics application.
+        """
+        client = self._aws_util.client('kinesisanalytics')
+        response = client.describe_application(
+            ApplicationName=application_name
+        )
+        if not response:
+            return ''
+        input_descriptions = response.get('ApplicationDetail', {}).get('InputDescriptions', [])
+        if len(input_descriptions) != 1:
+            return ''
+
+        return input_descriptions[0].get('InputId', '')
+
+    def stop_kinesis_data_analytics_application(self, application_name: str) -> None:
+        """
+        Stop the Kenisis Data Analytics application.
+        :param application_name: Name of the Kenisis Data Analytics application.
+        """
+        client = self._aws_util.client('kinesisanalytics')
+        client.stop_application(
+            ApplicationName=application_name
+        )
+
+        try:
+            KinesisAnalyticsApplicationUpdatedWaiter(client, 'READY').wait(application_name=application_name)
+        except WaiterError as e:
+            assert False, f'Failed to stop the Kinesis Data Analytics application: {str(e)}.'
+
+    def verify_cloud_watch_delivery(self, namespace: str, metrics_name: str,
+                                    dimensions: typing.List[dict], start_time: datetime) -> None:
+        """
+        Verify that the expected metrics is delivered to CloudWatch.
+        :param namespace: Namespace of the metrics.
+        :param metrics_name: Name of the metrics.
+        :param dimensions: Dimensions of the metrics.
+        :param start_time: Start time for generating the metrics.
+        """
+        client = self._aws_util.client('cloudwatch')
+
+        try:
+            CloudWatchMetricsDeliveredWaiter(client).wait(
+                namespace=namespace,
+                metrics_name=metrics_name,
+                dimensions=dimensions,
+                start_time=start_time
+            )
+        except WaiterError as e:
+            assert False, f'Failed to deliver metrics to CloudWatch: {str(e)}.'
+
+    def verify_s3_delivery(self, analytics_bucket_name: str) -> None:
+        """
+        Verify that metrics are delivered to S3 for batch analytics successfully.
+        :param analytics_bucket_name: Name of the deployed S3 bucket.
+        """
+        client = self._aws_util.client('s3')
+        bucket_name = analytics_bucket_name
+
+        try:
+            DataLakeMetricsDeliveredWaiter(client).wait(bucket_name=bucket_name, prefix=EXPECTED_S3_DIRECTORY)
+        except WaiterError as e:
+            assert False, f'Failed to find the S3 directory for storing metrics data: {str(e)}.'
+
+        # Check whether the data is converted to the expected data format.
+        response = client.list_objects_v2(
+            Bucket=bucket_name,
+            Prefix=EXPECTED_S3_DIRECTORY
+        )
+        assert response.get('KeyCount', 0) != 0, f'Failed to deliver metrics to the S3 bucket {bucket_name}.'
+
+        s3_objects = response.get('Contents', [])
+        for s3_object in s3_objects:
+            key = s3_object.get('Key', '')
+            assert pathlib.Path(key).suffix == EXPECTED_S3_OBJECT_EXTENSION, \
+                f'Invalid data format is found in the S3 bucket {bucket_name}'
+
+    def run_glue_crawler(self, crawler_name: str) -> None:
+        """
+        Run the Glue crawler and wait for it to finish.
+        :param crawler_name: Name of the Glue crawler
+        """
+        client = self._aws_util.client('glue')
+        try:
+            client.start_crawler(
+                Name=crawler_name
+            )
+        except client.exceptions.CrawlerRunningException:
+            # The crawler has already been started.
+            return
+
+        try:
+            GlueCrawlerReadyWaiter(client).wait(crawler_name=crawler_name)
+        except WaiterError as e:
+            assert False, f'Failed to run the Glue crawler: {str(e)}.'
+
+    def run_named_queries(self, work_group: str) -> None:
+        """
+        Run the named queries under the specific Athena work group.
+        :param work_group: Name of the Athena work group.
+        """
+        client = self._aws_util.client('athena')
+        # List all the named queries.
+        response = client.list_named_queries(
+            WorkGroup=work_group
+        )
+        named_query_ids = response.get('NamedQueryIds', [])
+
+        # Run each of the queries.
+        for named_query_id in named_query_ids:
+            get_named_query_response = client.get_named_query(
+                NamedQueryId=named_query_id
+            )
+            named_query = get_named_query_response.get('NamedQuery', {})
+
+            start_query_execution_response = client.start_query_execution(
+                QueryString=named_query.get('QueryString', ''),
+                QueryExecutionContext={
+                    'Database': named_query.get('Database', '')
+                },
+                WorkGroup=work_group
+            )
+
+            # Wait for the query to finish.
+            state = 'RUNNING'
+            while state == 'QUEUED' or state == 'RUNNING':
+                get_query_execution_response = client.get_query_execution(
+                    QueryExecutionId=start_query_execution_response.get('QueryExecutionId', '')
+                )
+
+                state = get_query_execution_response.get('QueryExecution', {}).get('Status', {}).get('State', '')
+
+            assert state == 'SUCCEEDED', f'Failed to run the named query {named_query.get("Name", {})}'
+
+    def empty_s3_bucket(self, bucket_name: str) -> None:
+        """
+        Empty the S3 bucket following:
+        https://boto3.amazonaws.com/v1/documentation/api/latest/guide/migrations3.html
+
+        :param bucket_name: Name of the S3 bucket.
+        """
+
+        s3 = self._aws_util.resource('s3')
+        bucket = s3.Bucket(bucket_name)
+
+        for key in bucket.objects.all():
+            key.delete()
+
+    def get_analytics_bucket_name(self, stack_name: str) -> str:
+        """
+        Get the name of the deployed S3 bucket.
+        :param stack_name: Name of the CloudFormation stack.
+        :return: Name of the deployed S3 bucket.
+        """
+
+        client = self._aws_util.client('cloudformation')
+
+        response = client.describe_stack_resources(
+            StackName=stack_name
+        )
+        resources = response.get('StackResources', [])
+
+        for resource in resources:
+            if resource.get('ResourceType') == 'AWS::S3::Bucket':
+                return resource.get('PhysicalResourceId', '')
+
+        return ''
+
+
+@pytest.fixture(scope='function')
+def aws_metrics_utils(
+        request: pytest.fixture,
+        aws_utils: pytest.fixture):
+    """
+    Fixture for the AWS metrics util functions.
+    :param request:  _pytest.fixtures.SubRequest class that handles getting
+        a pytest fixture from a pytest function/fixture.
+    :param aws_utils: aws_utils fixture.
+    """
+    aws_utils_obj = AWSMetricsUtils(aws_utils)
+    return aws_utils_obj

AutomatedTesting/Gem/PythonTests/AWS/Windows/aws_metrics/aws_metrics_waiters.py

@@ -0,0 +1,142 @@
+"""
+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 botocore.client
+import logging
+
+from datetime import timedelta
+from AWS.common.custom_waiter import CustomWaiter, WaitState
+
+logging.getLogger('boto').setLevel(logging.CRITICAL)
+
+
+class KinesisAnalyticsApplicationUpdatedWaiter(CustomWaiter):
+    """
+    Subclass of the base custom waiter class.
+    Wait for the Kinesis analytics application being updated to a specific status.
+    """
+    def __init__(self, client: botocore.client, status: str):
+        """
+        Initialize the waiter.
+
+        :param client: Boto3 client to use.
+        :param status: Expected status.
+        """
+        super().__init__(
+            'KinesisAnalyticsApplicationUpdated',
+            'DescribeApplication',
+            'ApplicationDetail.ApplicationStatus',
+            {status: WaitState.SUCCESS},
+            client)
+
+    def wait(self, application_name: str):
+        """
+        Wait for the expected status.
+
+        :param application_name: Name of the Kinesis analytics application.
+        """
+        self._wait(ApplicationName=application_name)
+
+
+class GlueCrawlerReadyWaiter(CustomWaiter):
+    """
+    Subclass of the base custom waiter class.
+    Wait for the Glue crawler to finish its processing.
+    """
+    def __init__(self, client: botocore.client):
+        """
+        Initialize the waiter.
+
+        :param client: Boto3 client to use.
+        """
+        super().__init__(
+            'GlueCrawlerReady',
+            'GetCrawler',
+            'Crawler.State',
+            {'READY': WaitState.SUCCESS},
+            client)
+
+    def wait(self, crawler_name):
+        """
+        Wait for the expected status.
+
+        :param crawler_name: Name of the Glue crawler.
+        """
+        self._wait(Name=crawler_name)
+
+
+class DataLakeMetricsDeliveredWaiter(CustomWaiter):
+    """
+    Subclass of the base custom waiter class.
+    Wait for the expected directory being created in the S3 bucket.
+    """
+    def __init__(self, client: botocore.client):
+        """
+        Initialize the waiter.
+
+        :param client: Boto3 client to use.
+        """
+        super().__init__(
+            'DataLakeMetricsDelivered',
+            'ListObjectsV2',
+            'KeyCount > `0`',
+            {True: WaitState.SUCCESS},
+            client)
+
+    def wait(self, bucket_name, prefix):
+        """
+        Wait for the expected directory being created.
+
+        :param bucket_name: Name of the S3 bucket.
+        :param prefix: Name of the expected directory prefix.
+        """
+        self._wait(Bucket=bucket_name, Prefix=prefix)
+
+
+class CloudWatchMetricsDeliveredWaiter(CustomWaiter):
+    """
+    Subclass of the base custom waiter class.
+    Wait for the expected metrics being delivered to CloudWatch.
+    """
+    def __init__(self, client: botocore.client):
+        """
+        Initialize the waiter.
+
+        :param client: Boto3 client to use.
+        """
+        super().__init__(
+            'CloudWatchMetricsDelivered',
+            'GetMetricStatistics',
+            'length(Datapoints) > `0`',
+            {True: WaitState.SUCCESS},
+            client)
+
+    def wait(self, namespace, metrics_name, dimensions, start_time):
+        """
+        Wait for the expected metrics being delivered.
+
+        :param namespace: Namespace of the metrics.
+        :param metrics_name: Name of the metrics.
+        :param dimensions: Dimensions of the metrics.
+        :param start_time: Start time for generating the metrics.
+        """
+        self._wait(
+            Namespace=namespace,
+            MetricName=metrics_name,
+            Dimensions=dimensions,
+            StartTime=start_time,
+            EndTime=start_time + timedelta(0, self.timeout),
+            Period=60,
+            Statistics=[
+                'SampleCount'
+            ],
+            Unit='Count'
+        )

AutomatedTesting/Gem/PythonTests/AWS/Windows/cdk/cdk.py

@@ -16,12 +16,15 @@ import boto3
 import ly_test_tools.environment.process_utils as process_utils
 from typing import List
 
+BOOTSTRAP_STACK_NAME = 'CDKToolkit'
+BOOTSTRAP_STAGING_BUCKET_LOGIC_ID = 'StagingBucket'
 
 class Cdk:
     """
     Cdk class that provides methods to run cdk application commands.
     Expects system to have NodeJS, AWS CLI and CDK installed globally and have their paths setup as env variables.
     """
+
     def __init__(self, cdk_path: str, project: str, account_id: str,
                  workspace: pytest.fixture, session: boto3.session.Session):
         """
@@ -49,12 +52,24 @@ class Cdk:
             env=self._cdk_env,
             shell=True)
 
+    def bootstrap(self) -> None:
+        """
+        Deploy the bootstrap stack.
+        """
+        bootstrap_cmd = ['cdk', 'bootstrap',
+                         f'aws://{self._cdk_env["O3DE_AWS_DEPLOY_ACCOUNT"]}/{self._cdk_env["O3DE_AWS_DEPLOY_REGION"]}']
+
+        process_utils.check_call(
+            bootstrap_cmd,
+            cwd=self._cdk_path,
+            env=self._cdk_env,
+            shell=True)
+
     def list(self) -> List[str]:
         """
         lists cdk stack names
         :return List of cdk stack names
         """
-
         if not self._cdk_path:
             return []
 
@@ -123,6 +138,38 @@ class Cdk:
         self._stacks = []
         self._cdk_path = ''
 
+    @staticmethod
+    def remove_bootstrap_stack(aws_utils: pytest.fixture) -> None:
+        """
+        Remove the CDK bootstrap stack.
+        :param aws_utils: aws_utils fixture.
+        """
+        # Check if the bootstrap stack exists.
+        response = aws_utils.client('cloudformation').describe_stacks(
+            StackName=BOOTSTRAP_STACK_NAME
+        )
+        stacks = response.get('Stacks', [])
+        if not stacks:
+            return
+
+        # Clear the bootstrap staging bucket before deleting the bootstrap stack.
+        response = aws_utils.client('cloudformation').describe_stack_resource(
+            StackName=BOOTSTRAP_STACK_NAME,
+            LogicalResourceId=BOOTSTRAP_STAGING_BUCKET_LOGIC_ID
+        )
+
+        staging_bucket_name = response.get('StackResourceDetail', {}).get('PhysicalResourceId', '')
+        if staging_bucket_name:
+            s3 = aws_utils.resource('s3')
+            bucket = s3.Bucket(staging_bucket_name)
+            for key in bucket.objects.all():
+                key.delete()
+
+        # Delete the bootstrap stack.
+        aws_utils.client('cloudformation').delete_stack(
+            StackName=BOOTSTRAP_STACK_NAME
+        )
+
 
 @pytest.fixture(scope='function')
 def cdk(
@@ -131,6 +178,7 @@ def cdk(
         feature_name: str,
         workspace: pytest.fixture,
         aws_utils: pytest.fixture,
+        bootstrap_required: bool = True,
         destroy_stacks_on_teardown: bool = True) -> Cdk:
     """
     Fixture for setting up a Cdk
@@ -140,6 +188,8 @@ def cdk(
     :param feature_name: Feature gem name to expect cdk folder in.
     :param workspace: ly_test_tools workspace fixture.
     :param aws_utils: aws_utils fixture.
+    :param bootstrap_required: Whether the bootstrap stack needs to be created to
+        provision resources the AWS CDK needs to perform the deployment.
     :param destroy_stacks_on_teardown: option to control calling destroy ot the end of test.
     :return Cdk class object.
     """
@@ -147,9 +197,14 @@ def cdk(
     cdk_path = f'{workspace.paths.engine_root()}/Gems/{feature_name}/cdk'
     cdk_obj = Cdk(cdk_path, project, aws_utils.assume_account_id(), workspace, aws_utils.assume_session())
 
+    if bootstrap_required:
+        cdk_obj.bootstrap()
+
     def teardown():
         if destroy_stacks_on_teardown:
             cdk_obj.destroy()
+            cdk_obj.remove_bootstrap_stack(aws_utils)
+
     request.addfinalizer(teardown)
 
     return cdk_obj

AutomatedTesting/Gem/PythonTests/AWS/common/aws_credentials.py

@@ -0,0 +1,134 @@
+"""
+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 boto3
+import configparser
+import logging
+import os
+import pytest
+import typing
+
+logger = logging.getLogger(__name__)
+logging.getLogger('boto').setLevel(logging.CRITICAL)
+
+
+class AwsCredentials:
+    def __init__(self, profile_name: str):
+        self._profile_name = profile_name
+
+        self._credentials_path = os.environ.get('AWS_SHARED_CREDENTIALS_FILE')
+        if not self._credentials_path:
+            # Home directory location varies based on the operating system, but is referred to using the environment
+            # variables %UserProfile% in Windows and $HOME or ~ (tilde) in Unix-based systems.
+            self._credentials_path = os.path.join(os.environ.get('UserProfile', os.path.expanduser('~')),
+                                                  '.aws', 'credentials')
+        self._credentials_file_exists = os.path.exists(self._credentials_path)
+
+        self._credentials = configparser.ConfigParser()
+        self._credentials.read(self._credentials_path)
+
+    def get_aws_credentials(self) -> typing.Tuple[str, str, str]:
+        """
+        Get aws credentials stored in the specific named profile.
+
+        :return AWS credentials.
+        """
+        access_key_id = self._get_aws_credential_attribute_value('aws_access_key_id')
+        secret_access_key = self._get_aws_credential_attribute_value('aws_secret_access_key')
+        session_token = self._get_aws_credential_attribute_value('aws_session_token')
+
+        return access_key_id, secret_access_key, session_token
+
+    def set_aws_credentials_by_session(self, session: boto3.Session) -> None:
+        """
+        Set AWS credentials stored in the specific named profile using an assumed role session.
+
+        :param session: assumed role session.
+        """
+        credentials = session.get_credentials().get_frozen_credentials()
+        self.set_aws_credentials(credentials.access_key, credentials.secret_key, credentials.token)
+
+    def set_aws_credentials(self, aws_access_key_id: str, aws_secret_access_key: str,
+                            aws_session_token: str) -> None:
+        """
+        Set AWS credentials stored in the specific named profile.
+
+        :param aws_access_key_id: AWS access key id.
+        :param aws_secret_access_key: AWS secrete access key.
+        :param aws_session_token: AWS assumed role session.
+        """
+        self._set_aws_credential_attribute_value('aws_access_key_id', aws_access_key_id)
+        self._set_aws_credential_attribute_value('aws_secret_access_key', aws_secret_access_key)
+        self._set_aws_credential_attribute_value('aws_session_token', aws_session_token)
+
+        if (len(self._credentials.sections()) == 0) and (not self._credentials_file_exists):
+            os.remove(self._credentials_path)
+            return
+
+        with open(self._credentials_path, 'w+') as credential_file:
+            self._credentials.write(credential_file)
+
+    def _get_aws_credential_attribute_value(self, attribute_name: str) -> str:
+        """
+        Get the value of an AWS credential attribute stored in the specific named profile.
+
+        :param attribute_name: Name of the AWS credential attribute.
+        :return Value of the AWS credential attribute.
+        """
+        try:
+            value = self._credentials.get(self._profile_name, attribute_name)
+        except configparser.NoSectionError:
+            # Named profile or key doesn't exist
+            value = None
+        except configparser.NoOptionError:
+            # Named profile doesn't have the specified attribute
+            value = None
+
+        return value
+
+    def _set_aws_credential_attribute_value(self, attribute_name: str, attribute_value: str) -> None:
+        """
+        Set the value of an AWS credential attribute stored in the specific named profile.
+
+        :param attribute_name: Name of the AWS credential attribute.
+        :param attribute_value: Value of the AWS credential attribute.
+        """
+        if self._profile_name not in self._credentials:
+            self._credentials[self._profile_name] = {}
+
+        if attribute_value is None:
+            self._credentials.remove_option(self._profile_name, attribute_name)
+            # Remove the named profile if it doesn't have any AWS credential attribute.
+            if len(self._credentials[self._profile_name]) == 0:
+                self._credentials.remove_section(self._profile_name)
+        else:
+            self._credentials[self._profile_name][attribute_name] = attribute_value
+
+
+@pytest.fixture(scope='function')
+def aws_credentials(request: pytest.fixture, aws_utils: pytest.fixture, profile_name: str):
+    """
+    Fixture for setting up temporary AWS credentials from assume role.
+
+    :param request: _pytest.fixtures.SubRequest class that handles getting
+        a pytest fixture from a pytest function/fixture.
+    :param aws_utils: aws_utils fixture.
+    :param profile_name: Named AWS profile to store temporary credentials.
+    """
+    aws_credentials_obj = AwsCredentials(profile_name)
+    original_access_key, original_secret_access_key, original_token = aws_credentials_obj.get_aws_credentials()
+    aws_credentials_obj.set_aws_credentials_by_session(aws_utils.assume_session())
+
+    def teardown():
+        # Reset to the named profile using the original AWS credentials
+        aws_credentials_obj.set_aws_credentials(original_access_key, original_secret_access_key, original_token)
+    request.addfinalizer(teardown)
+
+    return aws_credentials_obj

AutomatedTesting/Gem/PythonTests/AWS/common/aws_utils.py

@@ -1,82 +1,90 @@
-"""
-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 boto3
-import pytest
-import logging
-
-logger = logging.getLogger(__name__)
-
-
-class AwsUtils:
-
-    def __init__(self, arn: str, session_name: str, region_name: str):
-        local_session = boto3.Session(profile_name='default')
-        local_sts_client = local_session.client('sts')
-        self._local_account_id = local_sts_client.get_caller_identity()["Account"]
-        logger.info(f'Local Account Id: {self._local_account_id}')
-
-        response = local_sts_client.assume_role(RoleArn=arn, RoleSessionName=session_name)
-
-        self._assume_session = boto3.Session(aws_access_key_id=response['Credentials']['AccessKeyId'],
-                                             aws_secret_access_key=response['Credentials']['SecretAccessKey'],
-                                             aws_session_token=response['Credentials']['SessionToken'],
-                                             region_name=region_name)
-
-        assume_sts_client = self._assume_session.client('sts')
-        assume_account_id = assume_sts_client.get_caller_identity()["Account"]
-        logger.info(f'Assume Account Id: {assume_account_id}')
-        self._assume_account_id = assume_account_id
-
-    def client(self, service: str):
-        """
-        Get the client for a specific AWS service from configured session
-        :return: Client for the AWS service.
-        """
-        return self._assume_session.client(service)
-
-    def assume_session(self):
-        return self._assume_session
-
-    def local_account_id(self):
-        return self._local_account_id
-
-    def assume_account_id(self):
-        return self._assume_account_id
-
-    def destroy(self) -> None:
-        """
-        clears stored session
-        """
-        self._assume_session = None
-
-
-@pytest.fixture(scope='function')
-def aws_utils(
-        request: pytest.fixture,
-        assume_role_arn: str,
-        session_name: str,
-        region_name: str):
-    """
-    Fixture for setting up a Cdk
-    :param request: _pytest.fixtures.SubRequest class that handles getting
-        a pytest fixture from a pytest function/fixture.
-    :param assume_role_arn: Role used to fetch temporary aws credentials, configure service clients with obtained credentials.
-    :param session_name: Session name to set.
-    :param region_name: AWS account region to set for session.
-    :return AWSUtils class object.
-    """
-    aws_utils_obj = AwsUtils(assume_role_arn, session_name, region_name)
-
-    def teardown():
-        aws_utils_obj.destroy()
-
-    request.addfinalizer(teardown)
-
-    return aws_utils_obj
+"""
+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 boto3
+import pytest
+import logging
+
+logger = logging.getLogger(__name__)
+logging.getLogger('boto').setLevel(logging.CRITICAL)
+
+
+class AwsUtils:
+
+    def __init__(self, arn: str, session_name: str, region_name: str):
+        local_session = boto3.Session(profile_name='default')
+        local_sts_client = local_session.client('sts')
+        self._local_account_id = local_sts_client.get_caller_identity()["Account"]
+        logger.info(f'Local Account Id: {self._local_account_id}')
+
+        response = local_sts_client.assume_role(RoleArn=arn, RoleSessionName=session_name)
+
+        self._assume_session = boto3.Session(aws_access_key_id=response['Credentials']['AccessKeyId'],
+                                             aws_secret_access_key=response['Credentials']['SecretAccessKey'],
+                                             aws_session_token=response['Credentials']['SessionToken'],
+                                             region_name=region_name)
+
+        assume_sts_client = self._assume_session.client('sts')
+        assume_account_id = assume_sts_client.get_caller_identity()["Account"]
+        logger.info(f'Assume Account Id: {assume_account_id}')
+        self._assume_account_id = assume_account_id
+
+    def client(self, service: str):
+        """
+        Get the client for a specific AWS service from configured session
+        :return: Client for the AWS service.
+        """
+        return self._assume_session.client(service)
+
+    def resource(self, service: str):
+        """
+        Get the resource for a specific AWS service from configured session
+        :return: Client for the AWS service.
+        """
+        return self._assume_session.resource(service)
+
+    def assume_session(self):
+        return self._assume_session
+
+    def local_account_id(self):
+        return self._local_account_id
+
+    def assume_account_id(self):
+        return self._assume_account_id
+
+    def destroy(self) -> None:
+        """
+        clears stored session
+        """
+        self._assume_session = None
+
+
+@pytest.fixture(scope='function')
+def aws_utils(
+        request: pytest.fixture,
+        assume_role_arn: str,
+        session_name: str,
+        region_name: str):
+    """
+    Fixture for AWS util functions
+    :param request: _pytest.fixtures.SubRequest class that handles getting
+        a pytest fixture from a pytest function/fixture.
+    :param assume_role_arn: Role used to fetch temporary aws credentials, configure service clients with obtained credentials.
+    :param session_name: Session name to set.
+    :param region_name: AWS account region to set for session.
+    :return AWSUtils class object.
+    """
+    aws_utils_obj = AwsUtils(assume_role_arn, session_name, region_name)
+
+    def teardown():
+        aws_utils_obj.destroy()
+
+    request.addfinalizer(teardown)
+
+    return aws_utils_obj

AutomatedTesting/Gem/PythonTests/AWS/common/custom_waiter.py

@@ -0,0 +1,91 @@
+"""
+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.
+"""
+
+from enum import Enum
+import botocore.client
+import botocore.waiter
+import logging
+
+logging.getLogger('boto').setLevel(logging.CRITICAL)
+
+
+class WaitState(Enum):
+    SUCCESS = 'success'
+    FAILURE = 'failure'
+
+
+class CustomWaiter:
+    """
+    Base class for a custom waiter.
+
+    Modified from:
+    https://docs.aws.amazon.com/code-samples/latest/catalog/python-demo_tools-custom_waiter.py.html
+    """
+    def __init__(
+            self, name: str, operation: str, argument: str,
+            acceptors: dict, client: botocore.client, delay: int = 30, max_tries: int = 10,
+            matcher='path'):
+        """
+        Subclasses should pass specific operations, arguments, and acceptors to
+        their superclass.
+
+        :param name: The name of the waiter. This can be any descriptive string.
+        :param operation: The operation to wait for. This must match the casing of
+                          the underlying operation model, which is typically in
+                          CamelCase.
+        :param argument: The dict keys used to access the result of the operation, in
+                         dot notation. For example, 'Job.Status' will access
+                         result['Job']['Status'].
+        :param acceptors: The list of acceptors that indicate the wait is over. These
+                          can indicate either success or failure. The acceptor values
+                          are compared to the result of the operation after the
+                          argument keys are applied.
+        :param client: The Boto3 client.
+        :param delay: The number of seconds to wait between each call to the operation. Default to 30 seconds.
+        :param max_tries: The maximum number of tries before exiting. Default to 10.
+        :param matcher: The kind of matcher to use. Default to 'path'.
+        """
+        self.name = name
+        self.operation = operation
+        self.argument = argument
+        self.client = client
+        self.waiter_model = botocore.waiter.WaiterModel({
+            'version': 2,
+            'waiters': {
+                name: {
+                    "delay": delay,
+                    "operation": operation,
+                    "maxAttempts": max_tries,
+                    "acceptors": [{
+                        "state": state.value,
+                        "matcher": matcher,
+                        "argument": argument,
+                        "expected": expected
+                    } for expected, state in acceptors.items()]
+                }}})
+        self.waiter = botocore.waiter.create_waiter_with_client(
+            self.name, self.waiter_model, self.client)
+
+        self._timeout = delay * max_tries
+
+    def _wait(self, **kwargs):
+        """
+        Starts the botocore wait loop.
+
+        :param kwargs: Keyword arguments that are passed to the operation being polled.
+        """
+        self.waiter.wait(**kwargs)
+
+    @property
+    def timeout(self):
+        return self._timeout
+
+

AutomatedTesting/Gem/PythonTests/scripting/ScriptEvent_AddRemoveParameter_ActionsSuccessful.py

@@ -0,0 +1,131 @@
+"""
+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.
+"""
+
+
+# fmt: off
+class Tests():
+    new_event_created   = ("Successfully created a new event", "Failed to create a new event")
+    child_event_created = ("Successfully created Child Event", "Failed to create Child Event")
+    file_saved          = ("Successfully saved event asset",   "Failed to save event asset")
+    parameter_created   = ("Successfully added parameter",     "Failed to add parameter")
+    parameter_removed   = ("Successfully removed parameter",   "Failed to remove parameter")
+# fmt: on
+
+
+def ScriptEvent_AddRemoveParameter_ActionsSuccessful():
+    """
+    Summary:
+     Parameter can be removed from a Script Event method
+
+    Expected Behavior:
+     Upon saving the updated .scriptevents asset the removed paramenter should no longer be present on the Script Event
+
+    Test Steps:
+     1) Open Asset Editor
+     2) Get Asset Editor Qt object
+     3) Create new Script Event Asset
+     4) Add Parameter to Event
+     5) Remove Parameter from Event
+
+    Note:
+     - This test file must be called from the Open 3D Engine Editor command terminal
+     - Any passed and failed tests are written to the Editor.log file.
+        Parsing the file or running a log_monitor are required to observe the test results.
+
+    :return: None
+    """
+    import os
+    from PySide2 import QtWidgets
+
+    from editor_python_test_tools.utils import Report
+    from editor_python_test_tools.utils import TestHelper as helper
+    import editor_python_test_tools.pyside_utils as pyside_utils
+
+    import azlmbr.bus as bus
+    import azlmbr.editor as editor
+    import azlmbr.legacy.general as general
+
+    GENERAL_WAIT = 1.0  # seconds
+    FILE_PATH = os.path.join("AutomatedTesting", "ScriptCanvas", "test_file.scriptevent")
+    QtObject = object
+
+    def create_script_event(asset_editor: QtObject, file_path: str) -> None:
+        action = pyside_utils.find_child_by_pattern(menu_bar, {"type": QtWidgets.QAction, "text": "Script Events"})
+        action.trigger()
+        result = helper.wait_for_condition(
+            lambda: container.findChild(QtWidgets.QFrame, "Events") is not None, 3 * GENERAL_WAIT
+        )
+        Report.result(Tests.new_event_created, result)
+
+        # Add new child event
+        add_event = container.findChild(QtWidgets.QFrame, "Events").findChild(QtWidgets.QToolButton, "")
+        add_event.click()
+        result = helper.wait_for_condition(
+            lambda: asset_editor.findChild(QtWidgets.QFrame, "EventName") is not None, GENERAL_WAIT
+        )
+        Report.result(Tests.child_event_created, result)
+        # Save the Script Event file
+        editor.AssetEditorWidgetRequestsBus(bus.Broadcast, "SaveAssetAs", file_path)
+
+        # Verify if file is created
+        result = helper.wait_for_condition(lambda: os.path.exists(file_path), 3 * GENERAL_WAIT)
+        Report.result(Tests.file_saved, result)
+
+    def create_parameter(file_path: str) -> None:
+        add_param = container.findChild(QtWidgets.QFrame, "Parameters").findChild(QtWidgets.QToolButton, "")
+        add_param.click()
+        result = helper.wait_for_condition(
+            lambda: asset_editor_widget.findChild(QtWidgets.QFrame, "[0]") is not None, GENERAL_WAIT
+        )
+        Report.result(Tests.parameter_created, result)
+        editor.AssetEditorWidgetRequestsBus(bus.Broadcast, "SaveAssetAs", file_path)
+
+    def remove_parameter(file_path: str) -> None:
+        remove_param = container.findChild(QtWidgets.QFrame, "[0]").findChild(QtWidgets.QToolButton, "")
+        remove_param.click()
+        result = helper.wait_for_condition(
+            lambda: asset_editor_widget.findChild(QtWidgets.QFrame, "[0]") is None, GENERAL_WAIT
+        )
+        Report.result(Tests.parameter_removed, result)
+        editor.AssetEditorWidgetRequestsBus(bus.Broadcast, "SaveAssetAs", file_path)
+
+    # 1) Open Asset Editor
+    general.idle_enable(True)
+    # Initially close the Asset Editor and then reopen to ensure we don't have any existing assets open
+    general.close_pane("Asset Editor")
+    general.open_pane("Asset Editor")
+    helper.wait_for_condition(lambda: general.is_pane_visible("Asset Editor"), 5.0)
+
+    # 2) Get Asset Editor Qt object
+    editor_window = pyside_utils.get_editor_main_window()
+    asset_editor_widget = editor_window.findChild(QtWidgets.QDockWidget, "Asset Editor").findChild(
+        QtWidgets.QWidget, "AssetEditorWindowClass"
+    )
+    container = asset_editor_widget.findChild(QtWidgets.QWidget, "ContainerForRows")
+    menu_bar = asset_editor_widget.findChild(QtWidgets.QMenuBar)
+
+    # 3) Create new Script Event Asset
+    create_script_event(asset_editor_widget, FILE_PATH)
+
+    # 4) Add Parameter to Event
+    create_parameter(FILE_PATH)
+
+    # 5) Remove Parameter from Event
+    remove_parameter(FILE_PATH)
+
+
+if __name__ == "__main__":
+    import ImportPathHelper as imports
+
+    imports.init()
+    from editor_python_test_tools.utils import Report
+
+    Report.start_test(ScriptEvent_AddRemoveParameter_ActionsSuccessful)

AutomatedTesting/Gem/PythonTests/scripting/TestSuite_Periodic.py

@@ -186,6 +186,18 @@ class TestAutomation(TestAutomationBase):
         from . import Node_HappyPath_DuplicateNode as test_module
         self._run_test(request, workspace, editor, test_module)
 
+    def test_ScriptEvent_AddRemoveParameter_ActionsSuccessful(self, request, workspace, editor, launcher_platform):
+        def teardown():
+            file_system.delete(
+                [os.path.join(workspace.paths.project(), "ScriptCanvas", "test_file.scriptevent")], True, True
+            )
+        request.addfinalizer(teardown)
+        file_system.delete(
+            [os.path.join(workspace.paths.project(), "ScriptCanvas", "test_file.scriptevent")], True, True
+        )
+        from . import ScriptEvent_AddRemoveParameter_ActionsSuccessful as test_module
+        self._run_test(request, workspace, editor, test_module)
+
 # NOTE: We had to use hydra_test_utils.py, as TestAutomationBase run_test method
 # fails because of pyside_utils import
 @pytest.mark.SUITE_periodic

AutomatedTesting/Levels/Simple/Simple.ly

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:804193a2afd68cd1e6bec8155ea11400566f2941fbd6eb0c324839ebcd10192d
-size 8492
+oid sha256:302d6172156e8ed665e44e206d81f54f1b0f1008d73327300ea92f8c1159780b
+size 11820

AutomatedTesting/Registry/awscoreconfiguration.setreg

@@ -3,7 +3,7 @@
     {
         "AWSCore": 
         {
-            "ProfileName": "default",
+            "ProfileName": "AWSAutomationTest",
             "ResourceMappingConfigFileName": "aws_resource_mappings.json"
         }
     } 

AutomatedTesting/preview.png

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:40949893ed7009eeaa90b7ce6057cb6be9dfaf7b162e3c26ba9dadf985939d7d
-size 2038
+oid sha256:b9cd9d6f67440c193a85969ec5c082c6343e6d1fff3b6f209a0a6931eb22dd47
+size 2949

Code/CryEngine/CrySystem/SystemInit.cpp

@@ -2017,8 +2017,8 @@ void CSystem::CreateSystemVars()
     REGISTER_CVAR2("sys_streaming_in_blocks", &g_cvars.sys_streaming_in_blocks, 1, VF_NULL,
         "Streaming of large files happens in blocks");
 
-#if (defined(WIN32) || defined(WIN64)) && !defined(_RELEASE)
-    REGISTER_CVAR2("sys_float_exceptions", &g_cvars.sys_float_exceptions, 3, 0, "Use or not use floating point exceptions.");
+#if (defined(WIN32) || defined(WIN64)) && defined(_DEBUG)
+    REGISTER_CVAR2("sys_float_exceptions", &g_cvars.sys_float_exceptions, 2, 0, "Use or not use floating point exceptions.");
 #else // Float exceptions by default disabled for console builds.
     REGISTER_CVAR2("sys_float_exceptions", &g_cvars.sys_float_exceptions, 0, 0, "Use or not use floating point exceptions.");
 #endif

Code/Framework/AzFramework/AzFramework/Font/FontInterface.h

@@ -54,7 +54,7 @@ namespace AzFramework
         AZ::Matrix3x4 m_transform = AZ::Matrix3x4::Identity(); //!< Transform to apply to text quads
         bool m_monospace = false; //!< disable character proportional spacing
         bool m_depthTest = false; //!< Test character against the depth buffer
-        bool m_virtual800x600ScreenSize = true; //!< Text placement and size are scaled relative to a virtual 800x600 resolution
+        bool m_virtual800x600ScreenSize = false; //!< Text placement and size are scaled relative to a virtual 800x600 resolution
         bool m_scaleWithWindow = false; //!< Font gets bigger as the window gets bigger
         bool m_multiline = true; //!< text respects ascii newline characters
     };

Code/Framework/AzFramework/AzFramework/ProjectManager/ProjectManager.cpp

@@ -78,7 +78,7 @@ namespace AzFramework::ProjectManager
                 projectJsonPath.c_str());
         }
 
-        if (LaunchProjectManager(engineRootPath))
+        if (LaunchProjectManager())
         {
             AZ_TracePrintf("ProjectManager", "Project Manager launched successfully, requesting exit.");
             return ProjectPathCheckResult::ProjectManagerLaunched;
@@ -87,7 +87,7 @@ namespace AzFramework::ProjectManager
         return ProjectPathCheckResult::ProjectManagerLaunchFailed;
     }
 
-    bool LaunchProjectManager([[maybe_unused]] const AZ::IO::FixedMaxPath& engineRootPath)
+    bool LaunchProjectManager(const AZStd::string& commandLineArgs)
     {
         bool launchSuccess = false;
 #if (AZ_TRAIT_AZFRAMEWORK_USE_PROJECT_MANAGER)
@@ -109,7 +109,7 @@ namespace AzFramework::ProjectManager
             }
 
             AzFramework::ProcessLauncher::ProcessLaunchInfo processLaunchInfo;
-            processLaunchInfo.m_commandlineParameters = executablePath.String();
+            processLaunchInfo.m_commandlineParameters = executablePath.String() + commandLineArgs;
             launchSuccess = AzFramework::ProcessLauncher::LaunchUnwatchedProcess(processLaunchInfo);
         }
         if (ownsSystemAllocator)

Code/Framework/AzFramework/AzFramework/ProjectManager/ProjectManager.h

@@ -12,6 +12,7 @@
 #pragma once
 
 #include <AzCore/IO/Path/Path_fwd.h>
+#include <AzCore/std/string/string.h>
 
 namespace AzFramework::ProjectManager
 {
@@ -21,8 +22,16 @@ namespace AzFramework::ProjectManager
         ProjectManagerLaunched = 0,
         ProjectPathFound = 1
     };
-    // Check for a project name, if not found, attempts to launch project manager and returns false
+
+    //! Check for a project name, if not found, attempts to launch project manager and returns false
+    //! @param argc the number of arguments in argv
+    //! @param argv arguments provided to this executable
+    //! @return a ProjectPathCheckResult
     ProjectPathCheckResult CheckProjectPathProvided(const int argc, char* argv[]);
-    // Attempt to Launch the project manager.  Requires locating the engine root, project manager script, and python.
-    bool LaunchProjectManager(const AZ::IO::FixedMaxPath& engineRootPath);
+
+    //! Attempt to Launch the project manager, assuming the o3de executable exists in same folder as
+    //! current executable. Requires the o3de cli and python.
+    //! @param commandLineArgs additional command line arguments to provide to the project manager
+    //! @return true on success, false if failed to find or launch the executable
+    bool LaunchProjectManager(const AZStd::string& commandLineArgs = "");
 } // AzFramework::ProjectManager

Code/Framework/AzFramework/AzFramework/Session/ISessionHandlingRequests.h

@@ -12,6 +12,7 @@
 
 #pragma once
 
+#include <AzCore/RTTI/RTTI.h>
 #include <AzCore/std/string/string.h>
 
 namespace AzFramework
@@ -49,13 +50,17 @@ namespace AzFramework
     class ISessionHandlingClientRequests
     {
     public:
-        // Handle the player join session process
+        AZ_RTTI(ISessionHandlingClientRequests, "{41DE6BD3-72BC-4443-BFF9-5B1B9396657A}");
+        ISessionHandlingClientRequests() = default;
+        virtual ~ISessionHandlingClientRequests() = default;
+
+        // Request the player join session
         // @param  sessionConnectionConfig The required properties to handle the player join session process
         // @return The result of player join session process
-        virtual bool HandlePlayerJoinSession(const SessionConnectionConfig& sessionConnectionConfig) = 0;
+        virtual bool RequestPlayerJoinSession(const SessionConnectionConfig& sessionConnectionConfig) = 0;
 
-        // Handle the player leave session process
-        virtual void HandlePlayerLeaveSession() = 0;
+        // Request the connected player leave session
+        virtual void RequestPlayerLeaveSession() = 0;
     };
 
     //! ISessionHandlingServerRequests
@@ -63,6 +68,10 @@ namespace AzFramework
     class ISessionHandlingServerRequests
     {
     public:
+        AZ_RTTI(ISessionHandlingServerRequests, "{4F0C17BA-F470-4242-A8CB-EC7EA805257C}");
+        ISessionHandlingServerRequests() = default;
+        virtual ~ISessionHandlingServerRequests() = default;
+
         // Handle the destroy session process
         virtual void HandleDestroySession() = 0;
 
@@ -74,5 +83,10 @@ namespace AzFramework
         // Handle the player leave session process
         // @param  playerConnectionConfig The required properties to handle the player leave session process
         virtual void HandlePlayerLeaveSession(const PlayerConnectionConfig& playerConnectionConfig) = 0;
+
+        // Retrieves the file location of a pem-encoded TLS certificate
+        // @return If successful, returns the file location of TLS certificate file; if not successful, returns
+        //         empty string.
+        virtual AZStd::string GetSessionCertificate() = 0;
     };
 } // namespace AzFramework

Code/Framework/AzFramework/AzFramework/Session/ISessionRequests.h

@@ -167,6 +167,9 @@ namespace AzFramework
         : public AZ::EBusTraits
     {
     public:
+        // Safeguard handler for multi-threaded use case
+        using MutexType = AZStd::recursive_mutex;
+
         //////////////////////////////////////////////////////////////////////////
         // EBusTraits overrides
         static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Multiple;

Code/Framework/AzFramework/AzFramework/Session/SessionNotifications.h

@@ -24,6 +24,9 @@ namespace AzFramework
         : public AZ::EBusTraits
     {
     public:
+        // Safeguard handler for multi-threaded use case
+        using MutexType = AZStd::recursive_mutex;
+
         //////////////////////////////////////////////////////////////////////////
         // EBusTraits overrides
         static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Multiple;

Code/Framework/AzFramework/AzFramework/Spawnable/Spawnable.cpp

@@ -21,22 +21,6 @@ namespace AzFramework
     {
     }
 
-    Spawnable::Spawnable(Spawnable&& other)
-        : m_entities(AZStd::move(other.m_entities))
-    {
-    }
-
-
-    Spawnable& Spawnable::operator=(Spawnable&& other)
-    {
-        if (this != &other)
-        {
-            m_entities = AZStd::move(other.m_entities);
-        }
-
-        return *this;
-    }
-
     const Spawnable::EntityList& Spawnable::GetEntities() const
     {
         return m_entities;

Code/Framework/AzFramework/AzFramework/Spawnable/Spawnable.h

@@ -41,11 +41,11 @@ namespace AzFramework
         Spawnable() = default;
         explicit Spawnable(const AZ::Data::AssetId& id, AssetStatus status = AssetStatus::NotLoaded);
         Spawnable(const Spawnable& rhs) = delete;
-        Spawnable(Spawnable&& other);
+        Spawnable(Spawnable&& other) = delete;
         ~Spawnable() override = default;
 
         Spawnable& operator=(const Spawnable& rhs) = delete;
-        Spawnable& operator=(Spawnable&& other);
+        Spawnable& operator=(Spawnable&& other) = delete;
 
         const EntityList& GetEntities() const;
         EntityList& GetEntities();

Code/Framework/AzFramework/AzFramework/Spawnable/SpawnableEntitiesContainer.cpp

@@ -38,19 +38,20 @@ namespace AzFramework
     void SpawnableEntitiesContainer::SpawnAllEntities()
     {
         AZ_Assert(m_threadData, "Calling SpawnAllEntities on a Spawnable container that's not set.");
-        SpawnableEntitiesInterface::Get()->SpawnAllEntities(m_threadData->m_spawnedEntitiesTicket);
+        SpawnableEntitiesInterface::Get()->SpawnAllEntities(m_threadData->m_spawnedEntitiesTicket, SpawnablePriority_Default);
     }
 
     void SpawnableEntitiesContainer::SpawnEntities(AZStd::vector<size_t> entityIndices)
     {
         AZ_Assert(m_threadData, "Calling SpawnEntities on a Spawnable container that's not set.");
-        SpawnableEntitiesInterface::Get()->SpawnEntities(m_threadData->m_spawnedEntitiesTicket, AZStd::move(entityIndices));
+        SpawnableEntitiesInterface::Get()->SpawnEntities(
+            m_threadData->m_spawnedEntitiesTicket, SpawnablePriority_Default, AZStd::move(entityIndices));
     }
 
     void SpawnableEntitiesContainer::DespawnAllEntities()
     {
         AZ_Assert(m_threadData, "Calling DespawnEntities on a Spawnable container that's not set.");
-        SpawnableEntitiesInterface::Get()->DespawnAllEntities(m_threadData->m_spawnedEntitiesTicket);
+        SpawnableEntitiesInterface::Get()->DespawnAllEntities(m_threadData->m_spawnedEntitiesTicket, SpawnablePriority_Default);
     }
 
     void SpawnableEntitiesContainer::Reset(AZ::Data::Asset<Spawnable> spawnable)
@@ -66,8 +67,10 @@ namespace AzFramework
             m_monitor.Disconnect();
             m_monitor.m_threadData.reset();
 
-            SpawnableEntitiesInterface::Get()->Barrier(m_threadData->m_spawnedEntitiesTicket,
-                [threadData = m_threadData](EntitySpawnTicket&) mutable
+            SpawnableEntitiesInterface::Get()->Barrier(
+                m_threadData->m_spawnedEntitiesTicket,
+                SpawnablePriority_Default,
+                [threadData = m_threadData](EntitySpawnTicket::Id) mutable
                 {
                     threadData.reset();
                 });
@@ -83,8 +86,10 @@ namespace AzFramework
     void SpawnableEntitiesContainer::Alert(AlertCallback callback)
     {
         AZ_Assert(m_threadData, "Calling DespawnEntities on a Spawnable container that's not set.");
-        SpawnableEntitiesInterface::Get()->Barrier(m_threadData->m_spawnedEntitiesTicket,
-            [generation = m_threadData->m_generation, callback = AZStd::move(callback)](EntitySpawnTicket&)
+        SpawnableEntitiesInterface::Get()->Barrier(
+            m_threadData->m_spawnedEntitiesTicket,
+            SpawnablePriority_Default,
+            [generation = m_threadData->m_generation, callback = AZStd::move(callback)](EntitySpawnTicket::Id)
             {
                 callback(generation);
             });
@@ -110,6 +115,7 @@ namespace AzFramework
         AZ_Assert(m_threadData, "SpawnableEntitiesContainer is monitoring a spawnable, but doesn't have the associated data.");
 
         AZ_TracePrintf("Spawnables", "Reloading spawnable '%s'.\n", replacementAsset.GetHint().c_str());
-        SpawnableEntitiesInterface::Get()->ReloadSpawnable(m_threadData->m_spawnedEntitiesTicket, AZStd::move(replacementAsset));
+        SpawnableEntitiesInterface::Get()->ReloadSpawnable(
+            m_threadData->m_spawnedEntitiesTicket, SpawnablePriority_Default, AZStd::move(replacementAsset));
     }
 } // namespace AzFramework

Code/Framework/AzFramework/AzFramework/Spawnable/SpawnableEntitiesInterface.cpp

@@ -239,7 +239,9 @@ namespace AzFramework
     {
         auto manager = SpawnableEntitiesInterface::Get();
         AZ_Assert(manager, "Attempting to create an entity spawn ticket while the SpawnableEntitiesInterface has no implementation.");
-        m_payload = manager->CreateTicket(AZStd::move(spawnable));
+        AZStd::pair<EntitySpawnTicket::Id, void*> result = manager->CreateTicket(AZStd::move(spawnable));
+        m_id = result.first;
+        m_payload = result.second;
     }
 
     EntitySpawnTicket::~EntitySpawnTicket()
@@ -250,6 +252,7 @@ namespace AzFramework
             AZ_Assert(manager, "Attempting to destroy an entity spawn ticket while the SpawnableEntitiesInterface has no implementation.");
             manager->DestroyTicket(m_payload);
             m_payload = nullptr;
+            m_id = 0;
         }
     }
 
@@ -263,12 +266,20 @@ namespace AzFramework
                 AZ_Assert(manager, "Attempting to destroy an entity spawn ticket while the SpawnableEntitiesInterface has no implementation.");
                 manager->DestroyTicket(m_payload);
             }
+            m_id = rhs.m_id;
+            rhs.m_id = 0;
+
             m_payload = rhs.m_payload;
             rhs.m_payload = nullptr;
         }
         return *this;
     }
 
+    auto EntitySpawnTicket::GetId() const -> Id
+    {
+        return m_id;
+    }
+
     bool EntitySpawnTicket::IsValid() const
     {
         return m_payload != nullptr;

Code/Framework/AzFramework/AzFramework/Spawnable/SpawnableEntitiesInterface.h

@@ -14,6 +14,7 @@
 
 #include <AzCore/Asset/AssetCommon.h>
 #include <AzCore/Interface/Interface.h>
+#include <AzCore/RTTI/TypeSafeIntegral.h>
 #include <AzCore/std/functional.h>
 #include <AzFramework/Spawnable/Spawnable.h>
 
@@ -24,6 +25,14 @@ namespace AZ
 
 namespace AzFramework
 {
+    AZ_TYPE_SAFE_INTEGRAL(SpawnablePriority, uint8_t);
+
+    inline static constexpr SpawnablePriority SpawnablePriority_Highest  { 0 };
+    inline static constexpr SpawnablePriority SpawnablePriority_High     { 32 };
+    inline static constexpr SpawnablePriority SpawnablePriority_Default  { 128 };
+    inline static constexpr SpawnablePriority SpawnablePriority_Low      { 192 };
+    inline static constexpr SpawnablePriority SpawnablePriority_Lowest   { 255 };
+
     class SpawnableEntityContainerView
     {
     public:
@@ -124,16 +133,18 @@ namespace AzFramework
         SpawnableIndexEntityIterator m_end;
     };
 
-    //! Requests to the SpawnableEntitiesInterface require a ticket with a valid spawnable that be used as a template. A ticket can
-    //! be reused for multiple calls on the same spawnable and is safe to use by multiple threads at the same time. Entities created
+    //! Requests to the SpawnableEntitiesInterface require a ticket with a valid spawnable that is used as a template. A ticket can
+    //! be reused for multiple calls on the same spawnable and is safe to be used by multiple threads at the same time. Entities created
     //! from the spawnable may be tracked by the ticket and so using the same ticket is needed to despawn the exact entities created
-    //! by a call so spawn entities. The life cycle of the spawned entities is tied to the ticket and all entities spawned using a
+    //! by a call to spawn entities. The life cycle of the spawned entities is tied to the ticket and all entities spawned using a
     //! ticket will be despawned when it's deleted.
     class EntitySpawnTicket
     {
     public:
         friend class SpawnableEntitiesDefinition;
 
+        using Id = uint64_t;
+
         EntitySpawnTicket() = default;
         EntitySpawnTicket(const EntitySpawnTicket&) = delete;
         EntitySpawnTicket(EntitySpawnTicket&& rhs);
@@ -143,26 +154,37 @@ namespace AzFramework
         EntitySpawnTicket& operator=(const EntitySpawnTicket&) = delete;
         EntitySpawnTicket& operator=(EntitySpawnTicket&& rhs);
 
+        Id GetId() const;
         bool IsValid() const;
 
     private:
         void* m_payload{ nullptr };
+        Id m_id { 0 }; //!< An id that uniquely identifies a ticket.
     };
 
-    using EntitySpawnCallback = AZStd::function<void(EntitySpawnTicket&, SpawnableConstEntityContainerView)>;
-    using EntityPreInsertionCallback = AZStd::function<void(EntitySpawnTicket&, SpawnableEntityContainerView)>;
-    using EntityDespawnCallback = AZStd::function<void(EntitySpawnTicket&)>;
-    using ReloadSpawnableCallback = AZStd::function<void(EntitySpawnTicket&, SpawnableConstEntityContainerView)>;
-    using ListEntitiesCallback = AZStd::function<void(EntitySpawnTicket&, SpawnableConstEntityContainerView)>;
-    using ListIndicesEntitiesCallback = AZStd::function<void(EntitySpawnTicket&, SpawnableConstIndexEntityContainerView)>;
-    using ClaimEntitiesCallback = AZStd::function<void(EntitySpawnTicket&, SpawnableEntityContainerView)>;
-    using BarrierCallback = AZStd::function<void(EntitySpawnTicket&)>;
+    using EntitySpawnCallback = AZStd::function<void(EntitySpawnTicket::Id, SpawnableConstEntityContainerView)>;
+    using EntityPreInsertionCallback = AZStd::function<void(EntitySpawnTicket::Id, SpawnableEntityContainerView)>;
+    using EntityDespawnCallback = AZStd::function<void(EntitySpawnTicket::Id)>;
+    using ReloadSpawnableCallback = AZStd::function<void(EntitySpawnTicket::Id, SpawnableConstEntityContainerView)>;
+    using ListEntitiesCallback = AZStd::function<void(EntitySpawnTicket::Id, SpawnableConstEntityContainerView)>;
+    using ListIndicesEntitiesCallback = AZStd::function<void(EntitySpawnTicket::Id, SpawnableConstIndexEntityContainerView)>;
+    using ClaimEntitiesCallback = AZStd::function<void(EntitySpawnTicket::Id, SpawnableEntityContainerView)>;
+    using BarrierCallback = AZStd::function<void(EntitySpawnTicket::Id)>;
 
     //! Interface definition to (de)spawn entities from a spawnable into the game world.
+    //! 
     //! While the callbacks of the individual calls are being processed they will block processing any other request. Callbacks can be
     //! issued from threads other than the one that issued the call, including the main thread.
+    //!
     //! Calls on the same ticket are guaranteed to be executed in the order they are issued. Note that when issuing requests from
     //! multiple threads on the same ticket the order in which the requests are assigned to the ticket is not guaranteed.
+    //!
+    //! Most calls have a priority with values that range from 0 (highest priority) to 255 (lowest priority). The implementation of this
+    //! interface may choose to use priority lanes which doesn't guarantee that higher priority requests happen before lower priority
+    //! requests if they don't pass the priority lane threshold. Priority lanes and their thresholds are implementation specific and may
+    //! differ between platforms. Note that if a call happened on a ticket with lower priority followed by a one with a higher priority
+    //! the first lower priority call will still need to complete before the second higher priority call can be executed and the priority
+    //! of the first call will not be updated.
     class SpawnableEntitiesDefinition
     {
     public:
@@ -173,40 +195,48 @@ namespace AzFramework
         virtual ~SpawnableEntitiesDefinition() = default;
 
         //! Spawn instances of all entities in the spawnable.
-        //! @param spawnable The Spawnable asset that will be used to create entity instances from.
         //! @param ticket Stores the results of the call. Use this ticket to spawn additional entities or to despawn them.
+        //! @param priority The priority at which this call will be executed.
         //! @param completionCallback Optional callback that's called when spawning entities has completed. This can be called from
         //!     a different thread than the one that made the function call. The returned list of entities contains all the newly
         //!     created entities.
-        virtual void SpawnAllEntities(EntitySpawnTicket& ticket, EntityPreInsertionCallback preInsertionCallback = {},
+        virtual void SpawnAllEntities(
+            EntitySpawnTicket& ticket, SpawnablePriority priority, EntityPreInsertionCallback preInsertionCallback = {},
             EntitySpawnCallback completionCallback = {}) = 0;
         //! Spawn instances of some entities in the spawnable.
         //! @param ticket Stores the results of the call. Use this ticket to spawn additional entities or to despawn them.
+        //! @param priority The priority at which this call will be executed.
         //! @param entityIndices The indices into the template entities stored in the spawnable that will be used to spawn entities from.
         //! @param completionCallback Optional callback that's called when spawning entities has completed. This can be called from
         //!     a different thread than the one that made this function call. The returned list of entities contains all the newly
         //!     created entities.
-        virtual void SpawnEntities(EntitySpawnTicket& ticket, AZStd::vector<size_t> entityIndices,
+        virtual void SpawnEntities(
+            EntitySpawnTicket& ticket, SpawnablePriority priority, AZStd::vector<size_t> entityIndices,
             EntityPreInsertionCallback preInsertionCallback = {}, EntitySpawnCallback completionCallback = {}) = 0;
         //! Removes all entities in the provided list from the environment.
         //! @param ticket The ticket previously used to spawn entities with.
+        //! @param priority The priority at which this call will be executed.
         //! @param completionCallback Optional callback that's called when despawning entities has completed. This can be called from
         //!     a different thread than the one that made this function call.
-        virtual void DespawnAllEntities(EntitySpawnTicket& ticket, EntityDespawnCallback completionCallback = {}) = 0;
+        virtual void DespawnAllEntities(
+            EntitySpawnTicket& ticket, SpawnablePriority priority, EntityDespawnCallback completionCallback = {}) = 0;
 
         //! Removes all entities in the provided list from the environment and reconstructs the entities from the provided spawnable.
-        //! @param ticket Stores the results of the call. Use this ticket to spawn additional entities or to despawn them.
+        //! @param ticket Holds the information on the entities to reload.
+        //! @param priority The priority at which this call will be executed.
         //! @param spawnable The spawnable that will replace the existing spawnable. Both need to have the same asset id.
         //! @param completionCallback Optional callback that's called when the entities have been reloaded. This can be called from
         //!     a different thread than the one that made this function call. The returned list of entities contains all the replacement
         //!     entities.
-        virtual void ReloadSpawnable(EntitySpawnTicket& ticket, AZ::Data::Asset<Spawnable> spawnable,
+        virtual void ReloadSpawnable(
+            EntitySpawnTicket& ticket, SpawnablePriority priority, AZ::Data::Asset<Spawnable> spawnable,
             ReloadSpawnableCallback completionCallback = {}) = 0;
 
         //! List all entities that are spawned using this ticket.
         //! @param ticket Only the entities associated with this ticket will be listed.
+        //! @param priority The priority at which this call will be executed.
         //! @param listCallback Required callback that will be called to list the entities on.
-        virtual void ListEntities(EntitySpawnTicket& ticket, ListEntitiesCallback listCallback) = 0;
+        virtual void ListEntities(EntitySpawnTicket& ticket, SpawnablePriority priority, ListEntitiesCallback listCallback) = 0;
         //! List all entities that are spawned using this ticket with their spawnable index.
         //!     Spawnables contain a flat list of entities, which are used as templates to spawn entities from. For every spawned entity
         //!     the index of the entity in the spawnable that was used as a template is stored. This version of ListEntities will return
@@ -214,17 +244,23 @@ namespace AzFramework
         //!     the same index may appear multiple times as there are no restriction on how many instance of a specific entity can be
         //!     created.
         //! @param ticket Only the entities associated with this ticket will be listed.
+        //! @param priority The priority at which this call will be executed.
         //! @param listCallback Required callback that will be called to list the entities and indices on.
-        virtual void ListIndicesAndEntities(EntitySpawnTicket& ticket, ListIndicesEntitiesCallback listCallback) = 0;
+        virtual void ListIndicesAndEntities(
+            EntitySpawnTicket& ticket, SpawnablePriority priority, ListIndicesEntitiesCallback listCallback) = 0;
         //! Claim all entities that are spawned using this ticket. Ownership of the entities is transferred from the ticket to the
         //!     caller through the callback. After this call the ticket will have no entities associated with it. The caller of
         //!     this function will need to manage the entities after this call.
         //! @param ticket Only the entities associated with this ticket will be released.
+        //! @param priority The priority at which this call will be executed.
         //! @param listCallback Required callback that will be called to transfer the entities through.
-        virtual void ClaimEntities(EntitySpawnTicket& ticket, ClaimEntitiesCallback listCallback) = 0;
+        virtual void ClaimEntities(EntitySpawnTicket& ticket, SpawnablePriority priority, ClaimEntitiesCallback listCallback) = 0;
 
         //! Blocks until all operations made on the provided ticket before the barrier call have completed.
-        virtual void Barrier(EntitySpawnTicket& ticket, BarrierCallback completionCallback) = 0;
+        //! @param ticket The ticket to monitor.
+        //! @param priority The priority at which this call will be executed.
+        //! @param completionCallback Required callback that will be called as soon as the barrier has been reached.
+        virtual void Barrier(EntitySpawnTicket& ticket, SpawnablePriority priority, BarrierCallback completionCallback) = 0;
 
         //! Register a handler for OnSpawned events.
         virtual void AddOnSpawnedHandler(AZ::Event<AZ::Data::Asset<Spawnable>>::Handler& handler) = 0;
@@ -233,7 +269,7 @@ namespace AzFramework
         virtual void AddOnDespawnedHandler(AZ::Event<AZ::Data::Asset<Spawnable>>::Handler& handler) = 0;
 
     protected:
-        [[nodiscard]] virtual void* CreateTicket(AZ::Data::Asset<Spawnable>&& spawnable) = 0;
+        [[nodiscard]] virtual AZStd::pair<EntitySpawnTicket::Id, void*> CreateTicket(AZ::Data::Asset<Spawnable>&& spawnable) = 0;
         virtual void DestroyTicket(void* ticket) = 0;
 
         template<typename T>

Code/Framework/AzFramework/AzFramework/Spawnable/SpawnableEntitiesManager.cpp

@@ -10,9 +10,11 @@
 *
 */
 
+#include <AzCore/Casting/numeric_cast.h>
 #include <AzCore/Component/ComponentApplicationBus.h>
 #include <AzCore/Serialization/IdUtils.h>
 #include <AzCore/Serialization/SerializeContext.h>
+#include <AzCore/Settings/SettingsRegistry.h>
 #include <AzCore/std/parallel/scoped_lock.h>
 #include <AzCore/std/smart_ptr/make_shared.h>
 #include <AzFramework/Components/TransformComponent.h>
@@ -22,128 +24,122 @@
 
 namespace AzFramework
 {
-    void SpawnableEntitiesManager::SpawnAllEntities(EntitySpawnTicket& ticket, EntityPreInsertionCallback preInsertionCallback,
+    template<typename T>
+    void SpawnableEntitiesManager::QueueRequest(EntitySpawnTicket& ticket, SpawnablePriority priority, T&& request)
+    {
+        request.m_ticket = &GetTicketPayload<Ticket>(ticket);
+        Queue& queue = priority <= m_highPriorityThreshold ? m_highPriorityQueue : m_regularPriorityQueue;
+        {
+            AZStd::scoped_lock queueLock(queue.m_pendingRequestMutex);
+            request.m_requestId = GetTicketPayload<Ticket>(ticket).m_nextRequestId++;
+            queue.m_pendingRequest.push(AZStd::move(request));
+        }
+    }
+
+    SpawnableEntitiesManager::SpawnableEntitiesManager()
+    {
+        if (auto settingsRegistry = AZ::SettingsRegistry::Get(); settingsRegistry != nullptr)
+        {
+            AZ::u64 value = aznumeric_caster(m_highPriorityThreshold);
+            settingsRegistry->Get(value, "/O3DE/AzFramework/Spawnables/HighPriorityThreshold");
+            m_highPriorityThreshold = aznumeric_cast<SpawnablePriority>(AZStd::clamp(value, 0llu, 255llu));
+        }
+    }
+
+    void SpawnableEntitiesManager::SpawnAllEntities(
+        EntitySpawnTicket& ticket, SpawnablePriority priority, EntityPreInsertionCallback preInsertionCallback,
         EntitySpawnCallback completionCallback)
     {
         AZ_Assert(ticket.IsValid(), "Ticket provided to SpawnAllEntities hasn't been initialized.");
 
         SpawnAllEntitiesCommand queueEntry;
-        queueEntry.m_ticket = &ticket;
+        queueEntry.m_ticketId = ticket.GetId();
         queueEntry.m_completionCallback = AZStd::move(completionCallback);
         queueEntry.m_preInsertionCallback = AZStd::move(preInsertionCallback);
-        {
-            AZStd::scoped_lock queueLock(m_pendingRequestQueueMutex);
-            queueEntry.m_ticketId = GetTicketPayload<Ticket>(ticket).m_nextTicketId++;
-            m_pendingRequestQueue.push(AZStd::move(queueEntry));
-        }
+        QueueRequest(ticket, priority, AZStd::move(queueEntry));
     }
 
     void SpawnableEntitiesManager::SpawnEntities(
-        EntitySpawnTicket& ticket, AZStd::vector<size_t> entityIndices,
+        EntitySpawnTicket& ticket, SpawnablePriority priority, AZStd::vector<size_t> entityIndices,
         EntityPreInsertionCallback preInsertionCallback, EntitySpawnCallback completionCallback)
     {
         AZ_Assert(ticket.IsValid(), "Ticket provided to SpawnEntities hasn't been initialized.");
 
         SpawnEntitiesCommand queueEntry;
-        queueEntry.m_ticket = &ticket;
+        queueEntry.m_ticketId = ticket.GetId();
         queueEntry.m_entityIndices = AZStd::move(entityIndices);
         queueEntry.m_completionCallback = AZStd::move(completionCallback);
         queueEntry.m_preInsertionCallback = AZStd::move(preInsertionCallback);
-        {
-            AZStd::scoped_lock queueLock(m_pendingRequestQueueMutex);
-            queueEntry.m_ticketId = GetTicketPayload<Ticket>(ticket).m_nextTicketId++;
-            m_pendingRequestQueue.push(AZStd::move(queueEntry));
-        }
+        QueueRequest(ticket, priority, AZStd::move(queueEntry));
     }
 
-    void SpawnableEntitiesManager::DespawnAllEntities(EntitySpawnTicket& ticket, EntityDespawnCallback completionCallback)
+    void SpawnableEntitiesManager::DespawnAllEntities(
+        EntitySpawnTicket& ticket, SpawnablePriority priority, EntityDespawnCallback completionCallback)
     {
         AZ_Assert(ticket.IsValid(), "Ticket provided to DespawnAllEntities hasn't been initialized.");
 
         DespawnAllEntitiesCommand queueEntry;
-        queueEntry.m_ticket = &ticket;
+        queueEntry.m_ticketId = ticket.GetId();
         queueEntry.m_completionCallback = AZStd::move(completionCallback);
-        {
-            AZStd::scoped_lock queueLock(m_pendingRequestQueueMutex);
-            queueEntry.m_ticketId = GetTicketPayload<Ticket>(ticket).m_nextTicketId++;
-            m_pendingRequestQueue.push(AZStd::move(queueEntry));
-        }
+        QueueRequest(ticket, priority, AZStd::move(queueEntry));
     }
 
-    void SpawnableEntitiesManager::ReloadSpawnable(EntitySpawnTicket& ticket, AZ::Data::Asset<Spawnable> spawnable,
+    void SpawnableEntitiesManager::ReloadSpawnable(
+        EntitySpawnTicket& ticket, SpawnablePriority priority, AZ::Data::Asset<Spawnable> spawnable,
         ReloadSpawnableCallback completionCallback)
     {
         AZ_Assert(ticket.IsValid(), "Ticket provided to ReloadSpawnable hasn't been initialized.");
 
         ReloadSpawnableCommand queueEntry;
-        queueEntry.m_ticket = &ticket;
+        queueEntry.m_ticketId = ticket.GetId();
         queueEntry.m_spawnable = AZStd::move(spawnable);
         queueEntry.m_completionCallback = AZStd::move(completionCallback);
-        {
-            AZStd::scoped_lock queueLock(m_pendingRequestQueueMutex);
-            queueEntry.m_ticketId = GetTicketPayload<Ticket>(ticket).m_nextTicketId++;
-            m_pendingRequestQueue.push(AZStd::move(queueEntry));
-        }
+        QueueRequest(ticket, priority, AZStd::move(queueEntry));
     }
 
-    void SpawnableEntitiesManager::ListEntities(EntitySpawnTicket& ticket, ListEntitiesCallback listCallback)
+    void SpawnableEntitiesManager::ListEntities(EntitySpawnTicket& ticket, SpawnablePriority priority, ListEntitiesCallback listCallback)
     {
         AZ_Assert(listCallback, "ListEntities called on spawnable entities without a valid callback to use.");
         AZ_Assert(ticket.IsValid(), "Ticket provided to ListEntities hasn't been initialized.");
 
         ListEntitiesCommand queueEntry;
-        queueEntry.m_ticket = &ticket;
+        queueEntry.m_ticketId = ticket.GetId();
         queueEntry.m_listCallback = AZStd::move(listCallback);
-        {
-            AZStd::scoped_lock queueLock(m_pendingRequestQueueMutex);
-            queueEntry.m_ticketId = GetTicketPayload<Ticket>(ticket).m_nextTicketId++;
-            m_pendingRequestQueue.push(AZStd::move(queueEntry));
-        }
+        QueueRequest(ticket, priority, AZStd::move(queueEntry));
     }
 
-    void SpawnableEntitiesManager::ListIndicesAndEntities(EntitySpawnTicket& ticket, ListIndicesEntitiesCallback listCallback)
+    void SpawnableEntitiesManager::ListIndicesAndEntities(
+        EntitySpawnTicket& ticket, SpawnablePriority priority, ListIndicesEntitiesCallback listCallback)
     {
         AZ_Assert(listCallback, "ListEntities called on spawnable entities without a valid callback to use.");
         AZ_Assert(ticket.IsValid(), "Ticket provided to ListEntities hasn't been initialized.");
 
         ListIndicesEntitiesCommand queueEntry;
-        queueEntry.m_ticket = &ticket;
+        queueEntry.m_ticketId = ticket.GetId();
         queueEntry.m_listCallback = AZStd::move(listCallback);
-        {
-            AZStd::scoped_lock queueLock(m_pendingRequestQueueMutex);
-            queueEntry.m_ticketId = GetTicketPayload<Ticket>(ticket).m_nextTicketId++;
-            m_pendingRequestQueue.push(AZStd::move(queueEntry));
-        }
+        QueueRequest(ticket, priority, AZStd::move(queueEntry));
     }
 
-    void SpawnableEntitiesManager::ClaimEntities(EntitySpawnTicket& ticket, ClaimEntitiesCallback listCallback)
+    void SpawnableEntitiesManager::ClaimEntities(EntitySpawnTicket& ticket, SpawnablePriority priority, ClaimEntitiesCallback listCallback)
     {
         AZ_Assert(listCallback, "ClaimEntities called on spawnable entities without a valid callback to use.");
         AZ_Assert(ticket.IsValid(), "Ticket provided to ClaimEntities hasn't been initialized.");
 
         ClaimEntitiesCommand queueEntry;
-        queueEntry.m_ticket = &ticket;
+        queueEntry.m_ticketId = ticket.GetId();
         queueEntry.m_listCallback = AZStd::move(listCallback);
-        {
-            AZStd::scoped_lock queueLock(m_pendingRequestQueueMutex);
-            queueEntry.m_ticketId = GetTicketPayload<Ticket>(ticket).m_nextTicketId++;
-            m_pendingRequestQueue.push(AZStd::move(queueEntry));
-        }
+        QueueRequest(ticket, priority, AZStd::move(queueEntry));
     }
 
-    void SpawnableEntitiesManager::Barrier(EntitySpawnTicket& ticket, BarrierCallback completionCallback)
+    void SpawnableEntitiesManager::Barrier(EntitySpawnTicket& ticket, SpawnablePriority priority, BarrierCallback completionCallback)
     {
         AZ_Assert(completionCallback, "Barrier on spawnable entities called without a valid callback to use.");
         AZ_Assert(ticket.IsValid(), "Ticket provided to Barrier hasn't been initialized.");
 
         BarrierCommand queueEntry;
-        queueEntry.m_ticket = &ticket;
+        queueEntry.m_ticketId = ticket.GetId();
         queueEntry.m_completionCallback = AZStd::move(completionCallback);
-        {
-            AZStd::scoped_lock queueLock(m_pendingRequestQueueMutex);
-            queueEntry.m_ticketId = GetTicketPayload<Ticket>(ticket).m_nextTicketId++;
-            m_pendingRequestQueue.push(AZStd::move(queueEntry));
-        }
+        QueueRequest(ticket, priority, AZStd::move(queueEntry));
     }
 
     void SpawnableEntitiesManager::AddOnSpawnedHandler(AZ::Event<AZ::Data::Asset<Spawnable>>::Handler& handler)
@@ -156,34 +152,54 @@ namespace AzFramework
         handler.Connect(m_onDespawnedEvent);
     }
 
-    auto SpawnableEntitiesManager::ProcessQueue() -> CommandQueueStatus
+    auto SpawnableEntitiesManager::ProcessQueue(CommandQueuePriority priority) -> CommandQueueStatus
+    {
+        CommandQueueStatus result = CommandQueueStatus::NoCommandsLeft;
+        if ((priority & CommandQueuePriority::High) == CommandQueuePriority::High)
+        {
+            if (ProcessQueue(m_highPriorityQueue) == CommandQueueStatus::HasCommandsLeft)
+            {
+                result = CommandQueueStatus::HasCommandsLeft;
+            }
+        }
+        if ((priority & CommandQueuePriority::Regular) == CommandQueuePriority::Regular)
+        {
+            if (ProcessQueue(m_regularPriorityQueue) == CommandQueueStatus::HasCommandsLeft)
+            {
+                result = CommandQueueStatus::HasCommandsLeft;
+            }
+        }
+        return result;
+    }
+
+    auto SpawnableEntitiesManager::ProcessQueue(Queue& queue) -> CommandQueueStatus
     {
         AZStd::queue<Requests> pendingRequestQueue;
         {
-            AZStd::scoped_lock queueLock(m_pendingRequestQueueMutex);
-            m_pendingRequestQueue.swap(pendingRequestQueue);
+            AZStd::scoped_lock queueLock(queue.m_pendingRequestMutex);
+            queue.m_pendingRequest.swap(pendingRequestQueue);
         }
 
-        if (!pendingRequestQueue.empty() || !m_delayedQueue.empty())
+        if (!pendingRequestQueue.empty() || !queue.m_delayed.empty())
         {
             AZ::SerializeContext* serializeContext = nullptr;
             AZ::ComponentApplicationBus::BroadcastResult(serializeContext, &AZ::ComponentApplicationBus::Events::GetSerializeContext);
             AZ_Assert(serializeContext, "Failed to retrieve serialization context.");
 
             // Only process the requests that are currently in this queue, not the ones that could be re-added if they still can't complete.
-            size_t delayedSize = m_delayedQueue.size();
+            size_t delayedSize = queue.m_delayed.size();
             for (size_t i = 0; i < delayedSize; ++i)
             {
-                Requests& request = m_delayedQueue.front();
+                Requests& request = queue.m_delayed.front();
                 bool result = AZStd::visit([this, serializeContext](auto&& args) -> bool
                     {
                         return ProcessRequest(args, *serializeContext);
                     }, request);
                 if (!result)
                 {
-                    m_delayedQueue.emplace_back(AZStd::move(request));
+                    queue.m_delayed.emplace_back(AZStd::move(request));
                 }
-                m_delayedQueue.pop_front();
+                queue.m_delayed.pop_front();
             }
 
             do
@@ -197,7 +213,7 @@ namespace AzFramework
                         }, request);
                     if (!result)
                     {
-                        m_delayedQueue.emplace_back(AZStd::move(request));
+                        queue.m_delayed.emplace_back(AZStd::move(request));
                     }
                     pendingRequestQueue.pop();
                 }
@@ -205,20 +221,22 @@ namespace AzFramework
                 // Spawning entities can result in more entities being queued to spawn. Repeat spawning until the queue is
                 // empty to avoid a chain of entity spawning getting dragged out over multiple frames.
                 {
-                    AZStd::scoped_lock queueLock(m_pendingRequestQueueMutex);
-                    m_pendingRequestQueue.swap(pendingRequestQueue);
+                    AZStd::scoped_lock queueLock(queue.m_pendingRequestMutex);
+                    queue.m_pendingRequest.swap(pendingRequestQueue);
                 }
             } while (!pendingRequestQueue.empty());
         }
 
-        return m_delayedQueue.empty() ? CommandQueueStatus::NoCommandLeft : CommandQueueStatus::HasCommandsLeft;
+        return queue.m_delayed.empty() ? CommandQueueStatus::NoCommandsLeft : CommandQueueStatus::HasCommandsLeft;
     }
 
-    void* SpawnableEntitiesManager::CreateTicket(AZ::Data::Asset<Spawnable>&& spawnable)
+    AZStd::pair<uint64_t, void*> SpawnableEntitiesManager::CreateTicket(AZ::Data::Asset<Spawnable>&& spawnable)
     {
+        static AZStd::atomic_uint64_t idCounter { 1 };
+
         auto result = aznew Ticket();
         result->m_spawnable = AZStd::move(spawnable);
-        return result;
+        return AZStd::make_pair<EntitySpawnTicket::Id, void*>(idCounter++, result);
     }
 
     void SpawnableEntitiesManager::DestroyTicket(void* ticket)
@@ -226,9 +244,9 @@ namespace AzFramework
         DestroyTicketCommand queueEntry;
         queueEntry.m_ticket = reinterpret_cast<Ticket*>(ticket);
         {
-            AZStd::scoped_lock queueLock(m_pendingRequestQueueMutex);
-            queueEntry.m_ticketId = reinterpret_cast<Ticket*>(ticket)->m_nextTicketId++;
-            m_pendingRequestQueue.push(AZStd::move(queueEntry));
+            AZStd::scoped_lock queueLock(m_regularPriorityQueue.m_pendingRequestMutex);
+            queueEntry.m_requestId = reinterpret_cast<Ticket*>(ticket)->m_nextRequestId++;
+            m_regularPriorityQueue.m_pendingRequest.push(AZStd::move(queueEntry));
         }
     }
 
@@ -251,8 +269,8 @@ namespace AzFramework
 
     bool SpawnableEntitiesManager::ProcessRequest(SpawnAllEntitiesCommand& request, AZ::SerializeContext& serializeContext)
     {
-        Ticket& ticket = GetTicketPayload<Ticket>(*request.m_ticket);
-        if (ticket.m_spawnable.IsReady() && request.m_ticketId == ticket.m_currentTicketId)
+        Ticket& ticket = *request.m_ticket;
+        if (ticket.m_spawnable.IsReady() && request.m_requestId == ticket.m_currentRequestId)
         {
             AZStd::vector<AZ::Entity*>& spawnedEntities = ticket.m_spawnedEntities;
             AZStd::vector<size_t>& spawnedEntityIndices = ticket.m_spawnedEntityIndices;
@@ -300,7 +318,7 @@ namespace AzFramework
             // Let other systems know about newly spawned entities for any pre-processing before adding to the scene/game context.
             if (request.m_preInsertionCallback)
             {
-                request.m_preInsertionCallback(*request.m_ticket, SpawnableEntityContainerView(
+                request.m_preInsertionCallback(request.m_ticketId, SpawnableEntityContainerView(
                         ticket.m_spawnedEntities.begin() + spawnedEntitiesInitialCount, ticket.m_spawnedEntities.end()));
             }
 
@@ -314,13 +332,13 @@ namespace AzFramework
             // Let other systems know about newly spawned entities for any post-processing after adding to the scene/game context.
             if (request.m_completionCallback)
             {
-                request.m_completionCallback(*request.m_ticket, SpawnableConstEntityContainerView(
+                request.m_completionCallback(request.m_ticketId, SpawnableConstEntityContainerView(
                         ticket.m_spawnedEntities.begin() + spawnedEntitiesInitialCount, ticket.m_spawnedEntities.end()));
             }
 
             m_onSpawnedEvent.Signal(ticket.m_spawnable);
 
-            ticket.m_currentTicketId++;
+            ticket.m_currentRequestId++;
             return true;
         }
         else
@@ -331,8 +349,8 @@ namespace AzFramework
 
     bool SpawnableEntitiesManager::ProcessRequest(SpawnEntitiesCommand& request, AZ::SerializeContext& serializeContext)
     {
-        Ticket& ticket = GetTicketPayload<Ticket>(*request.m_ticket);
-        if (ticket.m_spawnable.IsReady() && request.m_ticketId == ticket.m_currentTicketId)
+        Ticket& ticket = *request.m_ticket;
+        if (ticket.m_spawnable.IsReady() && request.m_requestId == ticket.m_currentRequestId)
         {
             AZStd::vector<AZ::Entity*>& spawnedEntities = ticket.m_spawnedEntities;
             AZStd::vector<size_t>& spawnedEntityIndices = ticket.m_spawnedEntityIndices;
@@ -367,9 +385,7 @@ namespace AzFramework
             // Let other systems know about newly spawned entities for any pre-processing before adding to the scene/game context.
             if (request.m_preInsertionCallback)
             {
-                request.m_preInsertionCallback(
-                    *request.m_ticket,
-                    SpawnableEntityContainerView(
+                request.m_preInsertionCallback(request.m_ticketId, SpawnableEntityContainerView(
                         ticket.m_spawnedEntities.begin() + spawnedEntitiesInitialCount, ticket.m_spawnedEntities.end()));
             }
 
@@ -382,13 +398,13 @@ namespace AzFramework
 
             if (request.m_completionCallback)
             {
-                request.m_completionCallback(*request.m_ticket, SpawnableConstEntityContainerView(
+                request.m_completionCallback(request.m_ticketId, SpawnableConstEntityContainerView(
                     ticket.m_spawnedEntities.begin() + spawnedEntitiesInitialCount, ticket.m_spawnedEntities.end()));
             }
 
             m_onSpawnedEvent.Signal(ticket.m_spawnable);
 
-            ticket.m_currentTicketId++;
+            ticket.m_currentRequestId++;
             return true;
         }
         else
@@ -400,8 +416,8 @@ namespace AzFramework
     bool SpawnableEntitiesManager::ProcessRequest(DespawnAllEntitiesCommand& request,
         [[maybe_unused]] AZ::SerializeContext& serializeContext)
     {
-        Ticket& ticket = GetTicketPayload<Ticket>(*request.m_ticket);
-        if (request.m_ticketId == ticket.m_currentTicketId)
+        Ticket& ticket = *request.m_ticket;
+        if (request.m_requestId == ticket.m_currentRequestId)
         {
             for (AZ::Entity* entity : ticket.m_spawnedEntities)
             {
@@ -417,12 +433,12 @@ namespace AzFramework
 
             if (request.m_completionCallback)
             {
-                request.m_completionCallback(*request.m_ticket);
+                request.m_completionCallback(request.m_ticketId);
             }
 
             m_onDespawnedEvent.Signal(ticket.m_spawnable);
 
-            ticket.m_currentTicketId++;
+            ticket.m_currentRequestId++;
             return true;
         }
         else
@@ -433,11 +449,11 @@ namespace AzFramework
 
     bool SpawnableEntitiesManager::ProcessRequest(ReloadSpawnableCommand& request, AZ::SerializeContext& serializeContext)
     {
-        Ticket& ticket = GetTicketPayload<Ticket>(*request.m_ticket);
+        Ticket& ticket = *request.m_ticket;
         AZ_Assert(ticket.m_spawnable.GetId() == request.m_spawnable.GetId(),
             "Spawnable is being reloaded, but the provided spawnable has a different asset id. "
             "This will likely result in unexpected entities being created.");
-        if (ticket.m_spawnable.IsReady() && request.m_ticketId == ticket.m_currentTicketId)
+        if (ticket.m_spawnable.IsReady() && request.m_requestId == ticket.m_currentRequestId)
         {
             // Delete the original entities.
             for (AZ::Entity* entity : ticket.m_spawnedEntities)
@@ -493,11 +509,11 @@ namespace AzFramework
 
             if (request.m_completionCallback)
             {
-                request.m_completionCallback(*request.m_ticket, SpawnableConstEntityContainerView(
+                request.m_completionCallback(request.m_ticketId, SpawnableConstEntityContainerView(
                     ticket.m_spawnedEntities.begin(), ticket.m_spawnedEntities.end()));
             }
 
-            ticket.m_currentTicketId++;
+            ticket.m_currentRequestId++;
 
             m_onSpawnedEvent.Signal(ticket.m_spawnable);
 
@@ -511,12 +527,12 @@ namespace AzFramework
 
     bool SpawnableEntitiesManager::ProcessRequest(ListEntitiesCommand& request, [[maybe_unused]] AZ::SerializeContext& serializeContext)
     {
-        Ticket& ticket = GetTicketPayload<Ticket>(*request.m_ticket);
-        if (request.m_ticketId == ticket.m_currentTicketId)
+        Ticket& ticket = *request.m_ticket;
+        if (request.m_requestId == ticket.m_currentRequestId)
         {
-            request.m_listCallback(*request.m_ticket, SpawnableConstEntityContainerView(
+            request.m_listCallback(request.m_ticketId, SpawnableConstEntityContainerView(
                 ticket.m_spawnedEntities.begin(), ticket.m_spawnedEntities.end()));
-            ticket.m_currentTicketId++;
+            ticket.m_currentRequestId++;
             return true;
         }
         else
@@ -527,17 +543,15 @@ namespace AzFramework
 
     bool SpawnableEntitiesManager::ProcessRequest(ListIndicesEntitiesCommand& request, [[maybe_unused]] AZ::SerializeContext& serializeContext)
     {
-        Ticket& ticket = GetTicketPayload<Ticket>(*request.m_ticket);
-        if (request.m_ticketId == ticket.m_currentTicketId)
+        Ticket& ticket = *request.m_ticket;
+        if (request.m_requestId == ticket.m_currentRequestId)
         {
             AZ_Assert(
                 ticket.m_spawnedEntities.size() == ticket.m_spawnedEntityIndices.size(),
                 "Entities and indices on spawnable ticket have gone out of sync.");
-            request.m_listCallback(
-                *request.m_ticket,
-                SpawnableConstIndexEntityContainerView(
+            request.m_listCallback(request.m_ticketId, SpawnableConstIndexEntityContainerView(
                     ticket.m_spawnedEntities.begin(), ticket.m_spawnedEntityIndices.begin(), ticket.m_spawnedEntities.size()));
-            ticket.m_currentTicketId++;
+            ticket.m_currentRequestId++;
             return true;
         }
         else
@@ -548,16 +562,16 @@ namespace AzFramework
 
     bool SpawnableEntitiesManager::ProcessRequest(ClaimEntitiesCommand& request, [[maybe_unused]] AZ::SerializeContext& serializeContext)
     {
-        Ticket& ticket = GetTicketPayload<Ticket>(*request.m_ticket);
-        if (request.m_ticketId == ticket.m_currentTicketId)
+        Ticket& ticket = *request.m_ticket;
+        if (request.m_requestId == ticket.m_currentRequestId)
         {
-            request.m_listCallback(*request.m_ticket, SpawnableEntityContainerView(
+            request.m_listCallback(request.m_ticketId, SpawnableEntityContainerView(
                 ticket.m_spawnedEntities.begin(), ticket.m_spawnedEntities.end()));
 
             ticket.m_spawnedEntities.clear();
             ticket.m_spawnedEntityIndices.clear();
 
-            ticket.m_currentTicketId++;
+            ticket.m_currentRequestId++;
             return true;
         }
         else
@@ -568,15 +582,15 @@ namespace AzFramework
 
     bool SpawnableEntitiesManager::ProcessRequest(BarrierCommand& request, [[maybe_unused]] AZ::SerializeContext& serializeContext)
     {
-        Ticket& ticket = GetTicketPayload<Ticket>(*request.m_ticket);
-        if (request.m_ticketId == ticket.m_currentTicketId)
+        Ticket& ticket = *request.m_ticket;
+        if (request.m_requestId == ticket.m_currentRequestId)
         {
             if (request.m_completionCallback)
             {
-                request.m_completionCallback(*request.m_ticket);
+                request.m_completionCallback(request.m_ticketId);
             }
 
-            ticket.m_currentTicketId++;
+            ticket.m_currentRequestId++;
             return true;
         }
         else
@@ -587,7 +601,7 @@ namespace AzFramework
 
     bool SpawnableEntitiesManager::ProcessRequest(DestroyTicketCommand& request, [[maybe_unused]] AZ::SerializeContext& serializeContext)
     {
-        if (request.m_ticketId == request.m_ticket->m_currentTicketId)
+        if (request.m_requestId == request.m_ticket->m_currentRequestId)
         {
             for (AZ::Entity* entity : request.m_ticket->m_spawnedEntities)
             {
@@ -606,24 +620,4 @@ namespace AzFramework
             return false;
         }
     }
-
-    bool SpawnableEntitiesManager::IsEqualTicket(const EntitySpawnTicket* lhs, const EntitySpawnTicket* rhs)
-    {
-        return GetTicketPayload<Ticket>(lhs) == GetTicketPayload<Ticket>(rhs);
-    }
-
-    bool SpawnableEntitiesManager::IsEqualTicket(const Ticket* lhs, const EntitySpawnTicket* rhs)
-    {
-        return lhs == GetTicketPayload<Ticket>(rhs);
-    }
-
-    bool SpawnableEntitiesManager::IsEqualTicket(const EntitySpawnTicket* lhs, const Ticket* rhs)
-    {
-        return GetTicketPayload<Ticket>(lhs) == rhs;
-    }
-
-    bool SpawnableEntitiesManager::IsEqualTicket(const Ticket* lhs, const Ticket* rhs)
-    {
-        return lhs = rhs;
-    }
 } // namespace AzFramework

Code/Framework/AzFramework/AzFramework/Spawnable/SpawnableEntitiesManager.h

@@ -29,8 +29,6 @@ namespace AZ
 
 namespace AzFramework
 {
-    using EntityIdMap = AZStd::unordered_map<AZ::EntityId, AZ::EntityId>;
-
     class SpawnableEntitiesManager
         : public SpawnableEntitiesInterface::Registrar
     {
@@ -38,31 +36,47 @@ namespace AzFramework
         AZ_RTTI(AzFramework::SpawnableEntitiesManager, "{6E14333F-128C-464C-94CA-A63B05A5E51C}");
         AZ_CLASS_ALLOCATOR(SpawnableEntitiesManager, AZ::SystemAllocator, 0);
 
+        using EntityIdMap = AZStd::unordered_map<AZ::EntityId, AZ::EntityId>;
+
         enum class CommandQueueStatus : bool
         {
             HasCommandsLeft,
-            NoCommandLeft
+            NoCommandsLeft
         };
 
+        enum class CommandQueuePriority
+        {
+            High = 1 << 0,
+            Regular = 1 << 1
+        };
+
+        SpawnableEntitiesManager();
         ~SpawnableEntitiesManager() override = default;
 
         //
         // The following functions are thread safe
         //
 
-        void SpawnAllEntities(EntitySpawnTicket& ticket, EntityPreInsertionCallback preInsertionCallback = {}, EntitySpawnCallback completionCallback = {}) override;
-        void SpawnEntities(EntitySpawnTicket& ticket, AZStd::vector<size_t> entityIndices, EntityPreInsertionCallback preInsertionCallback = {},
+        void SpawnAllEntities(
+            EntitySpawnTicket& ticket, SpawnablePriority priority, EntityPreInsertionCallback preInsertionCallback = {},
             EntitySpawnCallback completionCallback = {}) override;
-        void DespawnAllEntities(EntitySpawnTicket& ticket, EntityDespawnCallback completionCallback = {}) override;
+        void SpawnEntities(
+            EntitySpawnTicket& ticket, SpawnablePriority priority, AZStd::vector<size_t> entityIndices,
+            EntityPreInsertionCallback preInsertionCallback = {},
+            EntitySpawnCallback completionCallback = {}) override;
+        void DespawnAllEntities(
+            EntitySpawnTicket& ticket, SpawnablePriority priority, EntityDespawnCallback completionCallback = {}) override;
 
-        void ReloadSpawnable(EntitySpawnTicket& ticket, AZ::Data::Asset<Spawnable> spawnable,
+        void ReloadSpawnable(
+            EntitySpawnTicket& ticket, SpawnablePriority priority, AZ::Data::Asset<Spawnable> spawnable,
             ReloadSpawnableCallback completionCallback = {}) override;
 
-        void ListEntities(EntitySpawnTicket& ticket, ListEntitiesCallback listCallback) override;
-        void ListIndicesAndEntities(EntitySpawnTicket& ticket, ListIndicesEntitiesCallback listCallback) override;
-        void ClaimEntities(EntitySpawnTicket& ticket, ClaimEntitiesCallback listCallback) override;
+        void ListEntities(EntitySpawnTicket& ticket, SpawnablePriority priority, ListEntitiesCallback listCallback) override;
+        void ListIndicesAndEntities(
+            EntitySpawnTicket& ticket, SpawnablePriority priority, ListIndicesEntitiesCallback listCallback) override;
+        void ClaimEntities(EntitySpawnTicket& ticket, SpawnablePriority priority, ClaimEntitiesCallback listCallback) override;
 
-        void Barrier(EntitySpawnTicket& spawnInfo, BarrierCallback completionCallback) override;
+        void Barrier(EntitySpawnTicket& spawnInfo, SpawnablePriority priority, BarrierCallback completionCallback) override;
 
         void AddOnSpawnedHandler(AZ::Event<AZ::Data::Asset<Spawnable>>::Handler& handler) override;
         void AddOnDespawnedHandler(AZ::Event<AZ::Data::Asset<Spawnable>>::Handler& handler) override;
@@ -71,13 +85,9 @@ namespace AzFramework
         // The following function is thread safe but intended to be run from the main thread.
         //
 
-        CommandQueueStatus ProcessQueue();
+        CommandQueueStatus ProcessQueue(CommandQueuePriority priority);
 
     protected:
-        void* CreateTicket(AZ::Data::Asset<Spawnable>&& spawnable) override;
-        void DestroyTicket(void* ticket) override;
-
-    private:
         struct Ticket
         {
             AZ_CLASS_ALLOCATOR(Ticket, AZ::ThreadPoolAllocator, 0);
@@ -86,8 +96,8 @@ namespace AzFramework
             AZStd::vector<AZ::Entity*> m_spawnedEntities;
             AZStd::vector<size_t> m_spawnedEntityIndices;
             AZ::Data::Asset<Spawnable> m_spawnable;
-            uint32_t m_nextTicketId{ 0 }; //!< Next id for this ticket.
-            uint32_t m_currentTicketId{ 0 }; //!< The id for the command that should be executed.
+            uint32_t m_nextRequestId{ 0 }; //!< Next id for this ticket.
+            uint32_t m_currentRequestId { 0 }; //!< The id for the command that should be executed.
             bool m_loadAll{ true };
         };
 
@@ -95,64 +105,86 @@ namespace AzFramework
         {
             EntitySpawnCallback m_completionCallback;
             EntityPreInsertionCallback m_preInsertionCallback;
-            EntitySpawnTicket* m_ticket;
-            uint32_t m_ticketId;
+            Ticket* m_ticket;
+            EntitySpawnTicket::Id m_ticketId;
+            uint32_t m_requestId;
         };
         struct SpawnEntitiesCommand
         {
             AZStd::vector<size_t> m_entityIndices;
             EntitySpawnCallback m_completionCallback;
             EntityPreInsertionCallback m_preInsertionCallback;
-            EntitySpawnTicket* m_ticket;
-            uint32_t m_ticketId;
+            Ticket* m_ticket;
+            EntitySpawnTicket::Id m_ticketId;
+            uint32_t m_requestId;
         };
         struct DespawnAllEntitiesCommand
         {
             EntityDespawnCallback m_completionCallback;
-            EntitySpawnTicket* m_ticket;
-            uint32_t m_ticketId;
+            Ticket* m_ticket;
+            EntitySpawnTicket::Id m_ticketId;
+            uint32_t m_requestId;
         };
         struct ReloadSpawnableCommand
         {
             AZ::Data::Asset<Spawnable> m_spawnable;
             ReloadSpawnableCallback m_completionCallback;
-            EntitySpawnTicket* m_ticket;
-            uint32_t m_ticketId;
+            Ticket* m_ticket;
+            EntitySpawnTicket::Id m_ticketId;
+            uint32_t m_requestId;
         };
         struct ListEntitiesCommand
         {
             ListEntitiesCallback m_listCallback;
-            EntitySpawnTicket* m_ticket;
-            uint32_t m_ticketId;
+            Ticket* m_ticket;
+            EntitySpawnTicket::Id m_ticketId;
+            uint32_t m_requestId;
         };
         struct ListIndicesEntitiesCommand
         {
             ListIndicesEntitiesCallback m_listCallback;
-            EntitySpawnTicket* m_ticket;
-            uint32_t m_ticketId;
+            Ticket* m_ticket;
+            EntitySpawnTicket::Id m_ticketId;
+            uint32_t m_requestId;
         };
         struct ClaimEntitiesCommand
         {
             ClaimEntitiesCallback m_listCallback;
-            EntitySpawnTicket* m_ticket;
-            uint32_t m_ticketId;
+            Ticket* m_ticket;
+            EntitySpawnTicket::Id m_ticketId;
+            uint32_t m_requestId;
         };
         struct BarrierCommand
         {
             BarrierCallback m_completionCallback;
-            EntitySpawnTicket* m_ticket;
-            uint32_t m_ticketId;
+            Ticket* m_ticket;
+            EntitySpawnTicket::Id m_ticketId;
+            uint32_t m_requestId;
         };
         struct DestroyTicketCommand
         {
             Ticket* m_ticket;
-            uint32_t m_ticketId;
+            uint32_t m_requestId;
         };
 
         using Requests = AZStd::variant<
             SpawnAllEntitiesCommand, SpawnEntitiesCommand, DespawnAllEntitiesCommand, ReloadSpawnableCommand, ListEntitiesCommand,
             ListIndicesEntitiesCommand, ClaimEntitiesCommand, BarrierCommand, DestroyTicketCommand>;
 
+        struct Queue
+        {
+            AZStd::deque<Requests> m_delayed; //!< Requests that were processed before, but couldn't be completed.
+            AZStd::queue<Requests> m_pendingRequest; //!< Requests waiting to be processed for the first time.
+            AZStd::mutex m_pendingRequestMutex;
+        };
+
+        template<typename T>
+        void QueueRequest(EntitySpawnTicket& ticket, SpawnablePriority priority, T&& request);
+        AZStd::pair<EntitySpawnTicket::Id, void*> CreateTicket(AZ::Data::Asset<Spawnable>&& spawnable) override;
+        void DestroyTicket(void* ticket) override;
+
+        CommandQueueStatus ProcessQueue(Queue& queue);
+
         AZ::Entity* SpawnSingleEntity(const AZ::Entity& entityTemplate,
             AZ::SerializeContext& serializeContext);
 
@@ -169,16 +201,18 @@ namespace AzFramework
         bool ProcessRequest(BarrierCommand& request, AZ::SerializeContext& serializeContext);
         bool ProcessRequest(DestroyTicketCommand& request, AZ::SerializeContext& serializeContext);
 
-        [[nodiscard]] static bool IsEqualTicket(const EntitySpawnTicket* lhs, const EntitySpawnTicket* rhs);
-        [[nodiscard]] static bool IsEqualTicket(const Ticket* lhs, const EntitySpawnTicket* rhs);
-        [[nodiscard]] static bool IsEqualTicket(const EntitySpawnTicket* lhs, const Ticket* rhs);
-        [[nodiscard]] static bool IsEqualTicket(const Ticket* lhs, const Ticket* rhs);
-
-        AZStd::deque<Requests> m_delayedQueue; //!< Requests that were processed before, but couldn't be completed.
-        AZStd::queue<Requests> m_pendingRequestQueue;
-        AZStd::mutex m_pendingRequestQueueMutex;
+        Queue m_highPriorityQueue;
+        Queue m_regularPriorityQueue;
 
         AZ::Event<AZ::Data::Asset<Spawnable>> m_onSpawnedEvent;
         AZ::Event<AZ::Data::Asset<Spawnable>> m_onDespawnedEvent;
+
+        //! The threshold used to determine if a request goes in the regular (if bigger than the value) or high priority queue (if smaller
+        //! or equal to this value). The starting value of 64 is chosen as it's between default values SpawnablePriority_High and
+        //! SpawnablePriority_Default which gives users a bit of room to fine tune the priorities as this value can be configured
+        //! through the Settings Registry under the key "/O3DE/AzFramework/Spawnables/HighPriorityThreshold".
+        SpawnablePriority m_highPriorityThreshold { 64 };
     };
+
+    AZ_DEFINE_ENUM_BITWISE_OPERATORS(AzFramework::SpawnableEntitiesManager::CommandQueuePriority);
 } // namespace AzFramework

Code/Framework/AzFramework/AzFramework/Spawnable/SpawnableSystemComponent.cpp

@@ -48,10 +48,23 @@ namespace AzFramework
 
     void SpawnableSystemComponent::OnTick(float /*deltaTime*/, AZ::ScriptTimePoint /*time*/)
     {
-        m_entitiesManager.ProcessQueue();
+        m_entitiesManager.ProcessQueue(
+            SpawnableEntitiesManager::CommandQueuePriority::High | SpawnableEntitiesManager::CommandQueuePriority::Regular);
         RootSpawnableNotificationBus::ExecuteQueuedEvents();
     }
 
+    int SpawnableSystemComponent::GetTickOrder()
+    {
+        return AZ::ComponentTickBus::TICK_GAME;
+    }
+
+    void SpawnableSystemComponent::OnSystemTick()
+    {
+        // Handle only high priority spawning events such as those created from network. These need to happen even if the client
+        // doesn't have focus to avoid time-out issues for instance.
+        m_entitiesManager.ProcessQueue(SpawnableEntitiesManager::CommandQueuePriority::High);
+    }
+
     void SpawnableSystemComponent::OnCatalogLoaded([[maybe_unused]] const char* catalogFile)
     {
         if (!m_catalogAvailable)
@@ -168,7 +181,8 @@ namespace AzFramework
             SpawnableEntitiesManager::CommandQueueStatus queueStatus;
             do
             {
-                queueStatus = m_entitiesManager.ProcessQueue();
+                queueStatus = m_entitiesManager.ProcessQueue(
+                    SpawnableEntitiesManager::CommandQueuePriority::High | SpawnableEntitiesManager::CommandQueuePriority::Regular);
             } while (queueStatus == SpawnableEntitiesManager::CommandQueueStatus::HasCommandsLeft);
         }
 

Code/Framework/AzFramework/AzFramework/Spawnable/SpawnableSystemComponent.h

@@ -28,6 +28,7 @@ namespace AzFramework
     class SpawnableSystemComponent
         : public AZ::Component
         , public AZ::TickBus::Handler
+        , public AZ::SystemTickBus::Handler
         , public AssetCatalogEventBus::Handler
         , public RootSpawnableInterface::Registrar
         , public RootSpawnableNotificationBus::Handler
@@ -58,6 +59,13 @@ namespace AzFramework
         //
 
         void OnTick(float deltaTime, AZ::ScriptTimePoint time) override;
+        int GetTickOrder() override;
+
+        //
+        // SystemTickBus
+        //
+
+        void OnSystemTick() override;
 
         //
         // AssetCatalogEventBus

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

@@ -227,11 +227,33 @@ namespace AzToolsFramework
                     instanceToCreate->get(), commonRootEntityOwningInstance->get().GetTemplateId(), undoBatch.GetUndoBatch(),
                     AZStd::move(patch));
 
+                // Reset the transform of the container entity so that the new values aren't saved in the new prefab's dom.
+                // The new values were saved in the link, so propagation will apply them correctly.
+                {
+                    AZ::Entity* containerEntity = GetEntityById(containerEntityId);
+
+                    PrefabDom containerBeforeReset;
+                    m_instanceToTemplateInterface->GenerateDomForEntity(containerBeforeReset, *containerEntity);
+
+                    AZ::TransformBus::Event(containerEntityId, &AZ::TransformBus::Events::SetParent, AZ::EntityId());
+                    AZ::TransformBus::Event(containerEntityId, &AZ::TransformBus::Events::SetLocalTM, AZ::Transform::CreateIdentity());
+
+                    PrefabDom containerAfterReset;
+                    m_instanceToTemplateInterface->GenerateDomForEntity(containerAfterReset, *containerEntity);
+
+                    // Update the state of the entity
+                    PrefabUndoEntityUpdate* state = aznew PrefabUndoEntityUpdate(AZStd::to_string(static_cast<AZ::u64>(containerEntityId)));
+                    state->SetParent(undoBatch.GetUndoBatch());
+                    state->Capture(containerBeforeReset, containerAfterReset, containerEntityId);
+
+                    state->Redo();
+                }
+
                 // This clears any entities marked as dirty due to reparenting of entities during the process of creating a prefab.
-                // We are doing this so that the changes in those enities are not queued up twice for propagation.
+                // We are doing this so that the changes in those entities are not queued up twice for propagation.
                 AzToolsFramework::ToolsApplicationRequestBus::Broadcast(
                     &AzToolsFramework::ToolsApplicationRequestBus::Events::ClearDirtyEntities);
-                
+
                 // Select Container Entity
                 {
                     auto selectionUndo = aznew SelectionCommand({containerEntityId}, "Select Prefab Container Entity");

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/Spawnable/SpawnableUtils.cpp

@@ -24,17 +24,6 @@
 
 namespace AzToolsFramework::Prefab::SpawnableUtils
 {
-
-    AzFramework::Spawnable CreateSpawnable(const PrefabDom& prefabDom)
-    {
-        AzFramework::Spawnable spawnable;
-        AZStd::vector<AZ::Data::Asset<AZ::Data::AssetData>> referencedAssets;
-        [[maybe_unused]] bool result = CreateSpawnable(spawnable, prefabDom, referencedAssets);
-        AZ_Assert(result,
-            "Failed to Load Prefab Instance from given Prefab DOM while Spawnable creation.");
-        return spawnable;
-    }
-
     bool CreateSpawnable(AzFramework::Spawnable& spawnable, const PrefabDom& prefabDom)
     {
         AZStd::vector<AZ::Data::Asset<AZ::Data::AssetData>> referencedAssets;

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/Spawnable/SpawnableUtils.h

@@ -17,7 +17,6 @@
 
 namespace AzToolsFramework::Prefab::SpawnableUtils
 {
-    AzFramework::Spawnable CreateSpawnable(const PrefabDom& prefabDom);
     bool CreateSpawnable(AzFramework::Spawnable& spawnable, const PrefabDom& prefabDom);
     bool CreateSpawnable(AzFramework::Spawnable& spawnable, const PrefabDom& prefabDom, AZStd::vector<AZ::Data::Asset<AZ::Data::AssetData>>& referencedAssets);
 

Code/Framework/AzToolsFramework/AzToolsFramework/UI/PropertyEditor/EntityPropertyEditor.cpp

@@ -969,7 +969,8 @@ namespace AzToolsFramework
         {
             // Build up components to display
             SharedComponentArray sharedComponentArray;
-            BuildSharedComponentArray(sharedComponentArray, selectionEntityTypeInfo != SelectionEntityTypeInfo::OnlyStandardEntities);
+            BuildSharedComponentArray(sharedComponentArray,
+                !(selectionEntityTypeInfo == SelectionEntityTypeInfo::OnlyStandardEntities || selectionEntityTypeInfo == SelectionEntityTypeInfo::OnlyPrefabEntities));
 
             if (sharedComponentArray.size() == 0)
             {

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

@@ -2471,7 +2471,17 @@ namespace AzToolsFramework
                 break;
             }
         });
-
+        
+        AddAction(
+            m_actions, { QKeySequence(Qt::Key_U) },
+            /*ID_VIEWPORTUI_VISIBLE=*/50040, "Toggle ViewportUI", "Hide/Unhide Viewport UI",
+           [this]()
+        {
+                SetViewportUiClusterVisible(m_transformModeClusterId, !m_viewportUiVisible);
+                SetViewportUiClusterVisible(m_spaceCluster.m_spaceClusterId, !m_viewportUiVisible);
+                m_viewportUiVisible = !m_viewportUiVisible;
+        });
+       
         EditorMenuRequestBus::Broadcast(&EditorMenuRequests::RestoreEditMenuToDefault);
     }
 

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

@@ -306,6 +306,7 @@ namespace AzToolsFramework
         AzFramework::ClickDetector m_clickDetector; //!< Detect different types of mouse click.
         AzFramework::CursorState m_cursorState; //!< Track the mouse position and delta movement each frame.
         SpaceCluster m_spaceCluster; //!< Related viewport ui state for controlling the current reference space.
+        bool m_viewportUiVisible = true; //!< Used to hide/show the viewport ui elements.
     };
 
     //! The ETCS (EntityTransformComponentSelection) namespace contains functions and data used exclusively by

Code/Framework/AzToolsFramework/Tests/Prefab/Benchmark/SpawnableCreateBenchmarks.cpp

@@ -34,7 +34,8 @@ namespace Benchmark
         {
             state.PauseTiming();
 
-            auto spawnable = ::AzToolsFramework::Prefab::SpawnableUtils::CreateSpawnable(prefabDom);
+            AzFramework::Spawnable spawnable;
+            AzToolsFramework::Prefab::SpawnableUtils::CreateSpawnable(spawnable, prefabDom);
 
             state.ResumeTiming();
         }

Code/Framework/AzToolsFramework/Tests/Prefab/SpawnableCreateTests.cpp

@@ -40,7 +40,8 @@ namespace UnitTest
 
         //Create Spawnable
         auto& prefabDom = m_prefabSystemComponent->FindTemplateDom(instance->GetTemplateId());
-        auto spawnable = ::AzToolsFramework::Prefab::SpawnableUtils::CreateSpawnable(prefabDom);
+        AzFramework::Spawnable spawnable;
+        AzToolsFramework::Prefab::SpawnableUtils::CreateSpawnable(spawnable, prefabDom);
 
         EXPECT_EQ(spawnable.GetEntities().size() - 1, normalEntityCount); // 1 for container entity
         const auto& spawnableEntities = spawnable.GetEntities();
@@ -84,7 +85,8 @@ namespace UnitTest
 
         //Create Spawnable
         auto& prefabDom = m_prefabSystemComponent->FindTemplateDom(thirdInstance->GetTemplateId());
-        auto spawnable = ::AzToolsFramework::Prefab::SpawnableUtils::CreateSpawnable(prefabDom);
+        AzFramework::Spawnable spawnable;
+        AzToolsFramework::Prefab::SpawnableUtils::CreateSpawnable(spawnable, prefabDom);
 
         EXPECT_EQ(spawnable.GetEntities().size() - 1, normalEntityCount); // 1 for container entity
         const auto& spawnableEntities = spawnable.GetEntities();

Code/Framework/Tests/Spawnable/SpawnableEntitiesManagerTests.cpp

@@ -55,7 +55,11 @@ namespace UnitTest
             delete m_ticket;
             m_ticket = nullptr;
             // One more tick on the spawnable entities manager in order to delete the ticket fully.
-            m_manager->ProcessQueue();
+            while (m_manager->ProcessQueue(
+                       AzFramework::SpawnableEntitiesManager::CommandQueuePriority::High |
+                       AzFramework::SpawnableEntitiesManager::CommandQueuePriority::Regular) !=
+                   AzFramework::SpawnableEntitiesManager::CommandQueueStatus::NoCommandsLeft)
+                ;
 
             delete m_spawnableAsset;
             m_spawnableAsset = nullptr;
@@ -85,6 +89,10 @@ namespace UnitTest
         TestApplication* m_application { nullptr };
     };
 
+    //
+    // SpawnAllEntitities
+    //
+
     TEST_F(SpawnableEntitiesManagerTest, SpawnAllEntities_Call_AllEntitiesSpawned)
     {
         static constexpr size_t NumEntities = 4;
@@ -92,16 +100,72 @@ namespace UnitTest
 
         size_t spawnedEntitiesCount = 0;
         auto callback =
-            [&spawnedEntitiesCount](AzFramework::EntitySpawnTicket&, AzFramework::SpawnableConstEntityContainerView entities)
+            [&spawnedEntitiesCount](AzFramework::EntitySpawnTicket::Id, AzFramework::SpawnableConstEntityContainerView entities)
             {
                 spawnedEntitiesCount += entities.size();
             };
-        m_manager->SpawnAllEntities(*m_ticket, {}, AZStd::move(callback));
-        m_manager->ProcessQueue();
+        m_manager->SpawnAllEntities(*m_ticket, AzFramework::SpawnablePriority_Default, {}, AZStd::move(callback));
+        m_manager->ProcessQueue(AzFramework::SpawnableEntitiesManager::CommandQueuePriority::Regular);
 
         EXPECT_EQ(NumEntities, spawnedEntitiesCount);
     }
 
+    TEST_F(SpawnableEntitiesManagerTest, SpawnAllEntities_DeleteTicketBeforeCall_NoCrash)
+    {
+        {
+            AzFramework::EntitySpawnTicket ticket(*m_spawnableAsset);
+            m_manager->SpawnAllEntities(ticket, AzFramework::SpawnablePriority_Default);
+        }
+        m_manager->ProcessQueue(AzFramework::SpawnableEntitiesManager::CommandQueuePriority::Regular);
+    }
+
+
+    //
+    // SpawnEntities
+    //
+
+    TEST_F(SpawnableEntitiesManagerTest, SpawnEntities_DeleteTicketBeforeCall_NoCrash)
+    {
+        {
+            AzFramework::EntitySpawnTicket ticket(*m_spawnableAsset);
+            m_manager->SpawnEntities(ticket, AzFramework::SpawnablePriority_Default, {});
+        }
+        m_manager->ProcessQueue(AzFramework::SpawnableEntitiesManager::CommandQueuePriority::Regular);
+    }
+
+
+    //
+    // DespawnAllEntities
+    //
+
+    TEST_F(SpawnableEntitiesManagerTest, DespawnAllEntities_DeleteTicketBeforeCall_NoCrash)
+    {
+        {
+            AzFramework::EntitySpawnTicket ticket(*m_spawnableAsset);
+            m_manager->DespawnAllEntities(ticket, AzFramework::SpawnablePriority_Default);
+        }
+        m_manager->ProcessQueue(AzFramework::SpawnableEntitiesManager::CommandQueuePriority::Regular);
+    }
+
+
+    //
+    // ReloadSpawnable
+    //
+
+    TEST_F(SpawnableEntitiesManagerTest, ReloadSpawnable_DeleteTicketBeforeCall_NoCrash)
+    {
+        {
+            AzFramework::EntitySpawnTicket ticket(*m_spawnableAsset);
+            m_manager->ReloadSpawnable(ticket, AzFramework::SpawnablePriority_Default, *m_spawnableAsset);
+        }
+        m_manager->ProcessQueue(AzFramework::SpawnableEntitiesManager::CommandQueuePriority::Regular);
+    }
+
+
+    //
+    // ListEntitities
+    //
+
     TEST_F(SpawnableEntitiesManagerTest, ListEntities_Call_AllEntitiesAreReported)
     {
         static constexpr size_t NumEntities = 4;
@@ -110,7 +174,7 @@ namespace UnitTest
         bool allValidEntityIds = true;
         size_t spawnedEntitiesCount = 0;
         auto callback = [&allValidEntityIds, &spawnedEntitiesCount]
-            (AzFramework::EntitySpawnTicket&, AzFramework::SpawnableConstEntityContainerView entities)
+            (AzFramework::EntitySpawnTicket::Id, AzFramework::SpawnableConstEntityContainerView entities)
             {
                 for (auto&& entity : entities)
                 {
@@ -119,14 +183,30 @@ namespace UnitTest
                 spawnedEntitiesCount += entities.size();
             };
 
-        m_manager->SpawnAllEntities(*m_ticket);
-        m_manager->ListEntities(*m_ticket, AZStd::move(callback));
-        m_manager->ProcessQueue();
+        m_manager->SpawnAllEntities(*m_ticket, AzFramework::SpawnablePriority_Default);
+        m_manager->ListEntities(*m_ticket, AzFramework::SpawnablePriority_Default, AZStd::move(callback));
+        m_manager->ProcessQueue(AzFramework::SpawnableEntitiesManager::CommandQueuePriority::Regular);
 
         EXPECT_TRUE(allValidEntityIds);
         EXPECT_EQ(NumEntities, spawnedEntitiesCount);
     }
 
+    TEST_F(SpawnableEntitiesManagerTest, ListEntities_DeleteTicketBeforeCall_NoCrash)
+    {
+        auto callback = [](AzFramework::EntitySpawnTicket::Id, AzFramework::SpawnableConstEntityContainerView) {};
+
+        {
+            AzFramework::EntitySpawnTicket ticket(*m_spawnableAsset);
+            m_manager->ListEntities(ticket, AzFramework::SpawnablePriority_Default, AZStd::move(callback));
+        }
+        m_manager->ProcessQueue(AzFramework::SpawnableEntitiesManager::CommandQueuePriority::Regular);
+    }
+
+
+    //
+    // ListIndicesAndEntities
+    //
+
     TEST_F(SpawnableEntitiesManagerTest, ListIndicesAndEntities_Call_AllEntitiesAreReportedAndIncrementByOne)
     {
         static constexpr size_t NumEntities = 4;
@@ -135,7 +215,7 @@ namespace UnitTest
         bool allValidEntityIds = true;
         size_t spawnedEntitiesCount = 0;
         auto callback = [&allValidEntityIds, &spawnedEntitiesCount]
-            (AzFramework::EntitySpawnTicket&, AzFramework::SpawnableConstIndexEntityContainerView entities)
+            (AzFramework::EntitySpawnTicket::Id, AzFramework::SpawnableConstIndexEntityContainerView entities)
             {
                 for (auto&& indexEntityPair : entities)
                 {
@@ -148,11 +228,121 @@ namespace UnitTest
                 }
             };
 
-        m_manager->SpawnAllEntities(*m_ticket);
-        m_manager->ListIndicesAndEntities(*m_ticket, AZStd::move(callback));
-        m_manager->ProcessQueue();
+        m_manager->SpawnAllEntities(*m_ticket, AzFramework::SpawnablePriority_Default);
+        m_manager->ListIndicesAndEntities(*m_ticket, AzFramework::SpawnablePriority_Default, AZStd::move(callback));
+        m_manager->ProcessQueue(AzFramework::SpawnableEntitiesManager::CommandQueuePriority::Regular);
 
         EXPECT_TRUE(allValidEntityIds);
         EXPECT_EQ(NumEntities, spawnedEntitiesCount);
     }
+
+    TEST_F(SpawnableEntitiesManagerTest, ListIndicesAndEntities_DeleteTicketBeforeCall_NoCrash)
+    {
+        auto callback = [](AzFramework::EntitySpawnTicket::Id, AzFramework::SpawnableConstIndexEntityContainerView) {};
+
+        {
+            AzFramework::EntitySpawnTicket ticket(*m_spawnableAsset);
+            m_manager->ListIndicesAndEntities(ticket, AzFramework::SpawnablePriority_Default, AZStd::move(callback));
+        }
+        m_manager->ProcessQueue(AzFramework::SpawnableEntitiesManager::CommandQueuePriority::Regular);
+    }
+
+
+    //
+    // ClaimEntities
+    //
+
+    TEST_F(SpawnableEntitiesManagerTest, ClaimEntities_DeleteTicketBeforeCall_NoCrash)
+    {
+        auto callback = [](AzFramework::EntitySpawnTicket::Id, AzFramework::SpawnableEntityContainerView) {};
+
+        {
+            AzFramework::EntitySpawnTicket ticket(*m_spawnableAsset);
+            m_manager->ClaimEntities(ticket, AzFramework::SpawnablePriority_Default, AZStd::move(callback));
+        }
+        m_manager->ProcessQueue(AzFramework::SpawnableEntitiesManager::CommandQueuePriority::Regular);
+    }
+
+
+    //
+    // Barrier
+    //
+
+    TEST_F(SpawnableEntitiesManagerTest, Barrier_DeleteTicketBeforeCall_NoCrash)
+    {
+        auto callback = [](AzFramework::EntitySpawnTicket::Id) {};
+
+        {
+            AzFramework::EntitySpawnTicket ticket(*m_spawnableAsset);
+            m_manager->Barrier(ticket, AzFramework::SpawnablePriority_Default, AZStd::move(callback));
+        }
+        m_manager->ProcessQueue(AzFramework::SpawnableEntitiesManager::CommandQueuePriority::Regular);
+    }
+
+
+    //
+    // Misc. - Priority tests
+    //
+
+    TEST_F(SpawnableEntitiesManagerTest, Priority_HighBeforeDefault_HigherPriorityCallHappensBeforeDefaultPriorityEvenWhenQueuedLater)
+    {
+        static constexpr size_t NumEntities = 4;
+        FillSpawnable(NumEntities);
+
+        AzFramework::EntitySpawnTicket highPriorityTicket(*m_spawnableAsset);
+
+        size_t callCounter = 1;
+        size_t highPriorityCallId = 0;
+        size_t defaultPriorityCallId = 0;
+        auto highCallback = [&callCounter, &highPriorityCallId]
+            (AzFramework::EntitySpawnTicket::Id, AzFramework::SpawnableConstEntityContainerView)
+            {
+                highPriorityCallId = callCounter++;
+            };
+        auto defaultCallback = [&callCounter, &defaultPriorityCallId]
+            (AzFramework::EntitySpawnTicket::Id, AzFramework::SpawnableConstEntityContainerView)
+            {
+                defaultPriorityCallId = callCounter++;
+            };
+
+        m_manager->SpawnAllEntities(*m_ticket, AzFramework::SpawnablePriority_Default, {}, AZStd::move(defaultCallback));
+        m_manager->SpawnAllEntities(highPriorityTicket, AzFramework::SpawnablePriority_High, {}, AZStd::move(highCallback));
+        m_manager->ProcessQueue(
+            AzFramework::SpawnableEntitiesManager::CommandQueuePriority::High |
+            AzFramework::SpawnableEntitiesManager::CommandQueuePriority::Regular);
+
+        EXPECT_LT(highPriorityCallId, defaultPriorityCallId);
+    }
+
+    TEST_F(SpawnableEntitiesManagerTest, Priority_SameTicket_DefaultPriorityCallHappensBeforeHighPriority)
+    {
+        static constexpr size_t NumEntities = 4;
+        FillSpawnable(NumEntities);
+
+        size_t callCounter = 1;
+        size_t highPriorityCallId = 0;
+        size_t defaultPriorityCallId = 0;
+        auto highCallback =
+            [&callCounter, &highPriorityCallId](AzFramework::EntitySpawnTicket::Id, AzFramework::SpawnableConstEntityContainerView)
+            {
+                highPriorityCallId = callCounter++;
+            };
+        auto defaultCallback =
+            [&callCounter, &defaultPriorityCallId](AzFramework::EntitySpawnTicket::Id, AzFramework::SpawnableConstEntityContainerView)
+            {
+                defaultPriorityCallId = callCounter++;
+            };
+
+        m_manager->SpawnAllEntities(*m_ticket, AzFramework::SpawnablePriority_Default, {}, AZStd::move(defaultCallback));
+        m_manager->SpawnAllEntities(*m_ticket, AzFramework::SpawnablePriority_High, {}, AZStd::move(highCallback));
+        m_manager->ProcessQueue(
+            AzFramework::SpawnableEntitiesManager::CommandQueuePriority::High |
+            AzFramework::SpawnableEntitiesManager::CommandQueuePriority::Regular);
+        // Run a second time as the high priority task will be pending at this point.
+        m_manager->ProcessQueue(
+            AzFramework::SpawnableEntitiesManager::CommandQueuePriority::High |
+            AzFramework::SpawnableEntitiesManager::CommandQueuePriority::Regular);
+
+        EXPECT_LT(defaultPriorityCallId, highPriorityCallId);
+    }
 } // namespace UnitTest

Code/Sandbox/Editor/AboutDialog.ui

@@ -75,14 +75,14 @@
           <widget class="QSvgWidget" name="m_logo" native="true">
            <property name="minimumSize">
             <size>
-             <width>161</width>
-             <height>49</height>
+             <width>175</width>
+             <height>66</height>
             </size>
            </property>
            <property name="maximumSize">
             <size>
-             <width>161</width>
-             <height>49</height>
+             <width>175</width>
+             <height>66</height>
             </size>
            </property>
           </widget>

Code/Sandbox/Editor/CMakeLists.txt

@@ -177,6 +177,11 @@ ly_add_target(
         Legacy::EditorLib
         ProjectManager
 )
+set_property(SOURCE
+    CryEdit.cpp
+    APPEND PROPERTY
+        COMPILE_DEFINITIONS LY_CMAKE_TARGET="Editor"
+)
 ly_add_translations(
     TARGETS Editor
     PREFIX Translations
@@ -186,15 +191,8 @@ ly_add_translations(
 )
 ly_add_dependencies(Editor AssetProcessor)
 
-if(TARGET Editor)
-    set_property(SOURCE
-        CryEdit.cpp
-        APPEND PROPERTY
-            COMPILE_DEFINITIONS LY_CMAKE_TARGET="Editor"
-    )
-else()
-    message(FATAL_ERROR "Cannot set LY_CMAKE_TARGET define to Editor as the target doesn't exist anymore."
-        " Perhaps it has been renamed")
+if(LY_FIRST_PROJECT_PATH)
+    set_property(TARGET Editor APPEND PROPERTY VS_DEBUGGER_COMMAND_ARGUMENTS "--project-path=\"${LY_FIRST_PROJECT_PATH}\"")
 endif()
 
 ################################################################################

Code/Sandbox/Editor/Core/LevelEditorMenuHandler.cpp

@@ -421,17 +421,18 @@ QMenu* LevelEditorMenuHandler::CreateFileMenu()
     fileMenu.AddSeparator();
 
     // Project Settings
-    auto projectSettingMenu = fileMenu.AddMenu(tr("Project Settings"));
+    fileMenu.AddAction(ID_FILE_PROJECT_MANAGER_SETTINGS);
 
-    // Project Settings Tool
+    // Platform Settings - Project Settings Tool
     // Shortcut must be set while adding the action otherwise it doesn't work
-    projectSettingMenu.Get()->addAction(
+    fileMenu.Get()->addAction(
         tr(LyViewPane::ProjectSettingsTool),
         []() { QtViewPaneManager::instance()->OpenPane(LyViewPane::ProjectSettingsTool); },
         tr("Ctrl+Shift+P"));
 
-    projectSettingMenu.AddSeparator();
-
+    fileMenu.AddSeparator();
+    fileMenu.AddAction(ID_FILE_PROJECT_MANAGER_NEW);
+    fileMenu.AddAction(ID_FILE_PROJECT_MANAGER_OPEN);
     fileMenu.AddSeparator();
 
     // NEWMENUS: NEEDS IMPLEMENTATION

Code/Sandbox/Editor/CryEdit.cpp

@@ -58,6 +58,7 @@ AZ_POP_DISABLE_WARNING
 #include <AzFramework/Components/CameraBus.h>
 #include <AzFramework/StringFunc/StringFunc.h>
 #include <AzFramework/Terrain/TerrainDataRequestBus.h>
+#include <AzFramework/ProjectManager/ProjectManager.h>
 
 // AzToolsFramework
 #include <AzToolsFramework/Component/EditorComponentAPIBus.h>
@@ -280,6 +281,8 @@ BOOL CCryDocManager::DoPromptFileName(QString& fileName, [[maybe_unused]] UINT n
     [[maybe_unused]] DWORD lFlags, BOOL bOpenFileDialog, [[maybe_unused]] CDocTemplate* pTemplate)
 {
     CLevelFileDialog levelFileDialog(bOpenFileDialog);
+    levelFileDialog.show();
+    levelFileDialog.adjustSize();
 
     if (levelFileDialog.exec() == QDialog::Accepted)
     {
@@ -477,6 +480,11 @@ void CCryEditApp::RegisterActionHandlers()
 
     ON_COMMAND(ID_FILE_SAVE_LEVEL, OnFileSave)
     ON_COMMAND(ID_FILE_EXPORTOCCLUSIONMESH, OnFileExportOcclusionMesh)
+
+    // Project Manager 
+    ON_COMMAND(ID_FILE_PROJECT_MANAGER_SETTINGS, OnOpenProjectManagerSettings)
+    ON_COMMAND(ID_FILE_PROJECT_MANAGER_NEW, OnOpenProjectManagerNew)
+    ON_COMMAND(ID_FILE_PROJECT_MANAGER_OPEN, OnOpenProjectManager)
 }
 
 CCryEditApp* CCryEditApp::s_currentInstance = nullptr;
@@ -2073,6 +2081,8 @@ void CCryEditApp::OnDocumentationAWSSupport()
 void CCryEditApp::OnDocumentationFeedback()
 {
     FeedbackDialog dialog;
+    dialog.show();
+    dialog.adjustSize();
     dialog.exec();
 }
 
@@ -2854,6 +2864,34 @@ void CCryEditApp::OnPreferences()
     */
 }
 
+void CCryEditApp::OnOpenProjectManagerSettings()
+{
+    OpenProjectManager("UpdateProject");
+}
+
+void CCryEditApp::OnOpenProjectManagerNew()
+{
+    OpenProjectManager("CreateProject");
+}
+
+void CCryEditApp::OnOpenProjectManager()
+{
+    OpenProjectManager("Projects");
+}
+
+void CCryEditApp::OpenProjectManager(const AZStd::string& screen)
+{
+    // provide the current project path for in case we want to update the project
+    AZ::IO::FixedMaxPathString projectPath = AZ::Utils::GetProjectPath();
+    const AZStd::string commandLineOptions = AZStd::string::format(" --screen %s --project_path %s", screen.c_str(), projectPath.c_str());
+    bool launchSuccess = AzFramework::ProjectManager::LaunchProjectManager(commandLineOptions);
+    if (!launchSuccess)
+    {
+        QMessageBox::critical(AzToolsFramework::GetActiveWindow(), QObject::tr("Failed to launch O3DE Project Manager"), QObject::tr("Failed to find or start the O3dE Project Manager"));
+    }
+}
+
+
 //////////////////////////////////////////////////////////////////////////
 void CCryEditApp::OnUndo()
 {
@@ -3313,6 +3351,8 @@ void CCryEditApp::OnCreateSlice()
 void CCryEditApp::OnOpenLevel()
 {
     CLevelFileDialog levelFileDialog(true);
+    levelFileDialog.show();
+    levelFileDialog.adjustSize();
 
     if (levelFileDialog.exec() == QDialog::Accepted)
     {

Code/Sandbox/Editor/CryEdit.h

@@ -229,6 +229,9 @@ public:
     void OnFileResaveSlices();
     void OnFileEditEditorini();
     void OnPreferences();
+    void OnOpenProjectManagerSettings();
+    void OnOpenProjectManagerNew();
+    void OnOpenProjectManager();
     void OnRedo();
     void OnUpdateRedo(QAction* action);
     void OnUpdateUndo(QAction* action);
@@ -366,6 +369,7 @@ private:
     AZ_POP_DISABLE_DLL_EXPORT_MEMBER_WARNING
     friend struct PythonTestOutputHandler;
 
+    void OpenProjectManager(const AZStd::string& screen);
     void OnWireframe();
     void OnUpdateWireframe(QAction* action);
     void OnViewConfigureLayout();

Code/Sandbox/Editor/EditorViewportWidget.cpp

@@ -463,16 +463,20 @@ void EditorViewportWidget::Update()
         m_renderViewport->GetViewportContext()->SetCameraTransform(LYTransformToAZTransform(m_Camera.GetMatrix()));
     }
 
-    AZ::Matrix4x4 clipMatrix;
-    AZ::MakePerspectiveFovMatrixRH(
-        clipMatrix,
-        m_Camera.GetFov(),
-        aznumeric_cast<float>(width()) / aznumeric_cast<float>(height()),
-        m_Camera.GetNearPlane(),
-        m_Camera.GetFarPlane(),
-        true
-    );
-    m_renderViewport->GetViewportContext()->SetCameraProjectionMatrix(clipMatrix);
+    // Don't override the game mode FOV
+    if (!GetIEditor()->IsInGameMode())
+    {
+        AZ::Matrix4x4 clipMatrix;
+        AZ::MakePerspectiveFovMatrixRH(
+            clipMatrix,
+            GetFOV(),
+            aznumeric_cast<float>(width()) / aznumeric_cast<float>(height()),
+            m_Camera.GetNearPlane(),
+            m_Camera.GetFarPlane(),
+            true
+        );
+        m_renderViewport->GetViewportContext()->SetCameraProjectionMatrix(clipMatrix);
+    }
     m_updatingCameraPosition = false;
 
 
@@ -870,6 +874,13 @@ void EditorViewportWidget::OnBeginPrepareRender()
         int w = m_rcClient.width();
         int h = m_rcClient.height();
 
+        // Don't bother doing an FOV calculation if we don't have a valid viewport
+        // This prevents frustum calculation bugs with a null viewport
+        if (w <= 1 || h <= 1)
+        {
+            return;
+        }
+
         float fov = gSettings.viewports.fDefaultFov;
 
         // match viewport fov to default / selected title menu fov
@@ -1782,9 +1793,6 @@ void EditorViewportWidget::SetViewTM(const Matrix34& viewTM, bool bMoveOnly)
                 cameraObject->SetWorldTM(camMatrix * AZMatrix3x3ToLYMatrix3x3(lookThroughEntityCorrection));
             }
         }
-
-        using namespace AzToolsFramework;
-        ComponentEntityObjectRequestBus::Event(cameraObject, &ComponentEntityObjectRequestBus::Events::UpdatePreemptiveUndoCache);
     }
     else if (m_viewEntityId.IsValid())
     {

Code/Sandbox/Editor/LyViewPaneNames.h

@@ -30,7 +30,7 @@ namespace LyViewPane
     static const char* const EntityInspector = "Entity Inspector";
     static const char* const EntityInspectorPinned = "Pinned Entity Inspector";
     static const char* const LevelInspector = "Level Inspector";
-    static const char* const ProjectSettingsTool = "Project Settings Tool";
+    static const char* const ProjectSettingsTool = "Edit Platform Settings...";
     static const char* const ErrorReport = "Error Report";
     static const char* const Console = "Console";
     static const char* const ConsoleMenuName = "&Console";

Code/Sandbox/Editor/MainWindow.cpp

@@ -748,6 +748,9 @@ void MainWindow::InitActions()
     am->AddAction(ID_FILE_EXPORTOCCLUSIONMESH, tr("Export Occlusion Mesh"));
     am->AddAction(ID_FILE_EDITLOGFILE, tr("Show Log File"));
     am->AddAction(ID_FILE_RESAVESLICES, tr("Resave All Slices"));
+    am->AddAction(ID_FILE_PROJECT_MANAGER_SETTINGS, tr("Edit Project Settings..."));
+    am->AddAction(ID_FILE_PROJECT_MANAGER_NEW, tr("New Project..."));
+    am->AddAction(ID_FILE_PROJECT_MANAGER_OPEN, tr("Open Project..."));
     am->AddAction(ID_GAME_PC_ENABLEVERYHIGHSPEC, tr("Very High")).SetCheckable(true)
         .RegisterUpdateCallback(cryEdit, &CCryEditApp::OnUpdateGameSpec);
     am->AddAction(ID_GAME_PC_ENABLEHIGHSPEC, tr("High")).SetCheckable(true)

Code/Sandbox/Editor/Resource.h

@@ -313,6 +313,9 @@
 #define ID_CREATE_LEVEL_FG_MODULE_FROM_SELECTION                    35077
 #define ID_GRAPHVIEW_ADD_BLACK_BOX                                  35078
 #define ID_GRAPHVIEW_UNGROUP                                        35079
+#define ID_FILE_PROJECT_MANAGER_NEW                                 35080
+#define ID_FILE_PROJECT_MANAGER_OPEN                                35081
+#define ID_FILE_PROJECT_MANAGER_SETTINGS                            35082
 #define ID_TV_TRACKS_TOOLBAR_BASE                                   35083               // range between ID_TV_TRACKS_TOOLBAR_BASE to ID_TV_TRACKS_TOOLBAR_LAST reserved
 #define ID_TV_TRACKS_TOOLBAR_LAST                                   35183               // for up to 100 "Add Tracks..." dynamically added Track View Track buttons
 #define ID_OPEN_TERRAIN_EDITOR          36007
@@ -366,3 +369,4 @@
 #define ID_TOOLBAR_WIDGET_SPACER_RIGHT       50013
 #define ID_TOOLBAR_WIDGET_PLAYCONSOLE_LABEL  50014
 #define ID_TOOLBAR_WIDGET_LAST               50020
+#define ID_VIEWPORTUI_VISIBLE                50040

Code/Sandbox/Editor/StartupLogoDialog.ui

@@ -42,14 +42,14 @@
           <widget class="QSvgWidget" name="m_logo" native="true">
            <property name="minimumSize">
             <size>
-             <width>161</width>
-             <height>49</height>
+             <width>175</width>
+             <height>66</height>
             </size>
            </property>
            <property name="maximumSize">
             <size>
-             <width>161</width>
-             <height>50</height>
+             <width>175</width>
+             <height>66</height>
             </size>
            </property>
           </widget>

Code/Sandbox/Editor/o3de_logo.svg

@@ -1,22 +1,35 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<svg width="323px" height="98px" viewBox="0 0 323 98" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
-    <title>Group 12</title>
-    <defs>
-        <polygon id="path-1" points="0 97.741 322.084 97.741 322.084 0 0 0"></polygon>
-    </defs>
-    <g id="Page-1" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
-        <g id="Group-12" transform="translate(0.000000, 0.000000)">
-            <path d="M99.7068,20.425 C91.1008,11.686 79.6658,6.841 67.5068,6.782 L67.2838,6.781 C62.9678,6.781 58.7408,7.396 54.6908,8.566 L54.6908,25.339 C58.5158,23.54 62.6988,22.563 67.0218,22.517 C67.1388,22.516 67.2538,22.515 67.3698,22.515 C75.1318,22.515 82.4608,25.519 88.0388,30.996 C93.7828,36.635 96.9708,44.124 97.0168,52.084 C97.0628,60.037 93.9658,67.554 88.2968,73.251 C82.6908,78.884 75.2578,82 67.3558,82.025 L67.2718,82.025 C59.4228,82.025 51.9878,78.959 46.3368,73.393 C40.6918,67.833 37.5578,60.397 37.5108,52.453 C37.4888,48.659 38.1798,44.975 39.5088,41.546 L23.0748,41.546 C19.4908,56.362 23.4348,72.648 34.9328,84.219 C43.5408,92.882 54.9608,97.683 67.0878,97.738 L67.3028,97.738 L67.3058,97.738 C79.3458,97.738 90.7008,93.045 99.2768,84.524 C107.8718,75.984 112.6488,64.62 112.7288,52.524 C112.8088,40.435 108.1838,29.035 99.7068,20.425" id="Fill-1" fill="#FFFFFF"></path>
-            <path d="M175.6326,27.8629 C175.6326,33.3889 173.9586,38.0879 170.6116,41.9599 C167.2646,45.8319 162.5656,48.4939 156.5146,49.9459 L156.5146,50.3089 C163.6536,51.1969 169.0586,53.3629 172.7296,56.8129 C176.3996,60.2619 178.2356,64.9099 178.2356,70.7579 C178.2356,79.2689 175.1496,85.8939 168.9786,90.6319 C162.8076,95.3719 153.9936,97.7409 142.5386,97.7409 C132.9386,97.7409 124.4286,96.1489 117.0076,92.9609 L117.0076,77.0489 C120.4356,78.7839 124.2076,80.1959 128.3216,81.2839 C132.4356,82.3729 136.5096,82.9179 140.5426,82.9179 C146.7146,82.9179 151.2716,81.8699 154.2156,79.7719 C157.1596,77.6749 158.6326,74.3079 158.6326,69.6679 C158.6326,65.5139 156.9386,62.5699 153.5506,60.8349 C150.1626,59.1009 144.7576,58.2329 137.3366,58.2329 L130.6206,58.2329 L130.6206,43.8939 L137.4576,43.8939 C144.3146,43.8939 149.3246,42.9979 152.4916,41.2019 C155.6576,39.4079 157.2406,36.3319 157.2406,31.9759 C157.2406,25.2809 153.0456,21.9329 144.6566,21.9329 C141.7526,21.9329 138.7986,22.4169 135.7936,23.3849 C132.7886,24.3529 129.4506,26.0279 125.7806,28.4069 L117.1306,15.5199 C125.1956,9.7119 134.8166,6.8079 145.9886,6.8079 C155.1446,6.8079 162.3736,8.6639 167.6786,12.3739 C172.9806,16.0869 175.6326,21.2499 175.6326,27.8629" id="Fill-3" fill="#FFFFFF"></path>
-            <path d="M241.8563,51.9425 C241.8563,32.9455 233.4653,23.4465 216.6883,23.4465 L206.7053,23.4465 L206.7053,81.0435 L214.7523,81.0435 C232.8213,81.0435 241.8563,71.3435 241.8563,51.9425 M261.3363,51.4595 C261.3363,66.0195 257.1933,77.1715 248.9043,84.9165 C240.6153,92.6605 228.6463,96.5325 212.9973,96.5325 L187.9503,96.5325 L187.9503,8.0815 L215.7193,8.0815 C230.1593,8.0815 241.3723,11.8925 249.3583,19.5155 C257.3433,27.1365 261.3363,37.7855 261.3363,51.4595" id="Fill-5" fill="#FFFFFF"></path>
-            <mask id="mask-2" fill="white">
-                <use xlink:href="#path-1"></use>
-            </mask>
-            <g id="Clip-8"></g>
-            <polygon id="Fill-7" fill="#FFFFFF" mask="url(#mask-2)" points="23.185 30.421 45.046 30.421 45.046 8.56 23.185 8.56"></polygon>
-            <polygon id="Fill-9" fill="#FFFFFF" mask="url(#mask-2)" points="5.251 9.038 14.289 9.038 14.289 0 5.251 0"></polygon>
-            <polygon id="Fill-10" fill="#FFFFFF" mask="url(#mask-2)" points="0 36.195 14.18 36.195 14.18 22.015 0 22.015"></polygon>
-            <polygon id="Fill-11" fill="#FFFFFF" mask="url(#mask-2)" points="322.0838 96.4337 271.0538 96.4337 271.0538 7.8287 322.0838 7.8287 322.0838 23.2227 289.8418 23.2227 289.8418 42.6767 319.8418 42.6767 319.8418 58.0707 289.8418 58.0707 289.8418 80.9187 322.0838 80.9187"></polygon>
+<svg width="350px" height="133px" viewBox="0 0 350 133" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+    <title>Artboard</title>
+    <g id="Artboard" stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
+        <g id="O3DE-Logo-with-WorkMark-REV-Mono" transform="translate(-0.060000, 0.000000)" fill="#FFFFFF">
+            <g id="Group-3" transform="translate(25.446000, 117.517000)">
+                <path d="M1.833,7.614 C1.833,9.618 2.262,11.139 3.121,12.175 C3.979,13.211 5.226,13.729 6.863,13.729 C8.511,13.729 9.758,13.212 10.599,12.18 C11.441,11.146 11.862,9.625 11.862,7.614 C11.862,5.623 11.443,4.113 10.604,3.083 C9.766,2.055 8.525,1.539 6.883,1.539 C5.234,1.539 3.979,2.057 3.121,3.093 C2.262,4.129 1.833,5.637 1.833,7.614 Z M13.694,7.614 C13.694,9.983 13.092,11.846 11.887,13.202 C10.683,14.559 9.007,15.237 6.863,15.237 C4.67,15.237 2.979,14.571 1.787,13.237 C0.596,11.904 3.55271368e-15,10.023 3.55271368e-15,7.594 C3.55271368e-15,5.184 0.597,3.315 1.792,1.989 C2.986,0.663 4.683,0 6.883,0 C9.022,0 10.692,0.676 11.892,2.025 C13.095,3.375 13.694,5.238 13.694,7.614 L13.694,7.614 Z" id="Fill-1"></path>
+            </g>
+            <path d="M55.659,125.252 L57.216,125.252 C58.75,125.252 59.86,125.005 60.546,124.513 C61.231,124.02 61.574,123.231 61.574,122.144 C61.574,121.165 61.251,120.436 60.606,119.956 C59.961,119.478 58.958,119.239 57.593,119.239 L55.659,119.239 L55.659,125.252 Z M63.366,122.063 C63.366,123.561 62.852,124.714 61.823,125.521 C60.795,126.327 59.324,126.731 57.41,126.731 L55.659,126.731 L55.659,132.551 L53.927,132.551 L53.927,117.749 L57.786,117.749 C61.506,117.749 63.366,119.188 63.366,122.063 L63.366,122.063 Z" id="Fill-4"></path>
+            <polyline id="Fill-5" points="86.247 132.551 77.949 132.551 77.949 117.749 86.247 117.749 86.247 119.279 79.681 119.279 79.681 124.047 85.849 124.047 85.849 125.566 79.681 125.566 79.681 131.013 86.247 131.013 86.247 132.551"></polyline>
+            <g id="Group-9" transform="translate(101.016000, 117.537000)">
+                <path d="M11.628,15.014 L9.651,15.014 L1.517,2.592 L1.436,2.592 C1.544,4.05 1.599,5.387 1.599,6.602 L1.599,15.014 L-1.42108547e-14,15.014 L-1.42108547e-14,0.212 L1.954,0.212 L10.069,12.584 L10.151,12.584 C10.137,12.403 10.106,11.817 10.059,10.828 C10.011,9.839 9.995,9.133 10.008,8.707 L10.008,0.212 L11.628,0.212 L11.628,15.014" id="Fill-6"></path>
+                <path d="M56.235,3.696 C56.235,4.64 55.968,5.413 55.436,6.014 C54.902,6.616 54.147,7.016 53.169,7.219 L53.169,7.3 C54.364,7.449 55.251,7.827 55.828,8.434 C56.404,9.041 56.693,9.837 56.693,10.823 C56.693,12.234 56.201,13.319 55.216,14.079 C54.232,14.837 52.834,15.217 51.022,15.217 C50.234,15.217 49.513,15.159 48.858,15.039 C48.203,14.922 47.567,14.714 46.949,14.417 L46.949,12.818 C47.594,13.135 48.281,13.376 49.011,13.541 C49.741,13.707 50.431,13.789 51.083,13.789 C53.655,13.789 54.942,12.788 54.942,10.783 C54.942,8.987 53.522,8.089 50.685,8.089 L49.219,8.089 L49.219,6.642 L50.707,6.642 C51.866,6.642 52.787,6.387 53.465,5.877 C54.144,5.369 54.483,4.661 54.483,3.756 C54.483,3.034 54.234,2.467 53.735,2.055 C53.236,1.644 52.559,1.438 51.704,1.438 C51.052,1.438 50.438,1.526 49.861,1.702 C49.284,1.877 48.626,2.201 47.886,2.673 L47.031,1.539 C47.642,1.06 48.345,0.683 49.144,0.411 C49.94,0.136 50.78,1.42108547e-14 51.663,1.42108547e-14 C53.109,1.42108547e-14 54.232,0.33 55.033,0.987 C55.834,1.646 56.235,2.548 56.235,3.696" id="Fill-8"></path>
+            </g>
+            <path d="M182.497,125.07 C182.497,123.14 182.009,121.685 181.035,120.706 C180.061,119.727 178.614,119.239 176.693,119.239 L174.178,119.239 L174.178,131.064 L176.286,131.064 C178.349,131.064 179.9,130.56 180.939,129.55 C181.976,128.541 182.497,127.048 182.497,125.07 Z M184.329,125.009 C184.329,127.452 183.662,129.321 182.329,130.613 C180.995,131.906 179.076,132.551 176.571,132.551 L172.447,132.551 L172.447,117.749 L177.008,117.749 C179.323,117.749 181.122,118.388 182.405,119.663 C183.687,120.94 184.329,122.721 184.329,125.009 L184.329,125.009 Z" id="Fill-10"></path>
+            <polyline id="Fill-11" points="228.264 132.551 219.965 132.551 219.965 117.749 228.264 117.749 228.264 119.279 221.697 119.279 221.697 124.047 227.867 124.047 227.867 125.566 221.697 125.566 221.697 131.013 228.264 131.013 228.264 132.551"></polyline>
+            <g id="Group-15" transform="translate(243.032000, 117.537000)">
+                <path d="M11.629,15.014 L9.652,15.014 L1.517,2.592 L1.436,2.592 C1.545,4.05 1.599,5.387 1.599,6.602 L1.599,15.014 L2.84217094e-14,15.014 L2.84217094e-14,0.212 L1.955,0.212 L10.07,12.584 L10.151,12.584 C10.138,12.403 10.107,11.817 10.059,10.828 C10.011,9.839 9.996,9.133 10.008,8.707 L10.008,0.212 L11.629,0.212 L11.629,15.014" id="Fill-12"></path>
+                <path d="M33.736,7.259 L38.796,7.259 L38.796,14.458 C38.008,14.707 37.208,14.897 36.393,15.025 C35.578,15.154 34.634,15.217 33.563,15.217 C31.309,15.217 29.554,14.551 28.299,13.217 C27.044,11.884 26.415,10.017 26.415,7.614 C26.415,6.076 26.726,4.727 27.346,3.569 C27.968,2.413 28.862,1.528 30.03,0.916 C31.197,0.306 32.564,1.42108547e-14 34.133,1.42108547e-14 C35.721,1.42108547e-14 37.201,0.29 38.573,0.872 L37.9,2.39 C36.555,1.823 35.263,1.539 34.021,1.539 C32.209,1.539 30.794,2.076 29.776,3.149 C28.757,4.222 28.248,5.71 28.248,7.614 C28.248,9.612 28.738,11.126 29.719,12.16 C30.7,13.192 32.14,13.709 34.042,13.709 C35.073,13.709 36.081,13.59 37.066,13.354 L37.066,8.798 L33.736,8.798 L33.736,7.259" id="Fill-14"></path>
+            </g>
+            <polygon id="Fill-16" points="296.871 132.551 298.602 132.551 298.602 117.749 296.871 117.749"></polygon>
+            <path d="M325.781,132.551 L323.805,132.551 L315.67,120.129 L315.588,120.129 C315.698,121.587 315.751,122.924 315.751,124.139 L315.751,132.551 L314.153,132.551 L314.153,117.749 L316.108,117.749 L324.223,130.121 L324.304,130.121 C324.29,129.94 324.259,129.354 324.212,128.365 C324.164,127.376 324.148,126.67 324.162,126.244 L324.162,117.749 L325.781,117.749 L325.781,132.551" id="Fill-17"></path>
+            <polyline id="Fill-18" points="349.64 132.551 341.341 132.551 341.341 117.749 349.64 117.749 349.64 119.279 343.073 119.279 343.073 124.047 349.243 124.047 349.243 125.566 343.073 125.566 343.073 131.013 349.64 131.013 349.64 132.551"></polyline>
+            <path d="M187.562,26.549 C187.562,32.293 185.822,37.178 182.341,41.203 C178.861,45.228 173.977,47.995 167.687,49.505 L167.687,49.882 C175.109,50.805 180.727,53.058 184.543,56.643 C188.358,60.228 190.266,65.061 190.266,71.14 C190.266,79.989 187.059,86.875 180.644,91.801 C174.228,96.728 165.067,99.191 153.159,99.191 C143.18,99.191 134.332,97.535 126.618,94.222 L126.618,77.681 C130.181,79.485 134.102,80.951 138.379,82.083 C142.656,83.216 146.891,83.781 151.083,83.781 C157.498,83.781 162.236,82.693 165.297,80.511 C168.358,78.331 169.889,74.831 169.889,70.008 C169.889,65.69 168.128,62.63 164.606,60.825 C161.083,59.023 155.464,58.121 147.75,58.121 L140.769,58.121 L140.769,43.216 L147.876,43.216 C155.004,43.216 160.213,42.283 163.505,40.417 C166.796,38.551 168.442,35.354 168.442,30.825 C168.442,23.865 164.081,20.385 155.36,20.385 C152.341,20.385 149.269,20.888 146.146,21.894 C143.022,22.901 139.552,24.642 135.737,27.115 L126.744,13.718 C135.129,7.68 145.129,4.661 156.744,4.661 C166.262,4.661 173.777,6.591 179.291,10.448 C184.804,14.305 187.562,19.673 187.562,26.549" id="Fill-19"></path>
+            <path d="M261.093,51.538 C261.093,31.236 252.127,21.084 234.196,21.084 L223.527,21.084 L223.527,82.639 L232.126,82.639 C251.437,82.639 261.093,72.273 261.093,51.538 Z M281.913,51.021 C281.913,66.583 277.484,78.5 268.625,86.777 C259.768,95.053 246.976,99.191 230.251,99.191 L203.483,99.191 L203.483,4.661 L233.162,4.661 C248.592,4.661 260.576,8.735 269.111,16.882 C277.646,25.029 281.913,36.408 281.913,51.021 L281.913,51.021 Z" id="Fill-20"></path>
+            <polyline id="Fill-21" points="349.64 99.191 295.198 99.191 295.198 4.661 349.64 4.661 349.64 21.084 315.242 21.084 315.242 41.84 347.247 41.84 347.247 58.262 315.242 58.262 315.242 82.639 349.64 82.639 349.64 99.191"></polyline>
+            <path d="M72.71,4.661 C68.177,4.661 63.799,5.313 59.648,6.505 L59.648,24.983 C63.596,23.066 68.027,21.988 72.71,21.988 C89.245,21.988 102.648,35.392 102.648,51.926 C102.648,68.46 89.245,81.865 72.71,81.865 C56.176,81.865 42.773,68.46 42.773,51.926 C42.773,47.99 43.539,44.237 44.92,40.794 L26.777,40.794 C25.914,44.365 25.446,48.09 25.446,51.926 C25.446,78.03 46.607,99.191 72.71,99.191 C98.814,99.191 119.976,78.03 119.976,51.926 C119.976,25.823 98.814,4.661 72.71,4.661" id="Fill-22"></path>
+            <g id="Group-27">
+                <polyline id="Fill-23" points="53.023 29.655 30.237 34.445 25.447 11.66 48.232 6.869 53.023 29.655"></polyline>
+                <polygon id="Fill-25" points="11.806 9.313 21.12 9.313 21.12 0 11.806 0"></polygon>
+                <polyline id="Fill-26" points="14.761 31.326 0 27.533 3.793 12.773 18.554 16.566 14.761 31.326"></polyline>
+            </g>
         </g>
     </g>
-</svg>
+</svg>

Code/Tools/AssetProcessor/CMakeLists.txt

@@ -125,6 +125,10 @@ ly_add_target(
             AZ::AssetProcessorBatch.Static
 )
 
+if(LY_FIRST_PROJECT_PATH)
+    set_property(TARGET AssetProcessor AssetProcessorBatch APPEND PROPERTY VS_DEBUGGER_COMMAND_ARGUMENTS "--project-path=\"${LY_FIRST_PROJECT_PATH}\"")
+endif()
+
 # Adds the AssetProcessorBatch target as a C preprocessor define so that it can be used as a Settings Registry
 # specialization in order to look up the generated .setreg which contains the dependencies
 # specified for the target.

Code/Tools/ProjectManager/CMakeLists.txt

@@ -25,7 +25,6 @@ ly_add_target(
     OUTPUT_NAME o3de
     NAMESPACE AZ
     AUTOMOC
-    AUTOUIC
     AUTORCC
     FILES_CMAKE
         project_manager_files.cmake

Code/Tools/ProjectManager/Resources/ProjectManager.qss

@@ -232,6 +232,18 @@ QTabBar::tab:pressed
     margin-left:30px;
 }
 
+#projectSettingsTab::tab-bar {
+    left: 60px;
+}
+
+#projectSettingsTabBar::tab {
+    height:50px;
+}
+
+#projectSettingsTopFrame {
+    background-color:#1E252F;
+}
+
 /************** Projects **************/
 #firstTimeContent > #titleLabel {
     font-size:60px;

Code/Tools/ProjectManager/Source/CreateProjectCtrl.cpp

@@ -15,7 +15,6 @@
 #include <PythonBindingsInterface.h>
 #include <NewProjectSettingsScreen.h>
 #include <ScreenHeaderWidget.h>
-#include <GemCatalog/GemCatalogScreen.h>
 
 #include <QDialogButtonBox>
 #include <QHBoxLayout>
@@ -42,9 +41,10 @@ namespace O3DE::ProjectManager
 
         m_stack = new QStackedWidget(this);
         m_stack->setObjectName("body");
-        m_stack->setSizePolicy(QSizePolicy(QSizePolicy::Preferred,QSizePolicy::Expanding));
+        m_stack->setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Expanding));
         m_stack->addWidget(new NewProjectSettingsScreen());
-        m_stack->addWidget(new GemCatalogScreen());
+        m_gemCatalog = new GemCatalogScreen();
+        m_stack->addWidget(m_gemCatalog);
         vLayout->addWidget(m_stack);
 
         QDialogButtonBox* backNextButtons = new QDialogButtonBox();
@@ -67,6 +67,15 @@ namespace O3DE::ProjectManager
         return ProjectManagerScreen::CreateProject;
     }
 
+    void CreateProjectCtrl::NotifyCurrentScreen()
+    {
+        ScreenWidget* currentScreen = reinterpret_cast<ScreenWidget*>(m_stack->currentWidget());
+        if (currentScreen)
+        {
+            currentScreen->NotifyCurrentScreen();
+        }
+    }
+
     void CreateProjectCtrl::HandleBackButton()
     {
         if (m_stack->currentIndex() > 0)
@@ -79,6 +88,7 @@ namespace O3DE::ProjectManager
             emit GotoPreviousScreenRequest();
         }
     }
+
     void CreateProjectCtrl::HandleNextButton()
     {
         ScreenWidget* currentScreen = reinterpret_cast<ScreenWidget*>(m_stack->currentWidget());
@@ -97,6 +107,9 @@ namespace O3DE::ProjectManager
 
                 m_projectInfo         = newProjectScreen->GetProjectInfo();
                 m_projectTemplatePath = newProjectScreen->GetProjectTemplatePath();
+
+                // The next page is the gem catalog. Gather the available gems that will be shown in the gem catalog.
+                m_gemCatalog->ReinitForProject(m_projectInfo.m_path, /*isNewProject=*/true);
             }
         }
 
@@ -110,6 +123,9 @@ namespace O3DE::ProjectManager
             auto result = PythonBindingsInterface::Get()->CreateProject(m_projectTemplatePath, m_projectInfo);
             if (result.IsSuccess())
             {
+                // automatically register the project
+                PythonBindingsInterface::Get()->AddProject(m_projectInfo.m_path);
+
                 // adding gems is not implemented yet because we don't know what targets to add or how to add them
                 emit ChangeScreenRequest(ProjectManagerScreen::Projects);
             }
@@ -117,6 +133,9 @@ namespace O3DE::ProjectManager
             {
                 QMessageBox::critical(this, tr("Project creation failed"), tr("Failed to create project."));
             }
+
+            // Enable/disable gems for the newly created project.
+            m_gemCatalog->EnableDisableGemsForProject(m_projectInfo.m_path);
         }
     }
 

Code/Tools/ProjectManager/Source/CreateProjectCtrl.h

@@ -14,6 +14,7 @@
 #if !defined(Q_MOC_RUN)
 #include <ScreenWidget.h>
 #include <ProjectInfo.h>
+#include <GemCatalog/GemCatalogScreen.h>
 #endif
 
 QT_FORWARD_DECLARE_CLASS(QStackedWidget)
@@ -31,6 +32,7 @@ namespace O3DE::ProjectManager
         explicit CreateProjectCtrl(QWidget* parent = nullptr);
         ~CreateProjectCtrl() = default;
         ProjectManagerScreen GetScreenEnum() override;
+        void NotifyCurrentScreen() override;
 
     protected slots:
         void HandleBackButton();
@@ -47,6 +49,8 @@ namespace O3DE::ProjectManager
 
         QString m_projectTemplatePath;
         ProjectInfo m_projectInfo;
+
+        GemCatalogScreen* m_gemCatalog = nullptr;
     };
 
 } // namespace O3DE::ProjectManager

Code/Tools/ProjectManager/Source/FormLineEditWidget.cpp

@@ -78,6 +78,14 @@ namespace O3DE::ProjectManager
         m_errorLabel->setText(labelText);
     }
 
+    void FormLineEditWidget::setErrorLabelVisible(bool visible)
+    {
+        m_errorLabel->setVisible(visible);
+        m_frame->setProperty("Valid", !visible);
+
+        refreshStyle();
+    }
+
     QLineEdit* FormLineEditWidget::lineEdit() const
     {
         return m_lineEdit;

Code/Tools/ProjectManager/Source/FormLineEditWidget.h

@@ -39,6 +39,7 @@ namespace O3DE::ProjectManager
 
         //! Set the error message for to display when invalid.
         void setErrorLabelText(const QString& labelText);
+        void setErrorLabelVisible(bool visible);
 
         //! Returns a pointer to the underlying LineEdit.
         QLineEdit* lineEdit() const;

Code/Tools/ProjectManager/Source/GemCatalog/GemCatalogScreen.cpp

@@ -15,13 +15,12 @@
 #include <GemCatalog/GemCatalogHeaderWidget.h>
 #include <GemCatalog/GemListHeaderWidget.h>
 #include <GemCatalog/GemSortFilterProxyModel.h>
-#include <GemCatalog/GemFilterWidget.h>
 #include <QVBoxLayout>
 #include <QHBoxLayout>
 #include <QPushButton>
 #include <QTimer>
-
-//#define USE_TESTGEMDATA
+#include <PythonBindingsInterface.h>
+#include <QMessageBox>
 
 namespace O3DE::ProjectManager
 {
@@ -29,47 +28,32 @@ namespace O3DE::ProjectManager
         : ScreenWidget(parent)
     {
         m_gemModel = new GemModel(this);
-        GemSortFilterProxyModel* proxyModel = new GemSortFilterProxyModel(m_gemModel, this);
+        m_proxModel = new GemSortFilterProxyModel(m_gemModel, this);
 
         QVBoxLayout* vLayout = new QVBoxLayout();
         vLayout->setMargin(0);
         vLayout->setSpacing(0);
         setLayout(vLayout);
 
-        GemCatalogHeaderWidget* headerWidget = new GemCatalogHeaderWidget(proxyModel);
+        GemCatalogHeaderWidget* headerWidget = new GemCatalogHeaderWidget(m_proxModel);
         vLayout->addWidget(headerWidget);
 
         QHBoxLayout* hLayout = new QHBoxLayout();
         hLayout->setMargin(0);
         vLayout->addLayout(hLayout);
 
-        m_gemListView = new GemListView(proxyModel, proxyModel->GetSelectionModel(), this);
+        m_gemListView = new GemListView(m_proxModel, m_proxModel->GetSelectionModel(), this);
         m_gemInspector = new GemInspector(m_gemModel, this);
-        m_gemInspector->setFixedWidth(320);
+        m_gemInspector->setFixedWidth(240);
 
-        // Start: Temporary gem test data
-#ifdef USE_TESTGEMDATA
-        QVector<GemInfo> testGemData = GenerateTestData();
-        for (const GemInfo& gemInfo : testGemData)
-        {
-            m_gemModel->AddGem(gemInfo);
-        }
-#else
-        // End: Temporary gem test data
-        auto result = PythonBindingsInterface::Get()->GetGems();
-        if (result.IsSuccess())
-        {
-            for (auto gemInfo : result.GetValue())
-            {
-                m_gemModel->AddGem(gemInfo);
-            }
-        }
-#endif
+        QWidget* filterWidget = new QWidget(this);
+        filterWidget->setFixedWidth(240);
+        m_filterWidgetLayout = new QVBoxLayout();
+        m_filterWidgetLayout->setMargin(0);
+        m_filterWidgetLayout->setSpacing(0);
+        filterWidget->setLayout(m_filterWidgetLayout);
 
-        GemFilterWidget* filterWidget = new GemFilterWidget(proxyModel);
-        filterWidget->setFixedWidth(250);
-
-        GemListHeaderWidget* listHeaderWidget = new GemListHeaderWidget(proxyModel);
+        GemListHeaderWidget* listHeaderWidget = new GemListHeaderWidget(m_proxModel);
 
         QVBoxLayout* middleVLayout = new QVBoxLayout();
         middleVLayout->setMargin(0);
@@ -80,98 +64,111 @@ namespace O3DE::ProjectManager
         hLayout->addWidget(filterWidget);
         hLayout->addLayout(middleVLayout);
         hLayout->addWidget(m_gemInspector);
-
-        proxyModel->InvalidateFilter();
     }
 
-    QVector<GemInfo> GemCatalogScreen::GenerateTestData()
+    void GemCatalogScreen::ReinitForProject(const QString& projectPath, bool isNewProject)
     {
-        QVector<GemInfo> result;
+        m_gemModel->clear();
+        FillModel(projectPath, isNewProject);
 
-        GemInfo gem("EMotion FX",
-            "O3DE Foundation",
-            "EMFX is a real-time character animation system. Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.",
-            (GemInfo::Android | GemInfo::iOS | GemInfo::macOS | GemInfo::Windows | GemInfo::Linux),
-            true);
-        gem.m_directoryLink = "C:/";
-        gem.m_documentationLink = "http://www.amazon.com";
-        gem.m_dependingGemUuids = QStringList({"EMotionFX", "Atom"});
-        gem.m_conflictingGemUuids = QStringList({"Vegetation", "Camera", "ScriptCanvas", "CloudCanvas", "Networking"});
-        gem.m_types = (GemInfo::Code | GemInfo::Asset);
-        gem.m_version = "v1.01";
-        gem.m_lastUpdatedDate = "24th April 2021";
-        gem.m_binarySizeInKB = 40;
-        gem.m_features = QStringList({"Animation", "Assets", "Physics"});
-        gem.m_gemOrigin = GemInfo::O3DEFoundation;
-        result.push_back(gem);
+        if (m_filterWidget)
+        {
+            m_filterWidget->hide();
+            m_filterWidget->deleteLater();
+        }
 
-        gem.m_name = "Atom";
-        gem.m_creator = "O3DE Seattle";
-        gem.m_summary = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.";
-        gem.m_platforms = (GemInfo::Android | GemInfo::Windows | GemInfo::Linux | GemInfo::macOS);
-        gem.m_isAdded = true;
-        gem.m_directoryLink = "C:/";
-        gem.m_documentationLink = "https://aws.amazon.com/gametech/";
-        gem.m_dependingGemUuids = QStringList({"EMotionFX", "Core", "AudioSystem", "Camera", "Particles"});
-        gem.m_conflictingGemUuids = QStringList({"CloudCanvas", "NovaNet"});
-        gem.m_version = "v2.31";
-        gem.m_lastUpdatedDate = "24th November 2020";
-        gem.m_features = QStringList({"Assets", "Rendering", "UI", "VR", "Debug", "Environment"});
-        gem.m_binarySizeInKB = 2087;
-        result.push_back(gem);
+        m_filterWidget = new GemFilterWidget(m_proxModel);
+        m_filterWidgetLayout->addWidget(m_filterWidget);
 
-        gem.m_name = "Physics";
-        gem.m_creator = "O3DE London";
-        gem.m_summary = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
-        gem.m_platforms = (GemInfo::Android | GemInfo::Linux | GemInfo::macOS);
-        gem.m_isAdded = true;
-        gem.m_directoryLink = "C:/";
-        gem.m_documentationLink = "https://aws.amazon.com/gametech/";
-        gem.m_dependingGemUuids = QStringList({"GraphCanvas", "ExpressionEvaluation", "UI Lib", "Multiplayer", "GameStateSamples"});
-        gem.m_conflictingGemUuids = QStringList({"Cloud Canvas", "EMotion FX", "Streaming", "MessagePopup", "Cloth", "Graph Canvas", "Twitch Integration"});
-        gem.m_version = "v1.5.102145";
-        gem.m_lastUpdatedDate = "1st January 2021";
-        gem.m_binarySizeInKB = 2000000;
-        gem.m_features = QStringList({"Physics", "Gameplay", "Debug", "Assets"});
-        result.push_back(gem);
+        m_proxModel->InvalidateFilter();
 
-        result.push_back(O3DE::ProjectManager::GemInfo("Certificate Manager",
-            "O3DE Irvine",
-            "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.",
-            GemInfo::Windows,
-            false));
+        // Select the first entry after everything got correctly sized
+        QTimer::singleShot(200, [=]{
+            QModelIndex firstModelIndex = m_gemListView->model()->index(0,0);
+            m_gemListView->selectionModel()->select(firstModelIndex, QItemSelectionModel::ClearAndSelect);
+            });
+    }
 
-        result.push_back(O3DE::ProjectManager::GemInfo("Cloud Gem Framework",
-            "O3DE Seattle",
-            "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.",
-            GemInfo::iOS | GemInfo::Linux,
-            false));
+    void GemCatalogScreen::FillModel(const QString& projectPath, bool isNewProject)
+    {
+        AZ::Outcome<QVector<GemInfo>, AZStd::string> allGemInfosResult;
+        if (isNewProject)
+        {
+            allGemInfosResult = PythonBindingsInterface::Get()->GetEngineGemInfos();
+        }
+        else
+        {
+            allGemInfosResult = PythonBindingsInterface::Get()->GetAllGemInfos(projectPath);
+        }
 
-        result.push_back(O3DE::ProjectManager::GemInfo("Cloud Gem Core",
-            "O3DE Foundation",
-            "Lorem ipsum dolor sit amet, consectetur adipiscing elit.",
-            GemInfo::Android | GemInfo::Windows | GemInfo::Linux,
-            true));
+        if (allGemInfosResult.IsSuccess())
+        {
+            // Add all available gems to the model.
+            const QVector<GemInfo> allGemInfos = allGemInfosResult.GetValue();
+            for (const GemInfo& gemInfo : allGemInfos)
+            {
+                m_gemModel->AddGem(gemInfo);
+            }
 
-        result.push_back(O3DE::ProjectManager::GemInfo("Gestures",
-            "O3DE Foundation",
-            "Lorem ipsum dolor sit amet, consectetur adipiscing elit.",
-            GemInfo::Android | GemInfo::Windows | GemInfo::Linux,
-            false));
+            // Gather enabled gems for the given project.
+            auto enabledGemNamesResult = PythonBindingsInterface::Get()->GetEnabledGemNames(projectPath);
+            if (enabledGemNamesResult.IsSuccess())
+            {
+                const QVector<AZStd::string> enabledGemNames = enabledGemNamesResult.GetValue();
+                for (const AZStd::string& enabledGemName : enabledGemNames)
+                {
+                    const QModelIndex modelIndex = m_gemModel->FindIndexByNameString(enabledGemName.c_str());
+                    if (modelIndex.isValid())
+                    {
+                        GemModel::SetWasPreviouslyAdded(*m_gemModel, modelIndex, true);
+                        GemModel::SetIsAdded(*m_gemModel, modelIndex, true);
+                    }
+                    else
+                    {
+                        AZ_Warning("ProjectManager::GemCatalog", false,
+                            "Cannot find entry for gem with name '%s'. The CMake target name probably does not match the specified name in the gem.json.",
+                            enabledGemName.c_str());
+                    }
+                }
+            }
+            else
+            {
+                QMessageBox::critical(nullptr, tr("Operation failed"), QString("Cannot retrieve enabled gems for project %1.\n\nError:\n%2").arg(projectPath, enabledGemNamesResult.GetError().c_str()));
+            }
+        }
+        else
+        {
+            QMessageBox::critical(nullptr, tr("Operation failed"), QString("Cannot retrieve gems for %1.\n\nError:\n%2").arg(projectPath, allGemInfosResult.GetError().c_str()));
+        }
+    }
 
-        result.push_back(O3DE::ProjectManager::GemInfo("Effects System",
-            "O3DE Foundation",
-            "Lorem ipsum dolor sit amet, consectetur adipiscing elit.",
-            GemInfo::Android | GemInfo::Windows | GemInfo::Linux,
-            true));
+    void GemCatalogScreen::EnableDisableGemsForProject(const QString& projectPath)
+    {
+        IPythonBindings* pythonBindings = PythonBindingsInterface::Get();
+        QVector<QModelIndex> toBeAdded = m_gemModel->GatherGemsToBeAdded();
+        QVector<QModelIndex> toBeRemoved = m_gemModel->GatherGemsToBeRemoved();
 
-        result.push_back(O3DE::ProjectManager::GemInfo("Microphone",
-            "O3DE Foundation",
-            "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vivamus euismod ligula vitae dui dictum, a sodales dolor luctus. Sed id elit dapibus, finibus neque sed, efficitur mi. Nam facilisis ligula at eleifend pellentesque. Praesent non ex consectetur, blandit tellus in, venenatis lacus. Duis nec neque in urna ullamcorper euismod id eu leo. Nam efficitur dolor sed odio vehicula venenatis. Suspendisse nec est non velit commodo cursus in sit amet dui. Ut bibendum nisl et libero hendrerit dapibus. Vestibulum ultrices ullamcorper urna, placerat porttitor est lobortis in. Interdum et malesuada fames ac ante ipsum primis in faucibus. Integer a magna ac tellus sollicitudin porttitor. Phasellus lobortis viverra justo id bibendum. Etiam ac pharetra risus. Nulla vitae justo nibh. Nulla viverra leo et molestie interdum. Duis sit amet bibendum nulla, sit amet vehicula augue.",
-            GemInfo::Android | GemInfo::Windows | GemInfo::Linux,
-            false));
+        for (const QModelIndex& modelIndex : toBeAdded)
+        {
+            const QString gemPath = GemModel::GetPath(modelIndex);
+            const AZ::Outcome<void, AZStd::string> result = pythonBindings->AddGemToProject(gemPath, projectPath);
+            if (!result.IsSuccess())
+            {
+                QMessageBox::critical(nullptr, "Operation failed",
+                    QString("Cannot add gem %1 to project.\n\nError:\n%2").arg(GemModel::GetName(modelIndex), result.GetError().c_str()));
+            }
+        }
 
-        return result;
+        for (const QModelIndex& modelIndex : toBeRemoved)
+        {
+            const QString gemPath = GemModel::GetPath(modelIndex);
+            const AZ::Outcome<void, AZStd::string> result = pythonBindings->RemoveGemFromProject(gemPath, projectPath);
+            if (!result.IsSuccess())
+            {
+                QMessageBox::critical(nullptr, "Operation failed",
+                    QString("Cannot remove gem %1 from project.\n\nError:\n%2").arg(GemModel::GetName(modelIndex), result.GetError().c_str()));
+            }
+        }
     }
 
     ProjectManagerScreen GemCatalogScreen::GetScreenEnum()

Code/Tools/ProjectManager/Source/GemCatalog/GemCatalogScreen.h

@@ -14,9 +14,11 @@
 
 #if !defined(Q_MOC_RUN)
 #include <ScreenWidget.h>
+#include <GemCatalog/GemFilterWidget.h>
 #include <GemCatalog/GemListView.h>
 #include <GemCatalog/GemInspector.h>
 #include <GemCatalog/GemModel.h>
+#include <GemCatalog/GemSortFilterProxyModel.h>
 #endif
 
 namespace O3DE::ProjectManager
@@ -29,11 +31,17 @@ namespace O3DE::ProjectManager
         ~GemCatalogScreen() = default;
         ProjectManagerScreen GetScreenEnum() override;
 
+        void ReinitForProject(const QString& projectPath, bool isNewProject);
+        void EnableDisableGemsForProject(const QString& projectPath);
+
     private:
-        QVector<GemInfo> GenerateTestData();
+        void FillModel(const QString& projectPath, bool isNewProject);
 
         GemListView* m_gemListView = nullptr;
         GemInspector* m_gemInspector = nullptr;
         GemModel* m_gemModel = nullptr;
+        GemSortFilterProxyModel* m_proxModel = nullptr;
+        QVBoxLayout* m_filterWidgetLayout = nullptr;
+        GemFilterWidget* m_filterWidget = nullptr;
     };
 } // namespace O3DE::ProjectManager

Code/Tools/ProjectManager/Source/GemCatalog/GemInfo.cpp

@@ -79,4 +79,9 @@ namespace O3DE::ProjectManager
     {
         return (m_platforms & platform);
     }
+
+    bool GemInfo::operator<(const GemInfo& gemInfo) const
+    {
+        return (m_displayName < gemInfo.m_displayName);
+    }
 } // namespace O3DE::ProjectManager

Code/Tools/ProjectManager/Source/GemCatalog/GemInfo.h

@@ -61,6 +61,8 @@ namespace O3DE::ProjectManager
 
         bool IsValid() const;
 
+        bool operator<(const GemInfo& gemInfo) const;
+
         QString m_path;
         QString m_name = "Unknown Gem Name";
         QString m_displayName = "Unknown Gem Name";

Code/Tools/ProjectManager/Source/GemCatalog/GemItemDelegate.cpp

@@ -131,6 +131,22 @@ namespace O3DE::ProjectManager
             return false;
         }
 
+        if (event->type() == QEvent::MouseButtonPress)
+        {
+            QMouseEvent* mouseEvent = static_cast<QMouseEvent*>(event);
+
+            QRect fullRect, itemRect, contentRect;
+            CalcRects(option, fullRect, itemRect, contentRect);
+            const QRect buttonRect = CalcButtonRect(contentRect);
+
+            if (buttonRect.contains(mouseEvent->pos()))
+            {
+                const bool isAdded = GemModel::IsAdded(modelIndex);
+                GemModel::SetIsAdded(*model, modelIndex, !isAdded);
+                return true;
+            }
+        }
+
         return QStyledItemDelegate::editorEvent(event, model, option, modelIndex);
     }
 

Code/Tools/ProjectManager/Source/GemCatalog/GemModel.cpp

@@ -38,6 +38,7 @@ namespace O3DE::ProjectManager
         item->setData(aznumeric_cast<int>(gemInfo.m_platforms), RolePlatforms);
         item->setData(aznumeric_cast<int>(gemInfo.m_types), RoleTypes);
         item->setData(gemInfo.m_summary, RoleSummary);
+        item->setData(false, RoleWasPreviouslyAdded);
         item->setData(gemInfo.m_isAdded, RoleIsAdded);
         item->setData(gemInfo.m_directoryLink, RoleDirectoryLink);
         item->setData(gemInfo.m_documentationLink, RoleDocLink);
@@ -47,6 +48,7 @@ namespace O3DE::ProjectManager
         item->setData(gemInfo.m_lastUpdatedDate, RoleLastUpdated);
         item->setData(gemInfo.m_binarySizeInKB, RoleBinarySize);
         item->setData(gemInfo.m_features, RoleFeatures);
+        item->setData(gemInfo.m_path, RolePath);
 
         appendRow(item);
 
@@ -89,11 +91,6 @@ namespace O3DE::ProjectManager
         return modelIndex.data(RoleSummary).toString();
     }
 
-    bool GemModel::IsAdded(const QModelIndex& modelIndex)
-    {
-        return modelIndex.data(RoleIsAdded).toBool();
-    }
-
     QString GemModel::GetDirectoryLink(const QModelIndex& modelIndex)
     {
         return modelIndex.data(RoleDirectoryLink).toString();
@@ -180,4 +177,62 @@ namespace O3DE::ProjectManager
     {
         return modelIndex.data(RoleFeatures).toStringList();
     }
+
+    QString GemModel::GetPath(const QModelIndex& modelIndex)
+    {
+        return modelIndex.data(RolePath).toString();
+    }
+
+    bool GemModel::IsAdded(const QModelIndex& modelIndex)
+    {
+        return modelIndex.data(RoleIsAdded).toBool();
+    }
+
+    void GemModel::SetIsAdded(QAbstractItemModel& model, const QModelIndex& modelIndex, bool isAdded)
+    {
+        model.setData(modelIndex, isAdded, RoleIsAdded);
+    }
+
+    void GemModel::SetWasPreviouslyAdded(QAbstractItemModel& model, const QModelIndex& modelIndex, bool wasAdded)
+    {
+        model.setData(modelIndex, wasAdded, RoleWasPreviouslyAdded);
+    }
+
+    bool GemModel::NeedsToBeAdded(const QModelIndex& modelIndex)
+    {
+        return (!modelIndex.data(RoleWasPreviouslyAdded).toBool() && modelIndex.data(RoleIsAdded).toBool());
+    }
+
+    bool GemModel::NeedsToBeRemoved(const QModelIndex& modelIndex)
+    {
+        return (modelIndex.data(RoleWasPreviouslyAdded).toBool() && !modelIndex.data(RoleIsAdded).toBool());
+    }
+
+    QVector<QModelIndex> GemModel::GatherGemsToBeAdded() const
+    {
+        QVector<QModelIndex> result;
+        for (int row = 0; row < rowCount(); ++row)
+        {
+            const QModelIndex modelIndex = index(row, 0);
+            if (NeedsToBeAdded(modelIndex))
+            {
+                result.push_back(modelIndex);
+            }
+        }
+        return result;
+    }
+
+    QVector<QModelIndex> GemModel::GatherGemsToBeRemoved() const
+    {
+        QVector<QModelIndex> result;
+        for (int row = 0; row < rowCount(); ++row)
+        {
+            const QModelIndex modelIndex = index(row, 0);
+            if (NeedsToBeRemoved(modelIndex))
+            {
+                result.push_back(modelIndex);
+            }
+        }
+        return result;
+    }
 } // namespace O3DE::ProjectManager

Code/Tools/ProjectManager/Source/GemCatalog/GemModel.h

@@ -46,13 +46,22 @@ namespace O3DE::ProjectManager
         static GemInfo::Platforms GetPlatforms(const QModelIndex& modelIndex);
         static GemInfo::Types GetTypes(const QModelIndex& modelIndex);
         static QString GetSummary(const QModelIndex& modelIndex);
-        static bool IsAdded(const QModelIndex& modelIndex);
         static QString GetDirectoryLink(const QModelIndex& modelIndex);
         static QString GetDocLink(const QModelIndex& modelIndex);
         static QString GetVersion(const QModelIndex& modelIndex);
         static QString GetLastUpdated(const QModelIndex& modelIndex);
         static int GetBinarySizeInKB(const QModelIndex& modelIndex);
         static QStringList GetFeatures(const QModelIndex& modelIndex);
+        static QString GetPath(const QModelIndex& modelIndex);
+
+        static bool IsAdded(const QModelIndex& modelIndex);
+        static void SetIsAdded(QAbstractItemModel& model, const QModelIndex& modelIndex, bool isAdded);
+        static void SetWasPreviouslyAdded(QAbstractItemModel& model, const QModelIndex& modelIndex, bool wasAdded);
+        static bool NeedsToBeAdded(const QModelIndex& modelIndex);
+        static bool NeedsToBeRemoved(const QModelIndex& modelIndex);
+
+        QVector<QModelIndex> GatherGemsToBeAdded() const;
+        QVector<QModelIndex> GatherGemsToBeRemoved() const;
 
     private:
         enum UserRole
@@ -62,6 +71,7 @@ namespace O3DE::ProjectManager
             RoleGemOrigin,
             RolePlatforms,
             RoleSummary,
+            RoleWasPreviouslyAdded,
             RoleIsAdded,
             RoleDirectoryLink,
             RoleDocLink,
@@ -71,7 +81,8 @@ namespace O3DE::ProjectManager
             RoleLastUpdated,
             RoleBinarySize,
             RoleFeatures,
-            RoleTypes
+            RoleTypes,
+            RolePath
         };
 
         QHash<QString, QModelIndex> m_nameToIndexMap;

Code/Tools/ProjectManager/Source/NewProjectSettingsScreen.cpp

@@ -15,6 +15,7 @@
 #include <FormLineEditWidget.h>
 #include <FormBrowseEditWidget.h>
 #include <PathValidator.h>
+#include <EngineInfo.h>
 
 #include <QVBoxLayout>
 #include <QHBoxLayout>
@@ -33,83 +34,72 @@ namespace O3DE::ProjectManager
     constexpr const char* k_pathProperty = "Path";
 
     NewProjectSettingsScreen::NewProjectSettingsScreen(QWidget* parent)
-        : ScreenWidget(parent)
+        : ProjectSettingsScreen(parent)
     {
-        QHBoxLayout* hLayout = new QHBoxLayout(this);
-        hLayout->setAlignment(Qt::AlignLeft);
-        hLayout->setContentsMargins(0,0,0,0);
+        const QString defaultName{ "NewProject" };
+        const QString defaultPath = QDir::toNativeSeparators(GetDefaultProjectPath() + "/" + defaultName);
 
-        // if we don't provide a parent for this box layout the stylesheet doesn't take
-        // if we don't set this in a frame (just use a sub-layout) all the content will align incorrectly horizontally
-        QFrame* projectSettingsFrame = new QFrame(this);
-        projectSettingsFrame->setObjectName("projectSettings");
-        QVBoxLayout* vLayout = new QVBoxLayout(this);
+        m_projectName->lineEdit()->setText(defaultName);
+        m_projectPath->lineEdit()->setText(defaultPath);
 
-        // you cannot remove content margins in qss
-        vLayout->setContentsMargins(0,0,0,0);
-        vLayout->setAlignment(Qt::AlignTop);
+        // if we don't use a QFrame we cannot "contain" the widgets inside and move them around
+        // as a group
+        QFrame* projectTemplateWidget = new QFrame(this);
+        projectTemplateWidget->setObjectName("projectTemplate");
+        QVBoxLayout* containerLayout = new QVBoxLayout();
+        containerLayout->setAlignment(Qt::AlignTop);
         {
-            m_projectName = new FormLineEditWidget(tr("Project name"), tr("New Project"), this);
-            m_projectName->setErrorLabelText(
-                tr("A project with this name already exists at this location. Please choose a new name or location."));
-            vLayout->addWidget(m_projectName);
+            QLabel* projectTemplateLabel = new QLabel(tr("Select a Project Template"));
+            projectTemplateLabel->setObjectName("projectTemplateLabel");
+            containerLayout->addWidget(projectTemplateLabel);
 
-            m_projectPath =
-                new FormBrowseEditWidget(tr("Project Location"), QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation), this);
-            m_projectPath->lineEdit()->setReadOnly(true);
-            m_projectPath->setErrorLabelText(tr("Please provide a valid path to a folder that exists"));
-            m_projectPath->lineEdit()->setValidator(new PathValidator(PathValidator::PathMode::ExistingFolder, this));
-            vLayout->addWidget(m_projectPath);
+            QLabel* projectTemplateDetailsLabel = new QLabel(tr("Project templates are pre-configured with relevant Gems that provide "
+                                                                "additional functionality and content to the project."));
+            projectTemplateDetailsLabel->setWordWrap(true);
+            projectTemplateDetailsLabel->setObjectName("projectTemplateDetailsLabel");
+            containerLayout->addWidget(projectTemplateDetailsLabel);
 
-            // if we don't use a QFrame we cannot "contain" the widgets inside and move them around
-            // as a group
-            QFrame* projectTemplateWidget = new QFrame(this);
-            projectTemplateWidget->setObjectName("projectTemplate");
-            QVBoxLayout* containerLayout = new QVBoxLayout();
-            containerLayout->setAlignment(Qt::AlignTop);
+            QHBoxLayout* templateLayout = new QHBoxLayout(this);
+            containerLayout->addItem(templateLayout);
+
+            m_projectTemplateButtonGroup = new QButtonGroup(this);
+            m_projectTemplateButtonGroup->setObjectName("templateButtonGroup");
+            auto templatesResult = PythonBindingsInterface::Get()->GetProjectTemplates();
+            if (templatesResult.IsSuccess() && !templatesResult.GetValue().isEmpty())
             {
-                QLabel* projectTemplateLabel = new QLabel(tr("Select a Project Template"));
-                projectTemplateLabel->setObjectName("projectTemplateLabel");
-                containerLayout->addWidget(projectTemplateLabel);
-
-                QLabel* projectTemplateDetailsLabel = new QLabel(tr("Project templates are pre-configured with relevant Gems that provide "
-                                                                    "additional functionality and content to the project."));
-                projectTemplateDetailsLabel->setWordWrap(true);
-                projectTemplateDetailsLabel->setObjectName("projectTemplateDetailsLabel");
-                containerLayout->addWidget(projectTemplateDetailsLabel);
-
-                QHBoxLayout* templateLayout = new QHBoxLayout(this);
-                containerLayout->addItem(templateLayout);
-
-                m_projectTemplateButtonGroup = new QButtonGroup(this);
-                m_projectTemplateButtonGroup->setObjectName("templateButtonGroup");
-                auto templatesResult = PythonBindingsInterface::Get()->GetProjectTemplates();
-                if (templatesResult.IsSuccess() && !templatesResult.GetValue().isEmpty())
+                for (const ProjectTemplateInfo& projectTemplate : templatesResult.GetValue())
                 {
-                    for (auto projectTemplate : templatesResult.GetValue())
-                    {
-                        QRadioButton* radioButton = new QRadioButton(projectTemplate.m_name, this);
-                        radioButton->setProperty(k_pathProperty, projectTemplate.m_path);
-                        m_projectTemplateButtonGroup->addButton(radioButton);
+                    QRadioButton* radioButton = new QRadioButton(projectTemplate.m_name, this);
+                    radioButton->setProperty(k_pathProperty, projectTemplate.m_path);
+                    m_projectTemplateButtonGroup->addButton(radioButton);
 
-                        containerLayout->addWidget(radioButton);
-                    }
-
-                    m_projectTemplateButtonGroup->buttons().first()->setChecked(true);
+                    containerLayout->addWidget(radioButton);
                 }
-            }
-            projectTemplateWidget->setLayout(containerLayout);
-            vLayout->addWidget(projectTemplateWidget);
-        }
-        projectSettingsFrame->setLayout(vLayout);
 
-        hLayout->addWidget(projectSettingsFrame);
+                m_projectTemplateButtonGroup->buttons().first()->setChecked(true);
+            }
+        }
+        projectTemplateWidget->setLayout(containerLayout);
+        m_verticalLayout->addWidget(projectTemplateWidget);
 
         QWidget* projectTemplateDetails = new QWidget(this);
         projectTemplateDetails->setObjectName("projectTemplateDetails");
-        hLayout->addWidget(projectTemplateDetails);
+        m_horizontalLayout->addWidget(projectTemplateDetails);
+    }
 
-        this->setLayout(hLayout);
+    QString NewProjectSettingsScreen::GetDefaultProjectPath()
+    {
+        QString defaultPath = QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation);
+        AZ::Outcome<EngineInfo> engineInfoResult = PythonBindingsInterface::Get()->GetEngineInfo();
+        if (engineInfoResult.IsSuccess())
+        {
+            QDir path(QDir::toNativeSeparators(engineInfoResult.GetValue().m_defaultProjectsFolder));
+            if (path.exists())
+            {
+                defaultPath = path.absolutePath();
+            }
+        }
+        return defaultPath;
     }
 
     ProjectManagerScreen NewProjectSettingsScreen::GetScreenEnum()
@@ -117,40 +107,13 @@ namespace O3DE::ProjectManager
         return ProjectManagerScreen::NewProjectSettings;
     }
 
-
-    ProjectInfo NewProjectSettingsScreen::GetProjectInfo()
+    void NewProjectSettingsScreen::NotifyCurrentScreen()
     {
-        ProjectInfo projectInfo;
-        projectInfo.m_projectName = m_projectName->lineEdit()->text();
-        projectInfo.m_path        = QDir::toNativeSeparators(m_projectPath->lineEdit()->text() + "/" + projectInfo.m_projectName);
-        return projectInfo;
+        Validate();
     }
 
     QString NewProjectSettingsScreen::GetProjectTemplatePath()
     {
         return m_projectTemplateButtonGroup->checkedButton()->property(k_pathProperty).toString();
     }
-
-    bool NewProjectSettingsScreen::Validate()
-    {
-        bool projectNameIsValid = true;
-        if (m_projectName->lineEdit()->text().isEmpty())
-        {
-            projectNameIsValid = false;
-        }
-
-        bool projectPathIsValid = true;
-        if (m_projectPath->lineEdit()->text().isEmpty())
-        {
-            projectPathIsValid = false;
-        }
-
-        QDir path(QDir::toNativeSeparators(m_projectPath->lineEdit()->text() + "/" + m_projectName->lineEdit()->text()));
-        if (path.exists() && !path.isEmpty())
-        {
-            projectPathIsValid = false;
-        }
-
-        return projectNameIsValid && projectPathIsValid;
-    }
 } // namespace O3DE::ProjectManager

Code/Tools/ProjectManager/Source/NewProjectSettingsScreen.h

@@ -12,36 +12,28 @@
 #pragma once
 
 #if !defined(Q_MOC_RUN)
-#include <ScreenWidget.h>
-#include <ProjectInfo.h>
+#include <ProjectSettingsScreen.h>
 #endif
 
 QT_FORWARD_DECLARE_CLASS(QButtonGroup)
 
 namespace O3DE::ProjectManager
 {
-    QT_FORWARD_DECLARE_CLASS(FormLineEditWidget)
-    QT_FORWARD_DECLARE_CLASS(FormBrowseEditWidget)
-
     class NewProjectSettingsScreen
-        : public ScreenWidget
+        : public ProjectSettingsScreen
     {
     public:
         explicit NewProjectSettingsScreen(QWidget* parent = nullptr);
         ~NewProjectSettingsScreen() = default;
         ProjectManagerScreen GetScreenEnum() override;
 
-        ProjectInfo GetProjectInfo();
         QString GetProjectTemplatePath();
 
-        bool Validate();
-
-    protected slots:
-        void HandleBrowseButton();
+        void NotifyCurrentScreen() override;
 
     private:
-        FormLineEditWidget* m_projectName;
-        FormBrowseEditWidget* m_projectPath;
+        QString GetDefaultProjectPath();
+
         QButtonGroup* m_projectTemplateButtonGroup;
     };
 

Code/Tools/ProjectManager/Source/ProjectButtonWidget.cpp

@@ -22,8 +22,6 @@
 #include <QMenu>
 #include <QSpacerItem>
 
-//#define SHOW_ALL_PROJECT_ACTIONS
-
 namespace O3DE::ProjectManager
 {
     inline constexpr static int s_projectImageWidth = 210;
@@ -96,10 +94,6 @@ namespace O3DE::ProjectManager
         m_removeProjectAction = newProjectMenu->addAction(tr("Remove from O3DE"));
         m_deleteProjectAction = newProjectMenu->addAction(tr("Delete this Project"));
 
-#ifdef SHOW_ALL_PROJECT_ACTIONS
-        m_editProjectGemsAction = newProjectMenu->addAction(tr("Cutomize Gems..."));
-#endif
-
         QFrame* footer = new QFrame(this);
         QHBoxLayout* hLayout = new QHBoxLayout();
         hLayout->setContentsMargins(0, 0, 0, 0);
@@ -121,10 +115,6 @@ namespace O3DE::ProjectManager
         connect(m_copyProjectAction, &QAction::triggered, [this]() { emit CopyProject(m_projectInfo.m_path); });
         connect(m_removeProjectAction, &QAction::triggered, [this]() { emit RemoveProject(m_projectInfo.m_path); });
         connect(m_deleteProjectAction, &QAction::triggered, [this]() { emit DeleteProject(m_projectInfo.m_path); });
-
-#ifdef SHOW_ALL_PROJECT_ACTIONS
-        connect(m_editProjectGemsAction, &QAction::triggered, [this]() { emit EditProjectGems(m_projectInfo.m_path); });
-#endif
     }
 
     void ProjectButton::SetButtonEnabled(bool enabled)

Code/Tools/ProjectManager/Source/ProjectButtonWidget.h

@@ -62,7 +62,6 @@ namespace O3DE::ProjectManager
     signals:
         void OpenProject(const QString& projectName);
         void EditProject(const QString& projectName);
-        void EditProjectGems(const QString& projectName);
         void CopyProject(const QString& projectName);
         void RemoveProject(const QString& projectName);
         void DeleteProject(const QString& projectName);
@@ -73,7 +72,6 @@ namespace O3DE::ProjectManager
         ProjectInfo m_projectInfo;
         LabelButton* m_projectImageLabel;
         QAction* m_editProjectAction;
-        QAction* m_editProjectGemsAction;
         QAction* m_copyProjectAction;
         QAction* m_removeProjectAction;
         QAction* m_deleteProjectAction;

Code/Tools/ProjectManager/Source/ProjectInfo.cpp

@@ -25,6 +25,19 @@ namespace O3DE::ProjectManager
     {
     }
 
+    bool ProjectInfo::operator==(const ProjectInfo& rhs)
+    {
+        return m_path == rhs.m_path
+            && m_projectName == rhs.m_projectName
+            && m_imagePath == rhs.m_imagePath
+            && m_backgroundImagePath == rhs.m_backgroundImagePath;
+    }
+
+    bool ProjectInfo::operator!=(const ProjectInfo& rhs)
+    {
+        return !operator==(rhs);
+    }
+
     bool ProjectInfo::IsValid() const
     {
         return !m_path.isEmpty() && !m_projectName.isEmpty();

Code/Tools/ProjectManager/Source/ProjectInfo.h

@@ -25,6 +25,8 @@ namespace O3DE::ProjectManager
         ProjectInfo() = default;
         ProjectInfo(const QString& path, const QString& projectName, const QString& displayName,
             const QString& imagePath, const QString& backgroundImagePath, bool isNew);
+        bool operator==(const ProjectInfo& rhs);
+        bool operator!=(const ProjectInfo& rhs);
 
         bool IsValid() const;
 

Code/Tools/ProjectManager/Source/ProjectManagerWindow.cpp

@@ -14,13 +14,16 @@
 #include <ScreensCtrl.h>
 
 #include <AzQtComponents/Components/StyleManager.h>
+#include <AzCore/IO/FileIO.h>
 #include <AzCore/IO/Path/Path.h>
+#include <AzFramework/CommandLine/CommandLine.h>
+#include <AzFramework/Application/Application.h>
 
 #include <QDir>
 
 namespace O3DE::ProjectManager
 {
-    ProjectManagerWindow::ProjectManagerWindow(QWidget* parent, const AZ::IO::PathView& engineRootPath)
+    ProjectManagerWindow::ProjectManagerWindow(QWidget* parent, const AZ::IO::PathView& engineRootPath, const AZ::IO::PathView& projectPath, ProjectManagerScreen startScreen)
         : QMainWindow(parent)
     {
         m_pythonBindings = AZStd::make_unique<PythonBindings>(engineRootPath);
@@ -50,7 +53,18 @@ namespace O3DE::ProjectManager
         // set stylesheet after creating the screens or their styles won't get updated
         AzQtComponents::StyleManager::setStyleSheet(this, QStringLiteral("style:ProjectManager.qss"));
 
-        screensCtrl->ForceChangeToScreen(ProjectManagerScreen::Projects, false);
+        // always push the projects screen first so we have something to come back to
+        if (startScreen != ProjectManagerScreen::Projects)
+        {
+            screensCtrl->ForceChangeToScreen(ProjectManagerScreen::Projects);
+        }
+        screensCtrl->ForceChangeToScreen(startScreen);
+
+        if (!projectPath.empty())
+        {
+            const QString path = QString::fromUtf8(projectPath.Native().data(), aznumeric_cast<int>(projectPath.Native().size()));
+            emit screensCtrl->NotifyCurrentProject(path);
+        }
     }
 
     ProjectManagerWindow::~ProjectManagerWindow()

Code/Tools/ProjectManager/Source/ProjectManagerWindow.h

@@ -14,6 +14,7 @@
 #if !defined(Q_MOC_RUN)
 #include <QMainWindow>
 #include <PythonBindings.h>
+#include <ScreenDefs.h>
 #endif
 
 namespace O3DE::ProjectManager
@@ -24,7 +25,8 @@ namespace O3DE::ProjectManager
         Q_OBJECT
 
     public:
-        explicit ProjectManagerWindow(QWidget* parent, const AZ::IO::PathView& engineRootPath);
+        explicit ProjectManagerWindow(QWidget* parent, const AZ::IO::PathView& engineRootPath, const AZ::IO::PathView& projectPath,
+            ProjectManagerScreen startScreen = ProjectManagerScreen::Projects);
         ~ProjectManagerWindow();
 
     private:

Code/Tools/ProjectManager/Source/ProjectSettingsScreen.cpp

@@ -11,45 +11,131 @@
  */
 
 #include <ProjectSettingsScreen.h>
+#include <FormBrowseEditWidget.h>
+#include <FormLineEditWidget.h>
+#include <PathValidator.h>
+#include <PythonBindingsInterface.h>
 
-#include <Source/ui_ProjectSettingsScreen.h>
+#include <QFileDialog>
+#include <QFrame>
+#include <QHBoxLayout>
+#include <QVBoxLayout>
+#include <QLabel>
+#include <QLineEdit>
+#include <QStandardPaths>
 
 namespace O3DE::ProjectManager
 {
     ProjectSettingsScreen::ProjectSettingsScreen(QWidget* parent)
         : ScreenWidget(parent)
-        , m_ui(new Ui::ProjectSettingsClass())
     {
-        m_ui->setupUi(this);
+        m_horizontalLayout = new QHBoxLayout(this);
+        m_horizontalLayout->setAlignment(Qt::AlignLeft);
+        m_horizontalLayout->setContentsMargins(0, 0, 0, 0);
 
-        connect(m_ui->gemsButton, &QPushButton::pressed, this, &ProjectSettingsScreen::HandleGemsButton);
+        // if we don't provide a parent for this box layout the stylesheet doesn't take
+        // if we don't set this in a frame (just use a sub-layout) all the content will align incorrectly horizontally
+        QFrame* projectSettingsFrame = new QFrame(this);
+        projectSettingsFrame->setObjectName("projectSettings");
+        m_verticalLayout = new QVBoxLayout(this);
+
+        // you cannot remove content margins in qss
+        m_verticalLayout->setContentsMargins(0, 0, 0, 0);
+        m_verticalLayout->setAlignment(Qt::AlignTop);
+
+        m_projectName = new FormLineEditWidget(tr("Project name"), "", this);
+        connect(m_projectName->lineEdit(), &QLineEdit::textChanged, this, &ProjectSettingsScreen::ValidateProjectName);
+        m_verticalLayout->addWidget(m_projectName);
+
+        m_projectPath = new FormBrowseEditWidget(tr("Project Location"), "", this);
+        m_projectPath->lineEdit()->setReadOnly(true);
+        connect(m_projectPath->lineEdit(), &QLineEdit::textChanged, this, &ProjectSettingsScreen::Validate);
+        m_verticalLayout->addWidget(m_projectPath);
+
+        projectSettingsFrame->setLayout(m_verticalLayout);
+
+        m_horizontalLayout->addWidget(projectSettingsFrame);
+
+        setLayout(m_horizontalLayout);
     }
 
     ProjectManagerScreen ProjectSettingsScreen::GetScreenEnum()
     {
-        return ProjectManagerScreen::ProjectSettings;
+        return ProjectManagerScreen::Invalid;
+    }
+
+    QString ProjectSettingsScreen::GetDefaultProjectPath()
+    {
+        QString defaultPath = QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation);
+        AZ::Outcome<EngineInfo> engineInfoResult = PythonBindingsInterface::Get()->GetEngineInfo();
+        if (engineInfoResult.IsSuccess())
+        {
+            QDir path(QDir::toNativeSeparators(engineInfoResult.GetValue().m_defaultProjectsFolder));
+            if (path.exists())
+            {
+                defaultPath = path.absolutePath();
+            }
+        }
+        return defaultPath;
     }
 
     ProjectInfo ProjectSettingsScreen::GetProjectInfo()
     {
-        // Impl pending next PR
-        return ProjectInfo();
+        ProjectInfo projectInfo;
+        projectInfo.m_projectName = m_projectName->lineEdit()->text();
+        projectInfo.m_path = m_projectPath->lineEdit()->text();
+        return projectInfo;
     }
 
-    void ProjectSettingsScreen::SetProjectInfo()
+    bool ProjectSettingsScreen::ValidateProjectName()
     {
-        // Impl pending next PR
+        bool projectNameIsValid = true;
+        if (m_projectName->lineEdit()->text().isEmpty())
+        {
+            projectNameIsValid = false;
+            m_projectName->setErrorLabelText(tr("Please provide a project name."));
+        }
+        else
+        {
+            // this validation should roughly match the utils.validate_identifier which the cli
+            // uses to validate project names
+            QRegExp validProjectNameRegex("[A-Za-z][A-Za-z0-9_-]{0,63}");
+            const bool result = validProjectNameRegex.exactMatch(m_projectName->lineEdit()->text());
+            if (!result)
+            {
+                projectNameIsValid = false;
+                m_projectName->setErrorLabelText(
+                    tr("Project names must start with a letter and consist of up to 64 letter, number, '_' or '-' characters"));
+            }
+        }
+
+        m_projectName->setErrorLabelVisible(!projectNameIsValid);
+        return projectNameIsValid;
+    }
+    bool ProjectSettingsScreen::ValidateProjectPath()
+    {
+        bool projectPathIsValid = true;
+        if (m_projectPath->lineEdit()->text().isEmpty())
+        {
+            projectPathIsValid = false;
+            m_projectPath->setErrorLabelText(tr("Please provide a valid location."));
+        }
+        else
+        {
+            QDir path(m_projectPath->lineEdit()->text());
+            if (path.exists() && !path.isEmpty())
+            {
+                projectPathIsValid = false;
+                m_projectPath->setErrorLabelText(tr("This folder exists and isn't empty.  Please choose a different location."));
+            }
+        }
+
+        m_projectPath->setErrorLabelVisible(!projectPathIsValid);
+        return projectPathIsValid;
     }
 
     bool ProjectSettingsScreen::Validate()
     {
-        // Impl pending next PR
-        return true;
+        return ValidateProjectName() && ValidateProjectPath();
     }
-
-    void ProjectSettingsScreen::HandleGemsButton()
-    {
-        emit ChangeScreenRequest(ProjectManagerScreen::GemCatalog);
-    }
-
 } // namespace O3DE::ProjectManager

Code/Tools/ProjectManager/Source/ProjectSettingsScreen.h

@@ -12,17 +12,18 @@
 #pragma once
 
 #if !defined(Q_MOC_RUN)
-#include <ScreenWidget.h>
 #include <ProjectInfo.h>
+#include <ScreenWidget.h>
 #endif
 
-namespace Ui
-{
-    class ProjectSettingsClass;
-}
+QT_FORWARD_DECLARE_CLASS(QHBoxLayout)
+QT_FORWARD_DECLARE_CLASS(QVBoxLayout)
 
 namespace O3DE::ProjectManager
 {
+    QT_FORWARD_DECLARE_CLASS(FormLineEditWidget)
+    QT_FORWARD_DECLARE_CLASS(FormBrowseEditWidget)
+
     class ProjectSettingsScreen
         : public ScreenWidget
     {
@@ -32,15 +33,20 @@ namespace O3DE::ProjectManager
         ProjectManagerScreen GetScreenEnum() override;
 
         ProjectInfo GetProjectInfo();
-        void SetProjectInfo();
 
         bool Validate();
 
     protected slots:
-        void HandleGemsButton();
+        virtual bool ValidateProjectName();
+        virtual bool ValidateProjectPath();
 
-    private:
-        QScopedPointer<Ui::ProjectSettingsClass> m_ui;
+    protected:
+        QString GetDefaultProjectPath();
+
+        QHBoxLayout* m_horizontalLayout;
+        QVBoxLayout* m_verticalLayout;
+        FormLineEditWidget* m_projectName;
+        FormBrowseEditWidget* m_projectPath;
     };
 
 } // namespace O3DE::ProjectManager

Code/Tools/ProjectManager/Source/ProjectSettingsScreen.ui

@@ -1,113 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<ui version="4.0">
- <class>ProjectSettingsClass</class>
- <widget class="QWidget" name="ProjectSettingsClass">
-  <property name="geometry">
-   <rect>
-    <x>0</x>
-    <y>0</y>
-    <width>782</width>
-    <height>579</height>
-   </rect>
-  </property>
-  <property name="windowTitle">
-   <string>Form</string>
-  </property>
-  <layout class="QVBoxLayout" name="verticalLayout">
-   <item>
-    <layout class="QHBoxLayout" name="horizontalLayout">
-     <item>
-      <widget class="QPushButton" name="projectSettingsButton">
-       <property name="text">
-        <string>Project Settings</string>
-       </property>
-      </widget>
-     </item>
-     <item>
-      <widget class="QPushButton" name="gemsButton">
-       <property name="text">
-        <string>Gems</string>
-       </property>
-      </widget>
-     </item>
-     <item>
-      <spacer name="horizontalSpacer">
-       <property name="orientation">
-        <enum>Qt::Horizontal</enum>
-       </property>
-       <property name="sizeHint" stdset="0">
-        <size>
-         <width>761</width>
-         <height>20</height>
-        </size>
-       </property>
-      </spacer>
-     </item>
-    </layout>
-   </item>
-   <item>
-    <layout class="QHBoxLayout" name="horizontalLayout_2">
-     <item>
-      <layout class="QVBoxLayout" name="verticalLayout_4">
-       <item>
-        <widget class="QLabel" name="label">
-         <property name="text">
-          <string>Project Name</string>
-         </property>
-        </widget>
-       </item>
-       <item>
-        <widget class="QLineEdit" name="lineEdit"/>
-       </item>
-       <item>
-        <widget class="QLabel" name="label_2">
-         <property name="text">
-          <string>Project Location</string>
-         </property>
-        </widget>
-       </item>
-       <item>
-        <widget class="QLineEdit" name="lineEdit_2"/>
-       </item>
-       <item>
-        <widget class="QLabel" name="label_3">
-         <property name="text">
-          <string>Project Image Location</string>
-         </property>
-        </widget>
-       </item>
-       <item>
-        <widget class="QLineEdit" name="lineEdit_3"/>
-       </item>
-       <item>
-        <widget class="QLabel" name="label_4">
-         <property name="text">
-          <string>Project Background Image Location</string>
-         </property>
-        </widget>
-       </item>
-       <item>
-        <widget class="QLineEdit" name="lineEdit_4"/>
-       </item>
-      </layout>
-     </item>
-     <item>
-      <spacer name="verticalSpacer">
-       <property name="orientation">
-        <enum>Qt::Vertical</enum>
-       </property>
-       <property name="sizeHint" stdset="0">
-        <size>
-         <width>20</width>
-         <height>40</height>
-        </size>
-       </property>
-      </spacer>
-     </item>
-    </layout>
-   </item>
-  </layout>
- </widget>
- <resources/>
- <connections/>
-</ui>

Code/Tools/ProjectManager/Source/ProjectUtils.cpp

@@ -192,5 +192,16 @@ namespace O3DE::ProjectManager
             return true;
         }
 
+        ProjectManagerScreen GetProjectManagerScreen(const QString& screen)
+        {
+            auto iter = s_ProjectManagerStringNames.find(screen);
+            if (iter != s_ProjectManagerStringNames.end())
+            {
+                return iter.value();
+            }
+
+            return ProjectManagerScreen::Invalid;
+        }
+
     } // namespace ProjectUtils
 } // namespace O3DE::ProjectManager

Code/Tools/ProjectManager/Source/ProjectUtils.h

@@ -11,6 +11,7 @@
  */
 #pragma once
 
+#include <ScreenDefs.h>
 #include <QWidget>
 
 namespace O3DE::ProjectManager
@@ -24,5 +25,6 @@ namespace O3DE::ProjectManager
         bool CopyProject(const QString& origPath, const QString& newPath);
         bool DeleteProjectFiles(const QString& path, bool force = false);
         bool MoveProject(const QString& origPath, const QString& newPath, QWidget* parent = nullptr);
+        ProjectManagerScreen GetProjectManagerScreen(const QString& screen);
     } // namespace ProjectUtils
 } // namespace O3DE::ProjectManager

Code/Tools/ProjectManager/Source/ProjectsScreen.cpp

@@ -182,10 +182,6 @@ namespace O3DE::ProjectManager
                     connect(projectButton, &ProjectButton::CopyProject, this, &ProjectsScreen::HandleCopyProject);
                     connect(projectButton, &ProjectButton::RemoveProject, this, &ProjectsScreen::HandleRemoveProject);
                     connect(projectButton, &ProjectButton::DeleteProject, this, &ProjectsScreen::HandleDeleteProject);
-
-#ifdef SHOW_ALL_PROJECT_ACTIONS
-                    connect(projectButton, &ProjectButton::EditProjectGems, this, &ProjectsScreen::HandleEditProjectGems);
-#endif
                 }
 
                 layout->addWidget(projectsScrollArea);
@@ -293,14 +289,8 @@ namespace O3DE::ProjectManager
     void ProjectsScreen::HandleEditProject(const QString& projectPath)
     {
         emit NotifyCurrentProject(projectPath);
-        emit ResetScreenRequest(ProjectManagerScreen::UpdateProject);
         emit ChangeScreenRequest(ProjectManagerScreen::UpdateProject);
     }
-    void ProjectsScreen::HandleEditProjectGems(const QString& projectPath)
-    {
-        emit NotifyCurrentProject(projectPath);
-        emit ChangeScreenRequest(ProjectManagerScreen::GemCatalog);
-    }
     void ProjectsScreen::HandleCopyProject(const QString& projectPath)
     {
         // Open file dialog and choose location for copied project then register copy with O3DE
@@ -341,6 +331,16 @@ namespace O3DE::ProjectManager
         }
         else
         {
+            // refresh the projects content by re-creating it for now
+            if (m_projectsContent)
+            {
+                m_stack->removeWidget(m_projectsContent);
+                m_projectsContent->deleteLater();
+            }
+
+            m_projectsContent = CreateProjectsContent();
+
+            m_stack->addWidget(m_projectsContent);
             m_stack->setCurrentWidget(m_projectsContent);
         }
     }

Code/Tools/ProjectManager/Source/ProjectsScreen.h

@@ -41,7 +41,6 @@ namespace O3DE::ProjectManager
         void HandleAddProjectButton();
         void HandleOpenProject(const QString& projectPath);
         void HandleEditProject(const QString& projectPath);
-        void HandleEditProjectGems(const QString& projectPath);
         void HandleCopyProject(const QString& projectPath);
         void HandleRemoveProject(const QString& projectPath);
         void HandleDeleteProject(const QString& projectPath);

Code/Tools/ProjectManager/Source/PythonBindings.cpp

@@ -283,12 +283,16 @@ namespace O3DE::ProjectManager
             AZ_Warning("ProjectManagerWindow", result != -1, "Append to sys path failed");
 
             // import required modules
+            m_cmake = pybind11::module::import("o3de.cmake");
             m_register = pybind11::module::import("o3de.register");
             m_manifest = pybind11::module::import("o3de.manifest");
             m_engineTemplate = pybind11::module::import("o3de.engine_template");
             m_enableGemProject = pybind11::module::import("o3de.enable_gem");
             m_disableGemProject = pybind11::module::import("o3de.disable_gem");
 
+            // make sure the engine is registered
+            RegisterThisEngine();
+
             return result == 0 && !PyErr_Occurred();
         } catch ([[maybe_unused]] const std::exception& e)
         {
@@ -311,7 +315,37 @@ namespace O3DE::ProjectManager
         return !PyErr_Occurred();
     }
 
-    bool PythonBindings::ExecuteWithLock(AZStd::function<void()> executionCallback)
+    bool PythonBindings::RegisterThisEngine()
+    {
+        bool registrationResult = true; // already registered is considered successful
+        bool pythonResult = ExecuteWithLock(
+            [&]
+            {
+                // check current engine path against all other registered engines
+                // to see if we are already registered
+                auto allEngines = m_manifest.attr("get_engines")();
+                if (pybind11::isinstance<pybind11::list>(allEngines))
+                {
+                    for (auto engine : allEngines)
+                    {
+                        AZ::IO::FixedMaxPath enginePath(Py_To_String(engine["path"]));
+                        if (enginePath.Compare(m_enginePath) == 0)
+                        {
+                            return;
+                        }
+                    }
+                }
+
+                auto result = m_register.attr("register")(m_enginePath.c_str());
+                registrationResult = (result.cast<int>() == 0);
+            });
+
+        bool finalResult = (registrationResult && pythonResult);
+        AZ_Assert(finalResult, "Registration of this engine failed!");
+        return finalResult;
+    }
+
+    AZ::Outcome<void, AZStd::string> PythonBindings::ExecuteWithLockErrorHandling(AZStd::function<void()> executionCallback)
     {
         AZStd::lock_guard<decltype(m_lock)> lock(m_lock);
         pybind11::gil_scoped_release release;
@@ -320,13 +354,19 @@ namespace O3DE::ProjectManager
         try
         {
             executionCallback();
-            return true;
         }
         catch ([[maybe_unused]] const std::exception& e)
         {
             AZ_Warning("PythonBindings", false, "Python exception %s", e.what());
-            return false;
+            return AZ::Failure<AZStd::string>(e.what());
         }
+
+        return AZ::Success();
+    }
+
+    bool PythonBindings::ExecuteWithLock(AZStd::function<void()> executionCallback)
+    {
+        return ExecuteWithLockErrorHandling(executionCallback).IsSuccess();
     }
 
     AZ::Outcome<EngineInfo> PythonBindings::GetEngineInfo()
@@ -419,7 +459,7 @@ namespace O3DE::ProjectManager
         return result;
     }
 
-    AZ::Outcome<GemInfo> PythonBindings::GetGem(const QString& path)
+    AZ::Outcome<GemInfo> PythonBindings::GetGemInfo(const QString& path)
     {
         GemInfo gemInfo = GemInfoFromPath(pybind11::str(path.toStdString()));
         if (gemInfo.IsValid())
@@ -432,32 +472,79 @@ namespace O3DE::ProjectManager
         }
     }
 
-    AZ::Outcome<QVector<GemInfo>> PythonBindings::GetGems()
+    AZ::Outcome<QVector<GemInfo>, AZStd::string> PythonBindings::GetEngineGemInfos()
     {
         QVector<GemInfo> gems;
 
-        bool result = ExecuteWithLock([&] {
-            // external gems
-            for (auto path : m_manifest.attr("get_gems")())
+        auto result = ExecuteWithLockErrorHandling([&]
             {
-                gems.push_back(GemInfoFromPath(path));
-            }
+                for (auto path : m_manifest.attr("get_engine_gems")())
+                {
+                    gems.push_back(GemInfoFromPath(path));
+                }
+            });
+        if (!result.IsSuccess())
+        {
+            return AZ::Failure<AZStd::string>(result.GetError().c_str());
+        }
 
-            // gems from the engine
-            for (auto path : m_manifest.attr("get_engine_gems")())
+        std::sort(gems.begin(), gems.end());
+        return AZ::Success(AZStd::move(gems));
+    }
+
+    AZ::Outcome<QVector<GemInfo>, AZStd::string> PythonBindings::GetAllGemInfos(const QString& projectPath)
+    {
+        QVector<GemInfo> gems;
+
+        auto result = ExecuteWithLockErrorHandling([&]
             {
-                gems.push_back(GemInfoFromPath(path));
-            }
-        });
+                pybind11::str pyProjectPath = projectPath.toStdString();
+                for (auto path : m_manifest.attr("get_all_gems")(pyProjectPath))
+                {
+                    gems.push_back(GemInfoFromPath(path));
+                }
+            });
+        if (!result.IsSuccess())
+        {
+            return AZ::Failure<AZStd::string>(result.GetError().c_str());
+        }
 
-        if (!result)
+        std::sort(gems.begin(), gems.end());
+        return AZ::Success(AZStd::move(gems));
+    }
+
+    AZ::Outcome<QVector<AZStd::string>, AZStd::string> PythonBindings::GetEnabledGemNames(const QString& projectPath)
+    {
+        // Retrieve the path to the cmake file that lists the enabled gems.
+        pybind11::str enabledGemsFilename;
+        auto result = ExecuteWithLockErrorHandling([&]
+            {
+                const pybind11::str pyProjectPath = projectPath.toStdString();
+                enabledGemsFilename = m_cmake.attr("get_enabled_gem_cmake_file")(
+                    pybind11::none(), // project_name
+                    pyProjectPath); // project_path
+            });
+        if (!result.IsSuccess())
         {
-            return AZ::Failure();
+            return AZ::Failure<AZStd::string>(result.GetError().c_str());
         }
-        else
+
+        // Retrieve the actual list of names from the cmake file.
+        QVector<AZStd::string> gemNames;
+        result = ExecuteWithLockErrorHandling([&]
+            {
+                const auto pyGemNames = m_cmake.attr("get_enabled_gems")(enabledGemsFilename);
+                for (auto gemName : pyGemNames)
+                {
+                    gemNames.push_back(Py_To_String(gemName));
+                }
+            });
+        if (!result.IsSuccess())
         {
-            return AZ::Success(AZStd::move(gems));
+            return AZ::Failure<AZStd::string>(result.GetError().c_str());
         }
+
+        return AZ::Success(AZStd::move(gemNames));
     }
 
     bool PythonBindings::AddProject(const QString& path)
@@ -513,10 +600,15 @@ namespace O3DE::ProjectManager
     {
         ProjectInfo createdProjectInfo;
         bool result = ExecuteWithLock([&] {
-
             pybind11::str projectPath = projectInfo.m_path.toStdString();
+            pybind11::str projectName = projectInfo.m_projectName.toStdString();
             pybind11::str templatePath = projectTemplatePath.toStdString();
-            auto createProjectResult = m_engineTemplate.attr("create_project")(projectPath, templatePath);
+
+            auto createProjectResult = m_engineTemplate.attr("create_project")(
+                projectPath,
+                projectName,
+                templatePath
+                );
             if (createProjectResult.cast<int>() == 0)
             {
                 createdProjectInfo = ProjectInfoFromPath(projectPath);
@@ -632,38 +724,36 @@ namespace O3DE::ProjectManager
         }
     }
 
-    bool PythonBindings::AddGemToProject(const QString& gemPath, const QString& projectPath)
+    AZ::Outcome<void, AZStd::string> PythonBindings::AddGemToProject(const QString& gemPath, const QString& projectPath)
     {
-        bool result = ExecuteWithLock([&] {
-            pybind11::str pyGemPath     = gemPath.toStdString();
-            pybind11::str pyProjectPath = projectPath.toStdString();
+        return ExecuteWithLockErrorHandling([&]
+            {
+                pybind11::str pyGemPath = gemPath.toStdString();
+                pybind11::str pyProjectPath = projectPath.toStdString();
 
-            m_enableGemProject.attr("enable_gem_in_project")(
-                pybind11::none(), // gem_name
-                pyGemPath,
-                pybind11::none(), // project_name
-                pyProjectPath
-            );
-        });
-
-        return result;
+                m_enableGemProject.attr("enable_gem_in_project")(
+                    pybind11::none(), // gem name not needed as path is provided
+                    pyGemPath,
+                    pybind11::none(), // project name not needed as path is provided
+                    pyProjectPath
+                );
+            });
     }
 
-    bool PythonBindings::RemoveGemFromProject(const QString& gemPath, const QString& projectPath)
+    AZ::Outcome<void, AZStd::string> PythonBindings::RemoveGemFromProject(const QString& gemPath, const QString& projectPath)
     {
-        bool result = ExecuteWithLock([&] {
-            pybind11::str pyGemPath     = gemPath.toStdString();
-            pybind11::str pyProjectPath = projectPath.toStdString();
+        return ExecuteWithLockErrorHandling([&]
+            {
+                pybind11::str pyGemPath = gemPath.toStdString();
+                pybind11::str pyProjectPath = projectPath.toStdString();
 
-            m_disableGemProject.attr("disable_gem_in_project")(
-                pybind11::none(), // gem_name
-                pyGemPath,
-                pybind11::none(), // project_name
-                pyProjectPath
-            );
-        });
-
-        return result;
+                m_disableGemProject.attr("disable_gem_in_project")(
+                    pybind11::none(), // gem name not needed as path is provided
+                    pyGemPath,
+                    pybind11::none(), // project name not needed as path is provided
+                    pyProjectPath
+                );
+            });
     }
 
     bool PythonBindings::UpdateProject([[maybe_unused]] const ProjectInfo& projectInfo)

Code/Tools/ProjectManager/Source/PythonBindings.h

@@ -39,8 +39,10 @@ namespace O3DE::ProjectManager
         bool SetEngineInfo(const EngineInfo& engineInfo) override;
 
         // Gem
-        AZ::Outcome<GemInfo> GetGem(const QString& path) override;
-        AZ::Outcome<QVector<GemInfo>> GetGems() override;
+        AZ::Outcome<GemInfo> GetGemInfo(const QString& path) override;
+        AZ::Outcome<QVector<GemInfo>, AZStd::string> GetEngineGemInfos() override;
+        AZ::Outcome<QVector<GemInfo>, AZStd::string> GetAllGemInfos(const QString& projectPath) override;
+        AZ::Outcome<QVector<AZStd::string>, AZStd::string> GetEnabledGemNames(const QString& projectPath) override;
 
         // Project
         AZ::Outcome<ProjectInfo> CreateProject(const QString& projectTemplatePath, const ProjectInfo& projectInfo) override;
@@ -49,8 +51,8 @@ namespace O3DE::ProjectManager
         bool AddProject(const QString& path) override;
         bool RemoveProject(const QString& path) override;
         bool UpdateProject(const ProjectInfo& projectInfo) override;
-        bool AddGemToProject(const QString& gemPath, const QString& projectPath) override;
-        bool RemoveGemFromProject(const QString& gemPath, const QString& projectPath) override;
+        AZ::Outcome<void, AZStd::string> AddGemToProject(const QString& gemPath, const QString& projectPath) override;
+        AZ::Outcome<void, AZStd::string> RemoveGemFromProject(const QString& gemPath, const QString& projectPath) override;
 
         // ProjectTemplate
         AZ::Outcome<QVector<ProjectTemplateInfo>> GetProjectTemplates() override;
@@ -58,16 +60,20 @@ namespace O3DE::ProjectManager
     private:
         AZ_DISABLE_COPY_MOVE(PythonBindings);
 
+        AZ::Outcome<void, AZStd::string> ExecuteWithLockErrorHandling(AZStd::function<void()> executionCallback);
         bool ExecuteWithLock(AZStd::function<void()> executionCallback);
         GemInfo GemInfoFromPath(pybind11::handle path);
         ProjectInfo ProjectInfoFromPath(pybind11::handle path);
         ProjectTemplateInfo ProjectTemplateInfoFromPath(pybind11::handle path);
+        bool RegisterThisEngine();
         bool StartPython();
         bool StopPython();
 
+
         AZ::IO::FixedMaxPath m_enginePath;
         pybind11::handle m_engineTemplate;
         AZStd::recursive_mutex m_lock;
+        pybind11::handle m_cmake;
         pybind11::handle m_register;
         pybind11::handle m_manifest;
         pybind11::handle m_enableGemProject;

Code/Tools/ProjectManager/Source/PythonBindingsInterface.h

@@ -57,13 +57,27 @@ namespace O3DE::ProjectManager
          * @param path the absolute path to the Gem 
          * @return an outcome with GemInfo on success 
          */
-        virtual AZ::Outcome<GemInfo> GetGem(const QString& path) = 0;
+        virtual AZ::Outcome<GemInfo> GetGemInfo(const QString& path) = 0;
 
         /**
-         * Get info about all known Gems
-         * @return an outcome with GemInfos on success 
+         * Get all available gem infos. This concatenates gems registered by the engine and the project.
+         * @param path The absolute path to the project.
+         * @return A list of gem infos.
          */
-        virtual AZ::Outcome<QVector<GemInfo>> GetGems() = 0;
+        virtual AZ::Outcome<QVector<GemInfo>, AZStd::string> GetAllGemInfos(const QString& projectPath) = 0;
+
+        /**
+        * Get engine gem infos.
+        * @return A list of all registered gem infos.
+        */
+        virtual AZ::Outcome<QVector<GemInfo>, AZStd::string> GetEngineGemInfos() = 0;
+
+        /**
+         * Get a list of all enabled gem names for a given project.
+         * @param[in] projectPath Absolute file path to the project.
+         * @return A list of gem names of all the enabled gems for a given project or a error message on failure.
+         */
+        virtual AZ::Outcome<QVector<AZStd::string>, AZStd::string> GetEnabledGemNames(const QString& projectPath) = 0;
 
 
         // Projects 
@@ -114,17 +128,17 @@ namespace O3DE::ProjectManager
          * Add a gem to a project
          * @param gemPath the absolute path to the gem 
          * @param projectPath the absolute path to the project
-         * @return true on success, false on failure
+         * @return An outcome with the success flag as well as an error message in case of a failure.
          */
-        virtual bool AddGemToProject(const QString& gemPath, const QString& projectPath) = 0;
+        virtual AZ::Outcome<void, AZStd::string> AddGemToProject(const QString& gemPath, const QString& projectPath) = 0;
 
         /**
          * Remove gem to a project
          * @param gemPath the absolute path to the gem 
          * @param projectPath the absolute path to the project
-         * @return true on success, false on failure
+         * @return An outcome with the success flag as well as an error message in case of a failure.
          */
-        virtual bool RemoveGemFromProject(const QString& gemPath, const QString& projectPath) = 0;
+        virtual AZ::Outcome<void, AZStd::string> RemoveGemFromProject(const QString& gemPath, const QString& projectPath) = 0;
 
 
         // Project Templates

Code/Tools/ProjectManager/Source/ScreenDefs.h

@@ -11,9 +11,13 @@
  */
 #pragma once
 
+#include <AzCore/std/containers/unordered_map.h>
+#include <AzCore/std/string/string.h>
+#include <QHash>
+
 namespace O3DE::ProjectManager
 {
-    enum ProjectManagerScreen
+    enum class ProjectManagerScreen
     {
         Invalid = -1,
         Empty,
@@ -22,7 +26,24 @@ namespace O3DE::ProjectManager
         GemCatalog,
         Projects,
         UpdateProject,
-        ProjectSettings,
+        UpdateProjectSettings,
         EngineSettings
     };
+
+    static QHash<QString, ProjectManagerScreen> s_ProjectManagerStringNames = {
+        { "Empty", ProjectManagerScreen::Empty},
+        { "CreateProject", ProjectManagerScreen::CreateProject},
+        { "NewProjectSettings", ProjectManagerScreen::NewProjectSettings},
+        { "GemCatalog", ProjectManagerScreen::GemCatalog},
+        { "Projects", ProjectManagerScreen::Projects},
+        { "UpdateProject", ProjectManagerScreen::UpdateProject},
+        { "UpdateProjectSettings", ProjectManagerScreen::UpdateProjectSettings},
+        { "EngineSettings", ProjectManagerScreen::EngineSettings}
+    };
+
+    // need to define qHash for ProjectManagerScreen when using scoped enums
+    inline uint qHash(ProjectManagerScreen key, uint seed)
+    {
+        return ::qHash(static_cast<uint>(key), seed);
+    }
 } // namespace O3DE::ProjectManager

Code/Tools/ProjectManager/Source/ScreenFactory.cpp

@@ -16,7 +16,7 @@
 #include <NewProjectSettingsScreen.h>
 #include <GemCatalog/GemCatalogScreen.h>
 #include <ProjectsScreen.h>
-#include <ProjectSettingsScreen.h>
+#include <UpdateProjectSettingsScreen.h>
 #include <EngineSettingsScreen.h>
 
 namespace O3DE::ProjectManager
@@ -42,8 +42,8 @@ namespace O3DE::ProjectManager
         case (ProjectManagerScreen::UpdateProject):
             newScreen = new UpdateProjectCtrl(parent);
             break;
-        case (ProjectManagerScreen::ProjectSettings):
-            newScreen = new ProjectSettingsScreen(parent);
+        case (ProjectManagerScreen::UpdateProjectSettings):
+            newScreen = new UpdateProjectSettingsScreen(parent);
             break;
         case (ProjectManagerScreen::EngineSettings):
             newScreen = new EngineSettingsScreen(parent);

Code/Tools/ProjectManager/Source/ScreensCtrl.cpp

@@ -13,6 +13,7 @@
 #include <ScreensCtrl.h>
 #include <ScreenFactory.h>
 #include <ScreenWidget.h>
+#include <UpdateProjectCtrl.h>
 
 #include <QTabWidget>
 #include <QVBoxLayout>
@@ -136,6 +137,7 @@ namespace O3DE::ProjectManager
         {
             shouldRestoreCurrentScreen = true;
         }
+        int tabIndex = GetScreenTabIndex(screen);
 
         // Delete old screen if it exists to start fresh
         DeleteScreen(screen);
@@ -144,11 +146,19 @@ namespace O3DE::ProjectManager
         ScreenWidget* newScreen = BuildScreen(this, screen);
         if (newScreen->IsTab())
         {
-            m_tabWidget->addTab(newScreen, newScreen->GetTabText());
+            if (tabIndex > -1)
+            {
+                m_tabWidget->insertTab(tabIndex, newScreen, newScreen->GetTabText());
+            }
+            else
+            {
+                m_tabWidget->addTab(newScreen, newScreen->GetTabText());
+            }
             if (shouldRestoreCurrentScreen)
             {
                 m_tabWidget->setCurrentWidget(newScreen);
                 m_screenStack->setCurrentWidget(m_tabWidget);
+                newScreen->NotifyCurrentScreen();
             }
         }
         else
@@ -157,6 +167,7 @@ namespace O3DE::ProjectManager
             if (shouldRestoreCurrentScreen)
             {
                 m_screenStack->setCurrentWidget(newScreen);
+                newScreen->NotifyCurrentScreen();
             }
         }
 
@@ -219,4 +230,19 @@ namespace O3DE::ProjectManager
             screen->NotifyCurrentScreen();
         }
     }
+
+    int ScreensCtrl::GetScreenTabIndex(ProjectManagerScreen screen)
+    {
+        const auto iter = m_screenMap.find(screen);
+        if (iter != m_screenMap.end())
+        {
+            ScreenWidget* screenWidget = iter.value();
+            if (screenWidget->IsTab())
+            {
+                return m_tabWidget->indexOf(screenWidget);
+            }
+        }
+        
+        return -1;
+    }
 } // namespace O3DE::ProjectManager

Code/Tools/ProjectManager/Source/ScreensCtrl.h

@@ -51,6 +51,8 @@ namespace O3DE::ProjectManager
         void TabChanged(int index);
 
     private:
+        int GetScreenTabIndex(ProjectManagerScreen screen);
+
         QStackedWidget* m_screenStack;
         QHash<ProjectManagerScreen, ScreenWidget*> m_screenMap;
         QStack<ProjectManagerScreen> m_screenVisitOrder;

Code/Tools/ProjectManager/Source/UpdateProjectCtrl.cpp

@@ -10,15 +10,20 @@
  *
  */
 
-#include <UpdateProjectCtrl.h>
-#include <ScreensCtrl.h>
+#include <GemCatalog/GemCatalogScreen.h>
 #include <PythonBindingsInterface.h>
-#include <ProjectSettingsScreen.h>
+#include <ScreenHeaderWidget.h>
+#include <ScreensCtrl.h>
+#include <UpdateProjectCtrl.h>
+#include <UpdateProjectSettingsScreen.h>
+#include <ProjectUtils.h>
 
 #include <QDialogButtonBox>
-#include <QVBoxLayout>
-#include <QPushButton>
 #include <QMessageBox>
+#include <QPushButton>
+#include <QStackedWidget>
+#include <QTabWidget>
+#include <QVBoxLayout>
 
 namespace O3DE::ProjectManager
 {
@@ -26,31 +31,57 @@ namespace O3DE::ProjectManager
         : ScreenWidget(parent)
     {
         QVBoxLayout* vLayout = new QVBoxLayout();
-        setLayout(vLayout);
+        vLayout->setContentsMargins(0, 0, 0, 0);
 
-        m_screensCtrl = new ScreensCtrl();
-        vLayout->addWidget(m_screensCtrl);
+        m_header = new ScreenHeader(this);
+        m_header->setTitle(tr(""));
+        m_header->setSubTitle(tr("Edit Project Settings:"));
+        connect(m_header->backButton(), &QPushButton::clicked, this, &UpdateProjectCtrl::HandleBackButton);
+        vLayout->addWidget(m_header);
+
+        m_updateSettingsScreen = new UpdateProjectSettingsScreen();
+        m_gemCatalogScreen = new GemCatalogScreen();
+
+        m_stack = new QStackedWidget(this);
+        m_stack->setObjectName("body");
+        m_stack->setSizePolicy(QSizePolicy(QSizePolicy::Preferred, QSizePolicy::Expanding));
+        vLayout->addWidget(m_stack);
+
+        QFrame* topBarFrameWidget = new QFrame(this);
+        topBarFrameWidget->setObjectName("projectSettingsTopFrame");
+        QHBoxLayout* topBarHLayout = new QHBoxLayout();
+        topBarHLayout->setContentsMargins(0, 0, 0, 0);
+        topBarFrameWidget->setLayout(topBarHLayout);
+
+        QTabWidget* tabWidget = new QTabWidget();
+        tabWidget->setObjectName("projectSettingsTab");
+        tabWidget->tabBar()->setObjectName("projectSettingsTabBar");
+        tabWidget->addTab(m_updateSettingsScreen, tr("General"));
+
+        QPushButton* gemsButton = new QPushButton(tr("Add More Gems"), this);
+        topBarHLayout->addWidget(gemsButton);
+        tabWidget->setCornerWidget(gemsButton);
+
+        topBarHLayout->addWidget(tabWidget);
+
+        m_stack->addWidget(topBarFrameWidget);
+        m_stack->addWidget(m_gemCatalogScreen);
 
         QDialogButtonBox* backNextButtons = new QDialogButtonBox();
+        backNextButtons->setObjectName("footer");
         vLayout->addWidget(backNextButtons);
 
         m_backButton = backNextButtons->addButton(tr("Back"), QDialogButtonBox::RejectRole);
+        m_backButton->setProperty("secondary", true);
         m_nextButton = backNextButtons->addButton(tr("Next"), QDialogButtonBox::ApplyRole);
 
-        connect(m_backButton, &QPushButton::pressed, this, &UpdateProjectCtrl::HandleBackButton);
-        connect(m_nextButton, &QPushButton::pressed, this, &UpdateProjectCtrl::HandleNextButton);
+        connect(gemsButton, &QPushButton::clicked, this, &UpdateProjectCtrl::HandleGemsButton);
+        connect(m_backButton, &QPushButton::clicked, this, &UpdateProjectCtrl::HandleBackButton);
+        connect(m_nextButton, &QPushButton::clicked, this, &UpdateProjectCtrl::HandleNextButton);
         connect(reinterpret_cast<ScreensCtrl*>(parent), &ScreensCtrl::NotifyCurrentProject, this, &UpdateProjectCtrl::UpdateCurrentProject);
 
-        m_screensOrder =
-        {
-            ProjectManagerScreen::ProjectSettings,
-            ProjectManagerScreen::GemCatalog
-        };
-        m_screensCtrl->BuildScreens(m_screensOrder);
-        m_screensCtrl->ForceChangeToScreen(ProjectManagerScreen::ProjectSettings, false);
-
-        UpdateNextButtonText();
-
+        Update();
+        setLayout(vLayout);
     }
 
     ProjectManagerScreen UpdateProjectCtrl::GetScreenEnum()
@@ -58,63 +89,80 @@ namespace O3DE::ProjectManager
         return ProjectManagerScreen::UpdateProject;
     }
 
+    void UpdateProjectCtrl::NotifyCurrentScreen()
+    {
+        m_stack->setCurrentIndex(ScreenOrder::Settings);
+        Update();
+    }
+
+    void UpdateProjectCtrl::HandleGemsButton()
+    {
+        // The next page is the gem catalog. Gather the available gems that will be shown in the gem catalog.
+        m_gemCatalogScreen->ReinitForProject(m_projectInfo.m_path, /*isNewProject=*/false);
+
+        m_stack->setCurrentWidget(m_gemCatalogScreen);
+        Update();
+    }
+
     void UpdateProjectCtrl::HandleBackButton()
     {
-        if (!m_screensCtrl->GotoPreviousScreen())
+        if (m_stack->currentIndex() > 0)
         {
-            emit GotoPreviousScreenRequest();
+            m_stack->setCurrentIndex(m_stack->currentIndex() - 1);
+            Update();
         }
         else
         {
-            UpdateNextButtonText();
+            emit GotoPreviousScreenRequest();
         }
     }
+
     void UpdateProjectCtrl::HandleNextButton()
     {
-        ScreenWidget* currentScreen = m_screensCtrl->GetCurrentScreen();
-        ProjectManagerScreen screenEnum = currentScreen->GetScreenEnum();
-        auto screenOrderIter = m_screensOrder.begin();
-        for (; screenOrderIter != m_screensOrder.end(); ++screenOrderIter)
+        if (m_stack->currentIndex() == ScreenOrder::Settings)
         {
-            if (*screenOrderIter == screenEnum)
+            if (m_updateSettingsScreen)
             {
-                ++screenOrderIter;
-                break;
-            }
-        }
-
-        if (screenEnum == ProjectManagerScreen::ProjectSettings)
-        {
-            auto projectScreen = reinterpret_cast<ProjectSettingsScreen*>(currentScreen);
-            if (projectScreen)
-            {
-                if (!projectScreen->Validate())
+                if (!m_updateSettingsScreen->Validate())
                 {
                     QMessageBox::critical(this, tr("Invalid project settings"), tr("Invalid project settings"));
                     return;
                 }
 
-                m_projectInfo = projectScreen->GetProjectInfo();
+                ProjectInfo newProjectSettings = m_updateSettingsScreen->GetProjectInfo();
+
+                // Update project if settings changed
+                if (m_projectInfo != newProjectSettings)
+                {
+                    bool result = PythonBindingsInterface::Get()->UpdateProject(newProjectSettings);
+                    if (!result)
+                    {
+                        QMessageBox::critical(this, tr("Project update failed"), tr("Failed to update project."));
+                        return;
+                    }
+                }
+
+                // Check if project path has changed and move it
+                if (newProjectSettings.m_path != m_projectInfo.m_path)
+                {
+                    if (!ProjectUtils::MoveProject(m_projectInfo.m_path, newProjectSettings.m_path))
+                    {
+                        QMessageBox::critical(this, tr("Project move failed"), tr("Failed to move project."));
+                        return;
+                    }
+                }
+
+                m_projectInfo = newProjectSettings;
             }
         }
 
-        if (screenOrderIter != m_screensOrder.end())
+        if (m_stack->currentIndex() == ScreenOrder::Gems && m_gemCatalogScreen)
         {
-            m_screensCtrl->ChangeToScreen(*screenOrderIter);
-            UpdateNextButtonText();
-        }
-        else
-        {
-            auto result = PythonBindingsInterface::Get()->UpdateProject(m_projectInfo);
-            if (result)
-            {
-                emit ChangeScreenRequest(ProjectManagerScreen::Projects);
-            }
-            else
-            {
-                QMessageBox::critical(this, tr("Project update failed"), tr("Failed to update project."));
-            }
+            // Enable or disable the gems that got adjusted in the gem catalog and apply them to the given project.
+            m_gemCatalogScreen->EnableDisableGemsForProject(m_projectInfo.m_path);
         }
+
+        emit ChangeScreenRequest(ProjectManagerScreen::Projects);
     }
 
     void UpdateProjectCtrl::UpdateCurrentProject(const QString& projectPath)
@@ -124,16 +172,28 @@ namespace O3DE::ProjectManager
         {
             m_projectInfo = projectResult.GetValue();
         }
+
+        Update();
+        UpdateSettingsScreen();
     }
 
-    void UpdateProjectCtrl::UpdateNextButtonText()
+    void UpdateProjectCtrl::Update()
     {
-        QString nextButtonText = tr("Continue");
-        if (m_screensCtrl->GetCurrentScreen()->GetScreenEnum() == ProjectManagerScreen::GemCatalog)
+        if (m_stack->currentIndex() == ScreenOrder::Gems)
         {
-            nextButtonText = tr("Update Project");
+            m_header->setSubTitle(QString(tr("Add More Gems to \"%1\"")).arg(m_projectInfo.m_projectName));
+            m_nextButton->setText(tr("Confirm"));
         }
-        m_nextButton->setText(nextButtonText);
+        else
+        {
+            m_header->setSubTitle(QString(tr("Edit Project Settings: \"%1\"")).arg(m_projectInfo.m_projectName));
+            m_nextButton->setText(tr("Save"));
+        }
+    }
+
+    void UpdateProjectCtrl::UpdateSettingsScreen()
+    {
+        m_updateSettingsScreen->SetProjectInfo(m_projectInfo);
     }
 
 } // namespace O3DE::ProjectManager

Code/Tools/ProjectManager/Source/UpdateProjectCtrl.h

@@ -12,40 +12,57 @@
 #pragma once
 
 #if !defined(Q_MOC_RUN)
-#include "ProjectInfo.h"
+#include <ProjectInfo.h>
 #include <ScreenWidget.h>
-#include <ScreensCtrl.h>
-#include <QPushButton>
 #endif
 
+QT_FORWARD_DECLARE_CLASS(QStackedWidget)
+QT_FORWARD_DECLARE_CLASS(QTabWidget)
+QT_FORWARD_DECLARE_CLASS(QPushButton)
+QT_FORWARD_DECLARE_CLASS(QFrame)
 
 namespace O3DE::ProjectManager
 {
-    class UpdateProjectCtrl
-        : public ScreenWidget
+    QT_FORWARD_DECLARE_CLASS(ScreenHeader)
+    QT_FORWARD_DECLARE_CLASS(UpdateProjectSettingsScreen)
+    QT_FORWARD_DECLARE_CLASS(GemCatalogScreen)
+
+    class UpdateProjectCtrl : public ScreenWidget
     {
     public:
         explicit UpdateProjectCtrl(QWidget* parent = nullptr);
         ~UpdateProjectCtrl() = default;
         ProjectManagerScreen GetScreenEnum() override;
 
+    protected:
+        void NotifyCurrentScreen() override;
 
     protected slots:
         void HandleBackButton();
         void HandleNextButton();
+        void HandleGemsButton();
         void UpdateCurrentProject(const QString& projectPath);
 
     private:
-        void UpdateNextButtonText();
+        void Update();
+        void UpdateSettingsScreen();
 
-        ScreensCtrl* m_screensCtrl;
-        QPushButton* m_backButton;
-        QPushButton* m_nextButton;
+        enum ScreenOrder
+        {
+            Settings,
+            Gems
+        };
+
+        ScreenHeader* m_header = nullptr;
+        QStackedWidget* m_stack = nullptr;
+        UpdateProjectSettingsScreen* m_updateSettingsScreen = nullptr;
+        GemCatalogScreen* m_gemCatalogScreen = nullptr;
+
+        QPushButton* m_backButton = nullptr;
+        QPushButton* m_nextButton = nullptr;
         QVector<ProjectManagerScreen> m_screensOrder;
 
         ProjectInfo m_projectInfo;
-
-        ProjectManagerScreen m_screenEnum;
     };
 
 } // namespace O3DE::ProjectManager

Code/Tools/ProjectManager/Source/UpdateProjectSettingsScreen.cpp

@@ -0,0 +1,51 @@
+/*
+ * 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 <UpdateProjectSettingsScreen.h>
+#include <FormBrowseEditWidget.h>
+#include <FormLineEditWidget.h>
+
+#include <QLineEdit>
+#include <QDir>
+
+namespace O3DE::ProjectManager
+{
+    UpdateProjectSettingsScreen::UpdateProjectSettingsScreen(QWidget* parent)
+        : ProjectSettingsScreen(parent)
+    {
+    }
+
+    ProjectManagerScreen UpdateProjectSettingsScreen::GetScreenEnum()
+    {
+        return ProjectManagerScreen::UpdateProjectSettings;
+    }
+
+    void UpdateProjectSettingsScreen::SetProjectInfo(const ProjectInfo& projectInfo)
+    {
+        m_projectName->lineEdit()->setText(projectInfo.m_projectName);
+        m_projectPath->lineEdit()->setText(projectInfo.m_path);
+    }
+
+    bool UpdateProjectSettingsScreen::ValidateProjectPath()
+    {
+        bool projectPathIsValid = true;
+        if (m_projectPath->lineEdit()->text().isEmpty())
+        {
+            projectPathIsValid = false;
+            m_projectPath->setErrorLabelText(tr("Please provide a valid location."));
+        }
+
+        m_projectPath->setErrorLabelVisible(!projectPathIsValid);
+        return projectPathIsValid;
+    }
+
+} // namespace O3DE::ProjectManager

Code/Tools/ProjectManager/Source/UpdateProjectSettingsScreen.h

@@ -0,0 +1,34 @@
+/*
+ * All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
+ * its licensors.
+ *
+ * For complete copyright and license terms please see the LICENSE at the root of this
+ * distribution (the "License"). All use of this software is governed by the License,
+ * or, if provided, by the license below or the license accompanying this file. Do not
+ * remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *
+ */
+#pragma once
+
+#if !defined(Q_MOC_RUN)
+#include <ProjectSettingsScreen.h>
+#endif
+
+namespace O3DE::ProjectManager
+{
+    class UpdateProjectSettingsScreen
+        : public ProjectSettingsScreen
+    {
+    public:
+        explicit UpdateProjectSettingsScreen(QWidget* parent = nullptr);
+        ~UpdateProjectSettingsScreen() = default;
+        ProjectManagerScreen GetScreenEnum() override;
+
+        void SetProjectInfo(const ProjectInfo& projectInfo);
+
+    protected:
+        bool ValidateProjectPath() override;
+    };
+
+} // namespace O3DE::ProjectManager

Code/Tools/ProjectManager/Source/main.cpp

@@ -15,13 +15,17 @@
 #include <AzCore/Component/ComponentApplication.h>
 #include <AzCore/Settings/SettingsRegistryMergeUtils.h>
 #include <AzCore/IO/Path/Path.h>
+#include <AzFramework/CommandLine/CommandLine.h>
 
 #include <ProjectManagerWindow.h>
+#include <ProjectUtils.h>
 
 #include <QApplication>
 #include <QCoreApplication>
 #include <QGuiApplication>
 
+using namespace O3DE::ProjectManager;
+
 int main(int argc, char* argv[])
 {
     QApplication::setOrganizationName("O3DE");
@@ -51,7 +55,29 @@ int main(int argc, char* argv[])
         AzQtComponents::StyleManager styleManager(&app);
         styleManager.initialize(&app, engineRootPath);
 
-        O3DE::ProjectManager::ProjectManagerWindow window(nullptr, engineRootPath);
+        // Get the initial start screen if one is provided via command line
+        constexpr char optionPrefix[] = "--";
+        AZ::CommandLine commandLine(optionPrefix);
+        commandLine.Parse(argc, argv);
+
+        ProjectManagerScreen startScreen = ProjectManagerScreen::Projects;
+        if(commandLine.HasSwitch("screen"))
+        {
+            QString screenOption = commandLine.GetSwitchValue("screen", 0).c_str();
+            ProjectManagerScreen screen = ProjectUtils::GetProjectManagerScreen(screenOption);
+            if (screen != ProjectManagerScreen::Invalid)
+            {
+                startScreen = screen;
+            }
+        }
+
+        AZ::IO::FixedMaxPath projectPath;
+        if (commandLine.HasSwitch("project-path"))
+        {
+            projectPath = commandLine.GetSwitchValue("project-path", 0).c_str();
+        }
+
+        ProjectManagerWindow window(nullptr, engineRootPath, projectPath, startScreen);
         window.show();
 
         // somethings is preventing us from moving the window to the center of the

Code/Tools/ProjectManager/project_manager_files.cmake

@@ -38,6 +38,8 @@ set(FILES
     Source/ProjectInfo.cpp
     Source/ProjectUtils.h
     Source/ProjectUtils.cpp
+    Source/UpdateProjectSettingsScreen.h
+    Source/UpdateProjectSettingsScreen.cpp
     Source/NewProjectSettingsScreen.h
     Source/NewProjectSettingsScreen.cpp
     Source/CreateProjectCtrl.h
@@ -48,7 +50,6 @@ set(FILES
     Source/ProjectsScreen.cpp
     Source/ProjectSettingsScreen.h
     Source/ProjectSettingsScreen.cpp
-    Source/ProjectSettingsScreen.ui
     Source/EngineSettingsScreen.h
     Source/EngineSettingsScreen.cpp
     Source/ProjectButtonWidget.h

Code/Tools/SceneAPI/SDKWrapper/AssImpSceneWrapper.cpp

@@ -42,7 +42,7 @@ namespace AZ
         }
 
 #if AZ_TRAIT_COMPILER_SUPPORT_CSIGNAL
-        void signal_handler(int signal) 
+        void signal_handler([[maybe_unused]] int signal) 
         {
             AZ_TracePrintf(
                 SceneAPI::Utilities::ErrorWindow,

Gems/AWSClientAuth/Code/CMakeLists.txt

@@ -56,9 +56,13 @@ ly_add_target(
         Gem::HttpRequestor
 )
 
-# servers and clients use the above module.
+# Load the "Gem::AWSClientAuth" module in all types of applications.
 ly_create_alias(NAME AWSClientAuth.Servers NAMESPACE Gem TARGETS Gem::AWSClientAuth)
 ly_create_alias(NAME AWSClientAuth.Clients NAMESPACE Gem TARGETS Gem::AWSClientAuth)
+if (PAL_TRAIT_BUILD_HOST_TOOLS)
+    ly_create_alias(NAME AWSClientAuth.Tools NAMESPACE Gem TARGETS Gem::AWSClientAuth)
+    ly_create_alias(NAME AWSClientAuth.Builders NAMESPACE Gem TARGETS Gem::AWSClientAuth)
+endif()
 
 ################################################################################
 # Tests

Gems/AWSCore/Code/CMakeLists.txt

@@ -79,14 +79,12 @@ if (PAL_TRAIT_BUILD_HOST_TOOLS)
         INCLUDE_DIRECTORIES
             PRIVATE
                 Include/Private
-        COMPILE_DEFINITIONS
-            PRIVATE
-                AWSCORE_EDITOR
         BUILD_DEPENDENCIES
             PRIVATE
                 AZ::AzCore
-                Gem::AWSCore.Static
                 Gem::AWSCore.Editor.Static
+        RUNTIME_DEPENDENCIES
+            Gem::AWSCore
     )
 
     ly_add_target(

Gems/AWSCore/Code/Include/Private/AWSCoreEditorModule.h

@@ -11,15 +11,15 @@
 
 #pragma once
 
-#include <AWSCoreModule.h>
+#include <AzCore/Module/Module.h>
 
 namespace AWSCore
 {
     class AWSCoreEditorModule
-        : public AWSCoreModule
+        :public AZ::Module
     {
     public:
-        AZ_RTTI(AWSCoreEditorModule, "{C1C9B898-848B-4C2F-A7AA-69642D12BCB5}", AWSCoreModule);
+        AZ_RTTI(AWSCoreEditorModule, "{C1C9B898-848B-4C2F-A7AA-69642D12BCB5}", AZ::Module);
         AZ_CLASS_ALLOCATOR(AWSCoreEditorModule, AZ::SystemAllocator, 0);
 
         AWSCoreEditorModule();

Gems/AWSCore/Code/Source/AWSCoreEditorModule.cpp

@@ -15,7 +15,6 @@
 namespace AWSCore
 {
     AWSCoreEditorModule::AWSCoreEditorModule()
-        : AWSCoreModule()
     {
         // Push results of [MyComponent]::CreateDescriptor() into m_descriptors here.
         m_descriptors.insert(m_descriptors.end(), {
@@ -28,10 +27,9 @@ namespace AWSCore
     */
     AZ::ComponentTypeList AWSCoreEditorModule::GetRequiredSystemComponents() const
     {
-        AZ::ComponentTypeList requiredComponents = AWSCoreModule::GetRequiredSystemComponents();
-        requiredComponents.push_back(azrtti_typeid<AWSCoreEditorSystemComponent>());
-
-        return requiredComponents;
+        return AZ::ComponentTypeList{
+            azrtti_typeid<AWSCoreEditorSystemComponent>()
+        };
     }
 
 }

Gems/AWSCore/Code/Source/AWSCoreModule.cpp

@@ -40,9 +40,7 @@ namespace AWSCore
 
 }
 
-#if !defined(AWSCORE_EDITOR)
 // 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(Gem_AWSCore, AWSCore::AWSCoreModule)
-#endif

Gems/AWSCore/Code/awscore_editor_shared_files.cmake

@@ -11,7 +11,5 @@
 
 set(FILES
     Include/Private/AWSCoreEditorModule.h
-    Include/Private/AWSCoreModule.h
     Source/AWSCoreEditorModule.cpp
-    Source/AWSCoreModule.cpp
 )

Gems/AWSMetrics/Code/CMakeLists.txt

@@ -46,9 +46,13 @@ ly_add_target(
         Gem::AWSCore
 )
 
-# Servers and Clients use the above metrics module
+# Load the "Gem::AWSMetrics" module in all types of applications.
 ly_create_alias(NAME AWSMetrics.Servers NAMESPACE Gem TARGETS Gem::AWSMetrics)
 ly_create_alias(NAME AWSMetrics.Clients NAMESPACE Gem TARGETS Gem::AWSMetrics)
+if (PAL_TRAIT_BUILD_HOST_TOOLS)
+    ly_create_alias(NAME AWSMetrics.Tools NAMESPACE Gem TARGETS Gem::AWSMetrics)
+    ly_create_alias(NAME AWSMetrics.Builders NAMESPACE Gem TARGETS Gem::AWSMetrics)
+endif()
 
 ################################################################################
 # Tests