From dae82b38586bcb07eff683c432c662d03bfe902a Mon Sep 17 00:00:00 2001 From: "T.J. McGrath-Daly" Date: Fri, 16 Jul 2021 16:15:23 +0800 Subject: [PATCH 1/7] Fix: only files can be selected Signed-off-by: T.J. McGrath-Daly --- .../AssetImporter/AssetImporterManager/AssetImporterManager.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/Code/Editor/AssetImporter/AssetImporterManager/AssetImporterManager.cpp b/Code/Editor/AssetImporter/AssetImporterManager/AssetImporterManager.cpp index baa287e47f..73c3d6f9ed 100644 --- a/Code/Editor/AssetImporter/AssetImporterManager/AssetImporterManager.cpp +++ b/Code/Editor/AssetImporter/AssetImporterManager/AssetImporterManager.cpp @@ -191,6 +191,7 @@ void AssetImporterManager::OnBrowseDestinationFilePath(QLineEdit* destinationLin fileDialog.setViewMode(QFileDialog::List); fileDialog.setWindowModality(Qt::WindowModality::ApplicationModal); fileDialog.setWindowTitle(tr("Select import destination")); + fileDialog.setFileMode(QFileDialog::Directory); QSettings settings; QString currentDestination = settings.value(AssetImporterManagerPrivate::g_selectDestinationFilesPath).toString(); From 3d17f9648f1b9f0431cf390f003cc64cace2003a Mon Sep 17 00:00:00 2001 From: jromnoa <80134229+jromnoa@users.noreply.github.com> Date: Fri, 14 Jan 2022 14:08:29 -0800 Subject: [PATCH 2/7] removes the old log lines test for the Light component, test will be re-added as a return codes test in the p1 test tasks Signed-off-by: jromnoa <80134229+jromnoa@users.noreply.github.com> --- .../Gem/PythonTests/Atom/TestSuite_Sandbox.py | 69 +----- ...dra_AtomEditorComponents_LightComponent.py | 213 ------------------ 2 files changed, 1 insertion(+), 281 deletions(-) delete mode 100644 AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_LightComponent.py diff --git a/AutomatedTesting/Gem/PythonTests/Atom/TestSuite_Sandbox.py b/AutomatedTesting/Gem/PythonTests/Atom/TestSuite_Sandbox.py index c9182070f6..bd0477a1db 100644 --- a/AutomatedTesting/Gem/PythonTests/Atom/TestSuite_Sandbox.py +++ b/AutomatedTesting/Gem/PythonTests/Atom/TestSuite_Sandbox.py @@ -9,87 +9,20 @@ import os import pytest -import ly_test_tools.environment.file_system as file_system -import editor_python_test_tools.hydra_test_utils as hydra from ly_test_tools.o3de.editor_test import EditorSharedTest, EditorTestSuite -from Atom.atom_utils.atom_constants import LIGHT_TYPES logger = logging.getLogger(__name__) TEST_DIRECTORY = os.path.join(os.path.dirname(__file__), "tests") -@pytest.mark.parametrize("project", ["AutomatedTesting"]) -@pytest.mark.parametrize("launcher_platform", ['windows_editor']) -@pytest.mark.parametrize("level", ["auto_test"]) -class TestAtomEditorComponentsMain(object): - """Holds tests for Atom components.""" - - @pytest.mark.test_case_id("C34525095") - def test_AtomEditorComponents_LightComponent( - self, request, editor, workspace, project, launcher_platform, level): - """ - Please review the hydra script run by this test for more specific test info. - Tests that the Light component has the expected property options available to it. - """ - cfg_args = [level] - - expected_lines = [ - "light_entity Entity successfully created", - "Entity has a Light component", - "light_entity_test: Component added to the entity: True", - f"light_entity_test: Property value is {LIGHT_TYPES['sphere']} which matches {LIGHT_TYPES['sphere']}", - "Controller|Configuration|Shadows|Enable shadow set to True", - "light_entity Controller|Configuration|Shadows|Shadowmap size: SUCCESS", - "Controller|Configuration|Shadows|Shadow filter method set to 1", # PCF - "Controller|Configuration|Shadows|Filtering sample count set to 4", - "Controller|Configuration|Shadows|Filtering sample count set to 64", - "Controller|Configuration|Shadows|Shadow filter method set to 2", # ESM - "Controller|Configuration|Shadows|ESM exponent set to 50.0", - "Controller|Configuration|Shadows|ESM exponent set to 5000.0", - "Controller|Configuration|Shadows|Shadow filter method set to 3", # ESM+PCF - f"light_entity_test: Property value is {LIGHT_TYPES['spot_disk']} which matches {LIGHT_TYPES['spot_disk']}", - f"light_entity_test: Property value is {LIGHT_TYPES['capsule']} which matches {LIGHT_TYPES['capsule']}", - f"light_entity_test: Property value is {LIGHT_TYPES['quad']} which matches {LIGHT_TYPES['quad']}", - "light_entity Controller|Configuration|Fast approximation: SUCCESS", - "light_entity Controller|Configuration|Both directions: SUCCESS", - f"light_entity_test: Property value is {LIGHT_TYPES['polygon']} which matches {LIGHT_TYPES['polygon']}", - f"light_entity_test: Property value is {LIGHT_TYPES['simple_point']} " - f"which matches {LIGHT_TYPES['simple_point']}", - "Controller|Configuration|Attenuation radius|Mode set to 0", - "Controller|Configuration|Attenuation radius|Radius set to 100.0", - f"light_entity_test: Property value is {LIGHT_TYPES['simple_spot']} " - f"which matches {LIGHT_TYPES['simple_spot']}", - "Controller|Configuration|Shutters|Outer angle set to 45.0", - "Controller|Configuration|Shutters|Outer angle set to 90.0", - "light_entity_test: Component added to the entity: True", - "Light component test (non-GPU) completed.", - ] - - unexpected_lines = ["Traceback (most recent call last):"] - - hydra.launch_and_validate_results( - request, - TEST_DIRECTORY, - editor, - "hydra_AtomEditorComponents_LightComponent.py", - timeout=120, - expected_lines=expected_lines, - unexpected_lines=unexpected_lines, - halt_on_unexpected=True, - null_renderer=True, - cfg_args=cfg_args, - enable_prefab_system=False, - ) - - @pytest.mark.parametrize("project", ["AutomatedTesting"]) @pytest.mark.parametrize("launcher_platform", ['windows_editor']) class TestAutomation(EditorTestSuite): enable_prefab_system = False - #this test is intermittently timing out without ever having executed. sandboxing while we investigate cause. + # this test is intermittently timing out without ever having executed. sandboxing while we investigate cause. @pytest.mark.test_case_id("C36525660") class AtomEditorComponents_DisplayMapperAdded(EditorSharedTest): from Atom.tests import hydra_AtomEditorComponents_DisplayMapperAdded as test_module diff --git a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_LightComponent.py b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_LightComponent.py deleted file mode 100644 index 7ecdc6859b..0000000000 --- a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_LightComponent.py +++ /dev/null @@ -1,213 +0,0 @@ -""" -Copyright (c) Contributors to the Open 3D Engine Project. -For complete copyright and license terms please see the LICENSE at the root of this distribution. - -SPDX-License-Identifier: Apache-2.0 OR MIT -""" - -import os -import sys - -import azlmbr.bus as bus -import azlmbr.editor as editor -import azlmbr.math as math -import azlmbr.paths -import azlmbr.legacy.general as general - -sys.path.append(os.path.join(azlmbr.paths.projectroot, "Gem", "PythonTests")) - -import editor_python_test_tools.hydra_editor_utils as hydra -from Atom.atom_utils.atom_constants import LIGHT_TYPES - -LIGHT_TYPE_PROPERTY = 'Controller|Configuration|Light type' -SPHERE_AND_SPOT_DISK_LIGHT_PROPERTIES = [ - ("Controller|Configuration|Shadows|Enable shadow", True), - ("Controller|Configuration|Shadows|Shadowmap size", 0), # 256 - ("Controller|Configuration|Shadows|Shadowmap size", 1), # 512 - ("Controller|Configuration|Shadows|Shadowmap size", 2), # 1024 - ("Controller|Configuration|Shadows|Shadowmap size", 3), # 2048 - ("Controller|Configuration|Shadows|Shadow filter method", 1), # PCF - ("Controller|Configuration|Shadows|Filtering sample count", 4.0), - ("Controller|Configuration|Shadows|Filtering sample count", 64.0), - ("Controller|Configuration|Shadows|Shadow filter method", 2), # ECM - ("Controller|Configuration|Shadows|ESM exponent", 50), - ("Controller|Configuration|Shadows|ESM exponent", 5000), - ("Controller|Configuration|Shadows|Shadow filter method", 3), # ESM+PCF -] -QUAD_LIGHT_PROPERTIES = [ - ("Controller|Configuration|Both directions", True), - ("Controller|Configuration|Fast approximation", True), -] -SIMPLE_POINT_LIGHT_PROPERTIES = [ - ("Controller|Configuration|Attenuation radius|Mode", 0), - ("Controller|Configuration|Attenuation radius|Radius", 100.0), -] -SIMPLE_SPOT_LIGHT_PROPERTIES = [ - ("Controller|Configuration|Shutters|Inner angle", 45.0), - ("Controller|Configuration|Shutters|Outer angle", 90.0), -] - - -def verify_required_component_property_value(entity_name, component, property_path, expected_property_value): - """ - Compares the property value of component against the expected_property_value. - :param entity_name: name of the entity to use (for test verification purposes). - :param component: component to check on a given entity for its current property value. - :param property_path: the path to the property inside the component. - :param expected_property_value: The value expected from the value inside property_path. - :return: None, but prints to general.log() which the test uses to verify against. - """ - property_value = editor.EditorComponentAPIBus( - bus.Broadcast, "GetComponentProperty", component, property_path).GetValue() - general.log(f"{entity_name}_test: Property value is {property_value} " - f"which matches {expected_property_value}") - - -def run(): - """ - Test Case - Light Component - 1. Creates a "light_entity" Entity and attaches a "Light" component to it. - 2. Updates the Light component to each light type option from the LIGHT_TYPES constant. - 3. The test will check the Editor log to ensure each light type was selected. - 4. Prints the string "Light component test (non-GPU) completed" after completion. - - Tests will fail immediately if any of these log lines are found: - 1. Trace::Assert - 2. Trace::Error - 3. Traceback (most recent call last): - - :return: None - """ - # Create a "light_entity" entity with "Light" component. - light_entity_name = "light_entity" - light_component = "Light" - light_entity = hydra.Entity(light_entity_name) - light_entity.create_entity(math.Vector3(-1.0, -2.0, 3.0), [light_component]) - general.log( - f"{light_entity_name}_test: Component added to the entity: " - f"{hydra.has_components(light_entity.id, [light_component])}") - - # Populate the light_component_id_pair value so that it can be used to select all Light component options. - light_component_id_pair = None - component_type_id_list = azlmbr.editor.EditorComponentAPIBus( - azlmbr.bus.Broadcast, 'FindComponentTypeIdsByEntityType', [light_component], 0) - if len(component_type_id_list) < 1: - general.log(f"ERROR: A component class with name {light_component} doesn't exist") - light_component_id_pair = None - elif len(component_type_id_list) > 1: - general.log(f"ERROR: Found more than one component classes with same name: {light_component}") - light_component_id_pair = None - entity_component_id_pair = azlmbr.editor.EditorComponentAPIBus( - azlmbr.bus.Broadcast, 'GetComponentOfType', light_entity.id, component_type_id_list[0]) - if entity_component_id_pair.IsSuccess(): - light_component_id_pair = entity_component_id_pair.GetValue() - - # Test each Light component option can be selected and it's properties updated. - # Point (sphere) light type checks. - light_type_property_test( - light_type=LIGHT_TYPES['sphere'], - light_properties=SPHERE_AND_SPOT_DISK_LIGHT_PROPERTIES, - light_component_id_pair=light_component_id_pair, - light_entity_name=light_entity_name, - light_entity=light_entity - ) - - # Spot (disk) light type checks. - light_type_property_test( - light_type=LIGHT_TYPES['spot_disk'], - light_properties=SPHERE_AND_SPOT_DISK_LIGHT_PROPERTIES, - light_component_id_pair=light_component_id_pair, - light_entity_name=light_entity_name, - light_entity=light_entity - ) - - # Capsule light type checks. - azlmbr.editor.EditorComponentAPIBus( - azlmbr.bus.Broadcast, - 'SetComponentProperty', - light_component_id_pair, - LIGHT_TYPE_PROPERTY, - LIGHT_TYPES['capsule'] - ) - verify_required_component_property_value( - entity_name=light_entity_name, - component=light_entity.components[0], - property_path=LIGHT_TYPE_PROPERTY, - expected_property_value=LIGHT_TYPES['capsule'] - ) - - # Quad light type checks. - light_type_property_test( - light_type=LIGHT_TYPES['quad'], - light_properties=QUAD_LIGHT_PROPERTIES, - light_component_id_pair=light_component_id_pair, - light_entity_name=light_entity_name, - light_entity=light_entity - ) - - # Polygon light type checks. - azlmbr.editor.EditorComponentAPIBus( - azlmbr.bus.Broadcast, - 'SetComponentProperty', - light_component_id_pair, - LIGHT_TYPE_PROPERTY, - LIGHT_TYPES['polygon'] - ) - verify_required_component_property_value( - entity_name=light_entity_name, - component=light_entity.components[0], - property_path=LIGHT_TYPE_PROPERTY, - expected_property_value=LIGHT_TYPES['polygon'] - ) - - # Point (simple punctual) light type checks. - light_type_property_test( - light_type=LIGHT_TYPES['simple_point'], - light_properties=SIMPLE_POINT_LIGHT_PROPERTIES, - light_component_id_pair=light_component_id_pair, - light_entity_name=light_entity_name, - light_entity=light_entity - ) - - # Spot (simple punctual) light type checks. - light_type_property_test( - light_type=LIGHT_TYPES['simple_spot'], - light_properties=SIMPLE_SPOT_LIGHT_PROPERTIES, - light_component_id_pair=light_component_id_pair, - light_entity_name=light_entity_name, - light_entity=light_entity - ) - - general.log("Light component test (non-GPU) completed.") - - -def light_type_property_test(light_type, light_properties, light_component_id_pair, light_entity_name, light_entity): - """ - Updates the current light type and modifies its properties, then verifies they are accurate to what was set. - :param light_type: The type of light to update, must match a value in LIGHT_TYPES - :param light_properties: List of tuples detailing properties to modify with update values. - :param light_component_id_pair: Entity + component ID pair for updating the light component on a given entity. - :param light_entity_name: the name of the Entity holding the light component. - :param light_entity: the Entity object containing the light component. - :return: None - """ - azlmbr.editor.EditorComponentAPIBus( - azlmbr.bus.Broadcast, - 'SetComponentProperty', - light_component_id_pair, - LIGHT_TYPE_PROPERTY, - light_type - ) - verify_required_component_property_value( - entity_name=light_entity_name, - component=light_entity.components[0], - property_path=LIGHT_TYPE_PROPERTY, - expected_property_value=light_type - ) - - for light_property in light_properties: - light_entity.get_set_test(0, light_property[0], light_property[1]) - - -if __name__ == "__main__": - run() From 9f25c9f6774fcb2bc92f6a5b23f227efb9c5905f Mon Sep 17 00:00:00 2001 From: jckand-amzn <82226555+jckand-amzn@users.noreply.github.com> Date: Tue, 18 Jan 2022 11:54:29 -0600 Subject: [PATCH 3/7] Skipping ShapeIntersectionFilter test Signed-off-by: jckand-amzn <82226555+jckand-amzn@users.noreply.github.com> --- .../PythonTests/largeworlds/dyn_veg/TestSuite_Main_Optimized.py | 1 + 1 file changed, 1 insertion(+) diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/TestSuite_Main_Optimized.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/TestSuite_Main_Optimized.py index 5b1e504442..af1c187817 100644 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/TestSuite_Main_Optimized.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/TestSuite_Main_Optimized.py @@ -131,6 +131,7 @@ class TestAutomation_PrefabNotEnabled(EditorTestSuite): class test_ShapeIntersectionFilter_InstancesPlantInAssignedShape(EditorParallelTest): from .EditorScripts import ShapeIntersectionFilter_InstancesPlantInAssignedShape as test_module + @pytest.mark.skip("https://github.com/o3de/o3de/issues/6973") class test_ShapeIntersectionFilter_FilterStageToggle(EditorParallelTest): from .EditorScripts import ShapeIntersectionFilter_FilterStageToggle as test_module From d223513ffeb6aa3c88bdacecbcb3e2b3309084e7 Mon Sep 17 00:00:00 2001 From: jckand-amzn <82226555+jckand-amzn@users.noreply.github.com> Date: Wed, 19 Jan 2022 15:01:20 -0600 Subject: [PATCH 4/7] Updating query areas for instance count validation Signed-off-by: jckand-amzn <82226555+jckand-amzn@users.noreply.github.com> --- .../ShapeIntersectionFilter_FilterStageToggle.py | 13 +++++++------ .../largeworlds/dyn_veg/TestSuite_Main_Optimized.py | 1 - 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/ShapeIntersectionFilter_FilterStageToggle.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/ShapeIntersectionFilter_FilterStageToggle.py index 8f179f7f50..b5c00a53b7 100644 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/ShapeIntersectionFilter_FilterStageToggle.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/ShapeIntersectionFilter_FilterStageToggle.py @@ -68,7 +68,7 @@ def ShapeIntersectionFilter_FilterStageToggle(): # Create a new entity as a child of the vegetation area entity with Box Shape box = hydra.Entity("box") box.create_entity(position, ["Box Shape"]) - box.get_set_test(0, "Box Shape|Box Configuration|Dimensions", math.Vector3(8.0, 8.0, 1.0)) + box.get_set_test(0, "Box Shape|Box Configuration|Dimensions", math.Vector3(5.0, 5.0, 1.0)) # Create a new entity as a child of the vegetation area entity with Cylinder Shape. cylinder = hydra.Entity("cylinder") @@ -80,10 +80,10 @@ def ShapeIntersectionFilter_FilterStageToggle(): # On the Shape Intersection Filter component, click the crosshair button, and add child entities one by one vegetation.get_set_test(3, "Configuration|Shape Entity Id", box.id) - result = helper.wait_for_condition(lambda: dynveg.validate_instance_count(position, 8.0, 100), 2.0) + result = helper.wait_for_condition(lambda: dynveg.validate_instance_count(position, 5.0, 49), 2.0) Report.result(Tests.instance_count_in_box_shape, result) vegetation.get_set_test(3, "Configuration|Shape Entity Id", cylinder.id) - result = helper.wait_for_condition(lambda: dynveg.validate_instance_count(position, 5.0, 100), 2.0) + result = helper.wait_for_condition(lambda: dynveg.validate_instance_count(position, 5.0, 121), 2.0) Report.result(Tests.instance_count_in_cylinder_shape, result) # Create a new entity as a child of the area entity with Random Noise Gradient, Gradient Transform Modifier, @@ -98,12 +98,13 @@ def ShapeIntersectionFilter_FilterStageToggle(): # Pin the Random Noise entity to the Gradient Entity Id field of the Position Modifier's Gradient X vegetation.get_set_test(4, "Configuration|Position X|Gradient|Gradient Entity Id", random_noise.id) - # Toggle between PreProcess and PostProcess + # Toggle between PreProcess and PostProcess and validate instances. Validate in a 0.3m wider radius due to position + # offsets vegetation.get_set_test(3, "Configuration|Filter Stage", 1) - result = helper.wait_for_condition(lambda: dynveg.validate_instance_count(position, 5.0, 117), 2.0) + result = helper.wait_for_condition(lambda: dynveg.validate_instance_count(position, 5.3, 121), 2.0) Report.result(Tests.preprocess_instance_count, result) vegetation.get_set_test(3, "Configuration|Filter Stage", 2) - result = helper.wait_for_condition(lambda: dynveg.validate_instance_count(position, 5.0, 122), 2.0) + result = helper.wait_for_condition(lambda: dynveg.validate_instance_count(position, 5.3, 122), 2.0) Report.result(Tests.postprocess_instance_count, result) diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/TestSuite_Main_Optimized.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/TestSuite_Main_Optimized.py index af1c187817..5b1e504442 100644 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/TestSuite_Main_Optimized.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/TestSuite_Main_Optimized.py @@ -131,7 +131,6 @@ class TestAutomation_PrefabNotEnabled(EditorTestSuite): class test_ShapeIntersectionFilter_InstancesPlantInAssignedShape(EditorParallelTest): from .EditorScripts import ShapeIntersectionFilter_InstancesPlantInAssignedShape as test_module - @pytest.mark.skip("https://github.com/o3de/o3de/issues/6973") class test_ShapeIntersectionFilter_FilterStageToggle(EditorParallelTest): from .EditorScripts import ShapeIntersectionFilter_FilterStageToggle as test_module From 2b43ad8029f53acd9edee4b49adfafdf9b2e0a01 Mon Sep 17 00:00:00 2001 From: Mike Balfour <82224783+mbalfour-amzn@users.noreply.github.com> Date: Wed, 19 Jan 2022 17:10:37 -0600 Subject: [PATCH 5/7] FastNoise GetValues() specialization (#7009) * Add comparison operator for use from unit tests. Signed-off-by: Mike Balfour <82224783+mbalfour-amzn@users.noreply.github.com> * First version of FastNoise benchmarks. Signed-off-by: Mike Balfour <82224783+mbalfour-amzn@users.noreply.github.com> * Simplified unit tests and added initial benchmarks. Signed-off-by: Mike Balfour <82224783+mbalfour-amzn@users.noreply.github.com> * Add GetValue vs GetValues unit test. Signed-off-by: Mike Balfour <82224783+mbalfour-amzn@users.noreply.github.com> * Moved Gradient test code into helper files for use from FastNoise. Also added benchmarks for each type of FastNoise so that we can have some comparative values handy. Signed-off-by: Mike Balfour <82224783+mbalfour-amzn@users.noreply.github.com> * Specialization for GetValues(). Signed-off-by: Mike Balfour <82224783+mbalfour-amzn@users.noreply.github.com> --- Gems/FastNoise/Code/CMakeLists.txt | 46 ++-- .../Source/FastNoiseGradientComponent.cpp | 46 +++- .../Code/Source/FastNoiseGradientComponent.h | 3 + .../Code/Tests/FastNoiseBenchmarks.cpp | 116 +++++++++ .../Code/Tests/FastNoiseEditorTest.cpp | 44 ++++ Gems/FastNoise/Code/Tests/FastNoiseTest.cpp | 246 ++++-------------- Gems/FastNoise/Code/Tests/FastNoiseTest.h | 60 +++++ .../Code/fastnoise_editor_tests_files.cmake | 13 + .../Code/fastnoise_tests_files.cmake | 1 + .../Code/Tests/GradientSignalBenchmarks.cpp | 211 ++------------- .../Tests/GradientSignalGetValuesTests.cpp | 76 ++---- .../Code/Tests/GradientSignalTestHelpers.cpp | 203 +++++++++++++++ .../Code/Tests/GradientSignalTestHelpers.h | 76 ++++++ .../gradientsignal_shared_tests_files.cmake | 2 + 14 files changed, 668 insertions(+), 475 deletions(-) create mode 100644 Gems/FastNoise/Code/Tests/FastNoiseBenchmarks.cpp create mode 100644 Gems/FastNoise/Code/Tests/FastNoiseEditorTest.cpp create mode 100644 Gems/FastNoise/Code/Tests/FastNoiseTest.h create mode 100644 Gems/FastNoise/Code/fastnoise_editor_tests_files.cmake create mode 100644 Gems/GradientSignal/Code/Tests/GradientSignalTestHelpers.cpp create mode 100644 Gems/GradientSignal/Code/Tests/GradientSignalTestHelpers.h diff --git a/Gems/FastNoise/Code/CMakeLists.txt b/Gems/FastNoise/Code/CMakeLists.txt index 819592e018..d945db1665 100644 --- a/Gems/FastNoise/Code/CMakeLists.txt +++ b/Gems/FastNoise/Code/CMakeLists.txt @@ -104,7 +104,7 @@ if(PAL_TRAIT_BUILD_TESTS_SUPPORTED) NAME FastNoise.Editor.Tests ${PAL_TRAIT_TEST_TARGET_TYPE} NAMESPACE Gem FILES_CMAKE - fastnoise_tests_files.cmake + fastnoise_editor_tests_files.cmake COMPILE_DEFINITIONS PUBLIC FASTNOISE_EDITOR @@ -120,23 +120,31 @@ if(PAL_TRAIT_BUILD_TESTS_SUPPORTED) ly_add_googletest( NAME Gem::FastNoise.Editor.Tests ) - else() - ly_add_target( - NAME FastNoise.Tests ${PAL_TRAIT_TEST_TARGET_TYPE} - NAMESPACE Gem - FILES_CMAKE - fastnoise_tests_files.cmake - INCLUDE_DIRECTORIES - PRIVATE - Tests - BUILD_DEPENDENCIES - PRIVATE - AZ::AzTest - Gem::FastNoise.Static - Gem::LmbrCentral - ) - ly_add_googletest( - NAME Gem::FastNoise.Tests - ) endif() + + ly_add_target( + NAME FastNoise.Tests ${PAL_TRAIT_TEST_TARGET_TYPE} + NAMESPACE Gem + FILES_CMAKE + fastnoise_tests_files.cmake + INCLUDE_DIRECTORIES + PRIVATE + Tests + BUILD_DEPENDENCIES + PRIVATE + AZ::AzTest + Gem::FastNoise.Static + Gem::GradientSignal + Gem::GradientSignal.Tests.Static + Gem::LmbrCentral + ) + ly_add_googletest( + NAME Gem::FastNoise.Tests + ) + + ly_add_googlebenchmark( + NAME Gem::FastNoise.Benchmarks + TARGET Gem::FastNoise.Tests + ) + endif() diff --git a/Gems/FastNoise/Code/Source/FastNoiseGradientComponent.cpp b/Gems/FastNoise/Code/Source/FastNoiseGradientComponent.cpp index 4cea2efcc8..ceeafc3af6 100644 --- a/Gems/FastNoise/Code/Source/FastNoiseGradientComponent.cpp +++ b/Gems/FastNoise/Code/Source/FastNoiseGradientComponent.cpp @@ -54,6 +54,21 @@ namespace FastNoiseGem return AZ::Edit::PropertyVisibility::Hide; } + bool FastNoiseGradientConfig::operator==(const FastNoiseGradientConfig& rhs) const + { + return (m_cellularDistanceFunction == rhs.m_cellularDistanceFunction) + && (m_cellularJitter == rhs.m_cellularJitter) + && (m_cellularReturnType == rhs.m_cellularReturnType) + && (m_fractalType == rhs.m_fractalType) + && (m_frequency == rhs.m_frequency) + && (m_gain == rhs.m_gain) + && (m_interp == rhs.m_interp) + && (m_lacunarity == rhs.m_lacunarity) + && (m_noiseType == rhs.m_noiseType) + && (m_octaves == rhs.m_octaves) + && (m_seed == rhs.m_seed); + } + void FastNoiseGradientConfig::Reflect(AZ::ReflectContext* context) { if (auto serializeContext = azrtti_cast(context)) @@ -306,7 +321,7 @@ namespace FastNoiseGem float FastNoiseGradientComponent::GetValue(const GradientSignal::GradientSampleParams& sampleParams) const { - AZ::Vector3 uvw = sampleParams.m_position; + AZ::Vector3 uvw; bool wasPointRejected = false; { @@ -314,13 +329,34 @@ namespace FastNoiseGem m_gradientTransform.TransformPositionToUVW(sampleParams.m_position, uvw, wasPointRejected); } - if (!wasPointRejected) + // Generator returns a range between [-1, 1], map that to [0, 1] + return wasPointRejected ? + 0.0f : + AZ::GetClamp((m_generator.GetNoise(uvw.GetX(), uvw.GetY(), uvw.GetZ()) + 1.0f) / 2.0f, 0.0f, 1.0f); + } + + void FastNoiseGradientComponent::GetValues(AZStd::span positions, AZStd::span outValues) const + { + if (positions.size() != outValues.size()) { - // Generator returns a range between [-1, 1], map that to [0, 1] - return AZ::GetClamp((m_generator.GetNoise(uvw.GetX(), uvw.GetY(), uvw.GetZ()) + 1.0f) / 2.0f, 0.0f, 1.0f); + AZ_Assert(false, "input and output lists are different sizes (%zu vs %zu).", positions.size(), outValues.size()); + return; } - return 0.0f; + AZStd::shared_lock lock(m_transformMutex); + AZ::Vector3 uvw; + + for (size_t index = 0; index < positions.size(); index++) + { + bool wasPointRejected = false; + + m_gradientTransform.TransformPositionToUVW(positions[index], uvw, wasPointRejected); + + // Generator returns a range between [-1, 1], map that to [0, 1] + outValues[index] = wasPointRejected ? + 0.0f : + AZ::GetClamp((m_generator.GetNoise(uvw.GetX(), uvw.GetY(), uvw.GetZ()) + 1.0f) / 2.0f, 0.0f, 1.0f); + } } template diff --git a/Gems/FastNoise/Code/Source/FastNoiseGradientComponent.h b/Gems/FastNoise/Code/Source/FastNoiseGradientComponent.h index dd19049ee6..29c42bfe1b 100644 --- a/Gems/FastNoise/Code/Source/FastNoiseGradientComponent.h +++ b/Gems/FastNoise/Code/Source/FastNoiseGradientComponent.h @@ -47,6 +47,8 @@ namespace FastNoiseGem AZ::u32 GetFrequencyParameterVisbility() const; AZ::u32 GetInterpParameterVisibility() const; + bool operator==(const FastNoiseGradientConfig& rhs) const; + int m_seed = 1; float m_frequency = 1.f; FastNoise::Interp m_interp = FastNoise::Interp::Quintic; @@ -90,6 +92,7 @@ namespace FastNoiseGem // GradientRequestBus overrides... float GetValue(const GradientSignal::GradientSampleParams& sampleParams) const override; + void GetValues(AZStd::span positions, AZStd::span outValues) const override; protected: FastNoiseGradientConfig m_configuration; diff --git a/Gems/FastNoise/Code/Tests/FastNoiseBenchmarks.cpp b/Gems/FastNoise/Code/Tests/FastNoiseBenchmarks.cpp new file mode 100644 index 0000000000..1e438db112 --- /dev/null +++ b/Gems/FastNoise/Code/Tests/FastNoiseBenchmarks.cpp @@ -0,0 +1,116 @@ +/* + * Copyright (c) Contributors to the Open 3D Engine Project. + * For complete copyright and license terms please see the LICENSE at the root of this distribution. + * + * SPDX-License-Identifier: Apache-2.0 OR MIT + * + */ + +#ifdef HAVE_BENCHMARK + +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace UnitTest +{ + class FastNoiseGetValues + : public ::benchmark::Fixture + { + public: + void RunGetValueOrGetValuesBenchmark(benchmark::State& state, FastNoise::NoiseType noiseType) + { + AZ::Entity* noiseEntity = aznew AZ::Entity("noise_entity"); + ASSERT_TRUE(noiseEntity != nullptr); + noiseEntity->CreateComponent(); + noiseEntity->CreateComponent(LmbrCentral::BoxShapeComponentTypeId); + noiseEntity->CreateComponent(); + + // Set up a FastNoise component with the requested noise type + FastNoiseGem::FastNoiseGradientConfig cfg; + cfg.m_frequency = 0.01f; + cfg.m_noiseType = noiseType; + noiseEntity->CreateComponent(cfg); + + noiseEntity->Init(); + noiseEntity->Activate(); + + UnitTest::GradientSignalTestHelpers::RunGetValueOrGetValuesBenchmark(state, noiseEntity->GetId()); + } + + }; + + BENCHMARK_DEFINE_F(FastNoiseGetValues, BM_FastNoiseGradient_Value)(benchmark::State& state) + { + RunGetValueOrGetValuesBenchmark(state, FastNoise::NoiseType::Value); + } + + BENCHMARK_DEFINE_F(FastNoiseGetValues, BM_FastNoiseGradient_ValueFractal)(benchmark::State& state) + { + RunGetValueOrGetValuesBenchmark(state, FastNoise::NoiseType::ValueFractal); + } + + BENCHMARK_DEFINE_F(FastNoiseGetValues, BM_FastNoiseGradient_Perlin)(benchmark::State& state) + { + RunGetValueOrGetValuesBenchmark(state, FastNoise::NoiseType::Perlin); + } + + BENCHMARK_DEFINE_F(FastNoiseGetValues, BM_FastNoiseGradient_PerlinFractal)(benchmark::State& state) + { + RunGetValueOrGetValuesBenchmark(state, FastNoise::NoiseType::PerlinFractal); + } + + BENCHMARK_DEFINE_F(FastNoiseGetValues, BM_FastNoiseGradient_Simplex)(benchmark::State& state) + { + RunGetValueOrGetValuesBenchmark(state, FastNoise::NoiseType::Simplex); + } + + BENCHMARK_DEFINE_F(FastNoiseGetValues, BM_FastNoiseGradient_SimplexFractal)(benchmark::State& state) + { + RunGetValueOrGetValuesBenchmark(state, FastNoise::NoiseType::SimplexFractal); + } + + BENCHMARK_DEFINE_F(FastNoiseGetValues, BM_FastNoiseGradient_Cellular)(benchmark::State& state) + { + RunGetValueOrGetValuesBenchmark(state, FastNoise::NoiseType::Cellular); + } + + BENCHMARK_DEFINE_F(FastNoiseGetValues, BM_FastNoiseGradient_WhiteNoise)(benchmark::State& state) + { + RunGetValueOrGetValuesBenchmark(state, FastNoise::NoiseType::WhiteNoise); + } + + BENCHMARK_DEFINE_F(FastNoiseGetValues, BM_FastNoiseGradient_Cubic)(benchmark::State& state) + { + RunGetValueOrGetValuesBenchmark(state, FastNoise::NoiseType::Cubic); + } + + BENCHMARK_DEFINE_F(FastNoiseGetValues, BM_FastNoiseGradient_CubicFractal)(benchmark::State& state) + { + RunGetValueOrGetValuesBenchmark(state, FastNoise::NoiseType::CubicFractal); + } + + GRADIENT_SIGNAL_GET_VALUES_BENCHMARK_REGISTER_F(FastNoiseGetValues, BM_FastNoiseGradient_Value); + GRADIENT_SIGNAL_GET_VALUES_BENCHMARK_REGISTER_F(FastNoiseGetValues, BM_FastNoiseGradient_ValueFractal); + GRADIENT_SIGNAL_GET_VALUES_BENCHMARK_REGISTER_F(FastNoiseGetValues, BM_FastNoiseGradient_Perlin); + GRADIENT_SIGNAL_GET_VALUES_BENCHMARK_REGISTER_F(FastNoiseGetValues, BM_FastNoiseGradient_PerlinFractal); + GRADIENT_SIGNAL_GET_VALUES_BENCHMARK_REGISTER_F(FastNoiseGetValues, BM_FastNoiseGradient_Simplex); + GRADIENT_SIGNAL_GET_VALUES_BENCHMARK_REGISTER_F(FastNoiseGetValues, BM_FastNoiseGradient_SimplexFractal); + GRADIENT_SIGNAL_GET_VALUES_BENCHMARK_REGISTER_F(FastNoiseGetValues, BM_FastNoiseGradient_Cellular); + GRADIENT_SIGNAL_GET_VALUES_BENCHMARK_REGISTER_F(FastNoiseGetValues, BM_FastNoiseGradient_WhiteNoise); + GRADIENT_SIGNAL_GET_VALUES_BENCHMARK_REGISTER_F(FastNoiseGetValues, BM_FastNoiseGradient_Cubic); + GRADIENT_SIGNAL_GET_VALUES_BENCHMARK_REGISTER_F(FastNoiseGetValues, BM_FastNoiseGradient_CubicFractal); + +#endif +} + + + diff --git a/Gems/FastNoise/Code/Tests/FastNoiseEditorTest.cpp b/Gems/FastNoise/Code/Tests/FastNoiseEditorTest.cpp new file mode 100644 index 0000000000..e30c6c01e0 --- /dev/null +++ b/Gems/FastNoise/Code/Tests/FastNoiseEditorTest.cpp @@ -0,0 +1,44 @@ +/* + * Copyright (c) Contributors to the Open 3D Engine Project. + * For complete copyright and license terms please see the LICENSE at the root of this distribution. + * + * SPDX-License-Identifier: Apache-2.0 OR MIT + * + */ + +#include + +#include +#include +#include +#include + + +class FastNoiseEditorTestApp : public ::testing::Test +{ +}; + +TEST_F(FastNoiseEditorTestApp, FastNoise_EditorCreateGameEntity) +{ + AZStd::unique_ptr noiseEntity(aznew AZ::Entity("editor_noise_entity")); + ASSERT_TRUE(noiseEntity != nullptr); + + FastNoiseGem::EditorFastNoiseGradientComponent editor; + auto* editorBase = static_cast(&editor); + editorBase->BuildGameEntity(noiseEntity.get()); + + // the new game entity's FastNoise component should look like the default one + FastNoiseGem::FastNoiseGradientConfig defaultConfig; + FastNoiseGem::FastNoiseGradientConfig gameComponentConfig; + + FastNoiseGem::FastNoiseGradientComponent* noiseComp = noiseEntity->FindComponent(); + ASSERT_TRUE(noiseComp != nullptr); + + // Change a value in the gameComponentConfig just to verify that it got overwritten instead of simply matching the default. + gameComponentConfig.m_seed++; + noiseComp->WriteOutConfig(&gameComponentConfig); + ASSERT_EQ(defaultConfig, gameComponentConfig); +} + +// This uses custom test / benchmark hooks so that we can load LmbrCentral and GradientSignal Gems. +AZ_UNIT_TEST_HOOK(new UnitTest::FastNoiseTestEnvironment, UnitTest::FastNoiseBenchmarkEnvironment); diff --git a/Gems/FastNoise/Code/Tests/FastNoiseTest.cpp b/Gems/FastNoise/Code/Tests/FastNoiseTest.cpp index f0d5a9d1bd..1ac5e8ddca 100644 --- a/Gems/FastNoise/Code/Tests/FastNoiseTest.cpp +++ b/Gems/FastNoise/Code/Tests/FastNoiseTest.cpp @@ -10,199 +10,61 @@ #include #include -#include -#include -#include #include +#include #include -#include -#include +#include #include -#include +#include +#include +#include #include #include #include +#include +#include -class MockGradientTransformComponent - : public AZ::Component - , private GradientSignal::GradientTransformRequestBus::Handler - , private GradientSignal::GradientTransformModifierRequestBus::Handler +class FastNoiseTest : public ::testing::Test { -public: - AZ_COMPONENT(MockGradientTransformComponent, "{464CF47B-7E10-4E1B-BD06-79BD2AC91399}"); - - static void GetProvidedServices(AZ::ComponentDescriptor::DependencyArrayType& services) - { - services.push_back(AZ_CRC("GradientTransformService", 0x8c8c5ecc)); - } - static void Reflect([[maybe_unused]] AZ::ReflectContext* context) {} - - MockGradientTransformComponent() = default; - ~MockGradientTransformComponent() = default; - - // AZ::Component interface - void Activate() override {} - void Deactivate() override {} - - //////////////////////////////////////////////////////////////////////////// - //// GradientTransformRequestBus - const GradientSignal::GradientTransform& GetGradientTransform() const override - { - return m_gradientTransform; - } - - ////////////////////////////////////////////////////////////////////////// - // GradientTransformModifierRequestBus - bool GetAllowReference() const override { return false; } - void SetAllowReference([[maybe_unused]] bool value) override {} - - AZ::EntityId GetShapeReference() const override { return AZ::EntityId(); } - void SetShapeReference([[maybe_unused]] AZ::EntityId shapeReference) override {} - - bool GetOverrideBounds() const override { return false; } - void SetOverrideBounds([[maybe_unused]] bool value) override {} - - AZ::Vector3 GetBounds() const override { return AZ::Vector3(); } - void SetBounds([[maybe_unused]] AZ::Vector3 bounds) override {} - - GradientSignal::TransformType GetTransformType() const override { return static_cast(0); } - void SetTransformType([[maybe_unused]] GradientSignal::TransformType type) override {} - - bool GetOverrideTranslate() const override { return false; } - void SetOverrideTranslate([[maybe_unused]] bool value) override {} - - AZ::Vector3 GetTranslate() const override { return AZ::Vector3(); } - void SetTranslate([[maybe_unused]] AZ::Vector3 translate) override {} - - bool GetOverrideRotate() const override { return false; } - void SetOverrideRotate([[maybe_unused]] bool value) override {} - - AZ::Vector3 GetRotate() const override { return AZ::Vector3(); } - void SetRotate([[maybe_unused]] AZ::Vector3 rotate) override {} - - bool GetOverrideScale() const override { return false; } - void SetOverrideScale([[maybe_unused]] bool value) override {} - - AZ::Vector3 GetScale() const override { return AZ::Vector3(); } - void SetScale([[maybe_unused]] AZ::Vector3 scale) override {} - - float GetFrequencyZoom() const override { return false; } - void SetFrequencyZoom([[maybe_unused]] float frequencyZoom) override {} - - GradientSignal::WrappingType GetWrappingType() const override { return static_cast(0); } - void SetWrappingType([[maybe_unused]] GradientSignal::WrappingType type) override {} - - bool GetIs3D() const override { return false; } - void SetIs3D([[maybe_unused]] bool value) override {} - - bool GetAdvancedMode() const override { return false; } - void SetAdvancedMode([[maybe_unused]] bool value) override {} - - GradientSignal::GradientTransform m_gradientTransform; }; -TEST(FastNoiseTest, ComponentsWithComponentApplication) +TEST_F(FastNoiseTest, FastNoise_ComponentCreatesSuccessfully) { - AZ::ComponentApplication::Descriptor appDesc; - appDesc.m_memoryBlocksByteSize = 10 * 1024 * 1024; - appDesc.m_recordingMode = AZ::Debug::AllocationRecords::RECORD_FULL; - appDesc.m_stackRecordLevels = 20; - - AZ::ComponentApplication app; - AZ::Entity* systemEntity = app.Create(appDesc); - ASSERT_TRUE(systemEntity != nullptr); - app.RegisterComponentDescriptor(FastNoiseGem::FastNoiseSystemComponent::CreateDescriptor()); - systemEntity->CreateComponent(); - - systemEntity->Init(); - systemEntity->Activate(); - - AZ::Entity* noiseEntity = aznew AZ::Entity("fastnoise_entity"); + AZ::Entity* noiseEntity = aznew AZ::Entity("noise_entity"); + ASSERT_TRUE(noiseEntity != nullptr); noiseEntity->CreateComponent(); - app.AddEntity(noiseEntity); - app.Destroy(); - ASSERT_TRUE(true); + FastNoiseGem::FastNoiseGradientComponent* noiseComp = noiseEntity->FindComponent(); + ASSERT_TRUE(noiseComp != nullptr); } -class FastNoiseTestApp - : public ::testing::Test -{ -public: - FastNoiseTestApp() - : m_application() - , m_systemEntity(nullptr) - { - } - - void SetUp() override - { - AZ::ComponentApplication::Descriptor appDesc; - appDesc.m_memoryBlocksByteSize = 10 * 1024 * 1024; - appDesc.m_recordingMode = AZ::Debug::AllocationRecords::RECORD_FULL; - appDesc.m_stackRecordLevels = 20; - - AZ::ComponentApplication::StartupParameters appStartup; - appStartup.m_createStaticModulesCallback = - [](AZStd::vector& modules) - { - modules.emplace_back(new FastNoiseGem::FastNoiseModule); - }; - - m_systemEntity = m_application.Create(appDesc, appStartup); - m_application.RegisterComponentDescriptor(MockGradientTransformComponent::CreateDescriptor()); - m_systemEntity->Init(); - m_systemEntity->Activate(); - } - - void TearDown() override - { - m_application.Destroy(); - } - - AZ::ComponentApplication m_application; - AZ::Entity* m_systemEntity; -}; - -////////////////////////////////////////////////////////////////////////// -// testing class to inspect protected data members in the FastNoiseGradientComponent -struct FastNoiseGradientComponentTester : public FastNoiseGem::FastNoiseGradientComponent -{ - const FastNoiseGem::FastNoiseGradientConfig& GetConfig() const { return m_configuration; } - - void AssertTrue(const FastNoiseGem::FastNoiseGradientConfig& cfg) - { - ASSERT_TRUE(m_configuration.m_cellularDistanceFunction == cfg.m_cellularDistanceFunction); - ASSERT_TRUE(m_configuration.m_cellularJitter == cfg.m_cellularJitter); - ASSERT_TRUE(m_configuration.m_cellularReturnType == cfg.m_cellularReturnType); - ASSERT_TRUE(m_configuration.m_fractalType == cfg.m_fractalType); - ASSERT_TRUE(m_configuration.m_frequency == cfg.m_frequency); - ASSERT_TRUE(m_configuration.m_gain == cfg.m_gain); - ASSERT_TRUE(m_configuration.m_interp == cfg.m_interp); - ASSERT_TRUE(m_configuration.m_lacunarity == cfg.m_lacunarity); - ASSERT_TRUE(m_configuration.m_noiseType == cfg.m_noiseType); - ASSERT_TRUE(m_configuration.m_octaves == cfg.m_octaves); - ASSERT_TRUE(m_configuration.m_seed == cfg.m_seed); - } -}; - -TEST_F(FastNoiseTestApp, FastNoise_Component) +TEST_F(FastNoiseTest, FastNoise_ComponentMatchesConfiguration) { AZ::Entity* noiseEntity = aznew AZ::Entity("noise_entity"); ASSERT_TRUE(noiseEntity != nullptr); - noiseEntity->CreateComponent(); - m_application.AddEntity(noiseEntity); + + FastNoiseGem::FastNoiseGradientConfig cfg; + FastNoiseGem::FastNoiseGradientConfig componentConfig; + + noiseEntity->CreateComponent(); + noiseEntity->CreateComponent(LmbrCentral::BoxShapeComponentTypeId); + noiseEntity->CreateComponent(); + noiseEntity->CreateComponent(cfg); FastNoiseGem::FastNoiseGradientComponent* noiseComp = noiseEntity->FindComponent(); ASSERT_TRUE(noiseComp != nullptr); + noiseComp->WriteOutConfig(&componentConfig); + ASSERT_EQ(cfg, componentConfig); } -TEST_F(FastNoiseTestApp, FastNoise_ComponentEbus) +TEST_F(FastNoiseTest, FastNoise_ComponentEbusWorksSuccessfully) { AZ::Entity* noiseEntity = aznew AZ::Entity("noise_entity"); ASSERT_TRUE(noiseEntity != nullptr); + noiseEntity->CreateComponent(); + noiseEntity->CreateComponent(LmbrCentral::BoxShapeComponentTypeId); + noiseEntity->CreateComponent(); noiseEntity->CreateComponent(); - noiseEntity->CreateComponent(); noiseEntity->Init(); noiseEntity->Activate(); @@ -210,51 +72,39 @@ TEST_F(FastNoiseTestApp, FastNoise_ComponentEbus) GradientSignal::GradientSampleParams params; float sample = -1.0f; - GradientSignal::GradientRequestBus::EventResult(sample, noiseEntity->GetId(), &GradientSignal::GradientRequestBus::Events::GetValue, params); + GradientSignal::GradientRequestBus::EventResult(sample, noiseEntity->GetId(), + &GradientSignal::GradientRequestBus::Events::GetValue, params); ASSERT_TRUE(sample >= 0.0f); ASSERT_TRUE(sample <= 1.0f); } -TEST_F(FastNoiseTestApp, FastNoise_ComponentMatchesConfiguration) +TEST_F(FastNoiseTest, FastNoise_VerifyGetValueAndGetValuesMatch) { + const float shapeHalfBounds = 128.0f; + AZ::Entity* noiseEntity = aznew AZ::Entity("noise_entity"); ASSERT_TRUE(noiseEntity != nullptr); + noiseEntity->CreateComponent(); + noiseEntity->CreateComponent(); - AZ::SimpleLcgRandom rand(AZStd::GetTimeNowMicroSecond()); + // Create a Box Shape to map our gradient into + LmbrCentral::BoxShapeConfig boxConfig(AZ::Vector3(shapeHalfBounds * 2.0f)); + auto boxComponent = noiseEntity->CreateComponent(LmbrCentral::BoxShapeComponentTypeId); + boxComponent->SetConfiguration(boxConfig); + // Create a Fast Noise component with an adjusted frequency. (The defaults of Perlin noise with frequency=1.0 would cause us + // to always get back the same noise value) FastNoiseGem::FastNoiseGradientConfig cfg; - + cfg.m_frequency = 0.01f; noiseEntity->CreateComponent(cfg); - noiseEntity->CreateComponent(); - - m_application.AddEntity(noiseEntity); - FastNoiseGem::FastNoiseGradientComponent* noiseComp = noiseEntity->FindComponent(); - ASSERT_TRUE(noiseComp != nullptr); - reinterpret_cast(noiseComp)->AssertTrue(cfg); -} - -#if FASTNOISE_EDITOR -#include - -TEST_F(FastNoiseTestApp, FastNoise_EditorCreateGameEntity) -{ - AZStd::unique_ptr noiseEntity(aznew AZ::Entity("editor_noise_entity")); - ASSERT_TRUE(noiseEntity != nullptr); - - FastNoiseGem::EditorFastNoiseGradientComponent editor; - auto* editorBase = static_cast(&editor); - editorBase->BuildGameEntity(noiseEntity.get()); - - // the new game entity's ocean component should look like the default one - FastNoiseGem::FastNoiseGradientConfig cfg; + noiseEntity->Init(); + noiseEntity->Activate(); - FastNoiseGem::FastNoiseGradientComponent* noiseComp = noiseEntity->FindComponent(); - ASSERT_TRUE(noiseComp != nullptr); - reinterpret_cast(noiseComp)->AssertTrue(cfg); + // Create a gradient sampler and run through a series of points to see if they match expectations. + UnitTest::GradientSignalTestHelpers::CompareGetValueAndGetValues(noiseEntity->GetId(), shapeHalfBounds); } -#endif - -AZ_UNIT_TEST_HOOK(DEFAULT_UNIT_TEST_ENV); +// This uses custom test / benchmark hooks so that we can load LmbrCentral and GradientSignal Gems. +AZ_UNIT_TEST_HOOK(new UnitTest::FastNoiseTestEnvironment, UnitTest::FastNoiseBenchmarkEnvironment); diff --git a/Gems/FastNoise/Code/Tests/FastNoiseTest.h b/Gems/FastNoise/Code/Tests/FastNoiseTest.h new file mode 100644 index 0000000000..71b10cfc68 --- /dev/null +++ b/Gems/FastNoise/Code/Tests/FastNoiseTest.h @@ -0,0 +1,60 @@ +/* + * Copyright (c) Contributors to the Open 3D Engine Project. + * For complete copyright and license terms please see the LICENSE at the root of this distribution. + * + * SPDX-License-Identifier: Apache-2.0 OR MIT + * + */ +#pragma once + +#include +#include +#include +#include + +namespace UnitTest +{ + // The FastNoise unit tests need to use the GemTestEnvironment to load the GradientSignal and LmbrCentral Gems so that + // GradientTransform components can be used in the unit tests and benchmarks. + class FastNoiseTestEnvironment + : public AZ::Test::GemTestEnvironment + { + public: + void AddGemsAndComponents() override + { + AddDynamicModulePaths({ "GradientSignal" }); + AddDynamicModulePaths({ "LmbrCentral" }); + + AddComponentDescriptors({ + AzFramework::TransformComponent::CreateDescriptor(), + FastNoiseGem::FastNoiseSystemComponent::CreateDescriptor(), + FastNoiseGem::FastNoiseGradientComponent::CreateDescriptor() + }); + + AddRequiredComponents({ FastNoiseGem::FastNoiseSystemComponent::TYPEINFO_Uuid() }); + } + }; + +#ifdef HAVE_BENCHMARK + //! The Benchmark environment is used for one time setup and tear down of shared resources + class FastNoiseBenchmarkEnvironment + : public AZ::Test::BenchmarkEnvironmentBase + , public FastNoiseTestEnvironment + + { + protected: + void SetUpBenchmark() override + { + SetupEnvironment(); + } + + void TearDownBenchmark() override + { + TeardownEnvironment(); + } + }; +#endif + + +} // namespace UnitTest + diff --git a/Gems/FastNoise/Code/fastnoise_editor_tests_files.cmake b/Gems/FastNoise/Code/fastnoise_editor_tests_files.cmake new file mode 100644 index 0000000000..685e2fb647 --- /dev/null +++ b/Gems/FastNoise/Code/fastnoise_editor_tests_files.cmake @@ -0,0 +1,13 @@ +# +# Copyright (c) Contributors to the Open 3D Engine Project. +# For complete copyright and license terms please see the LICENSE at the root of this distribution. +# +# SPDX-License-Identifier: Apache-2.0 OR MIT +# +# + +set(FILES + Tests/FastNoiseEditorTest.cpp + Source/FastNoiseModule.h + Source/FastNoiseModule.cpp +) diff --git a/Gems/FastNoise/Code/fastnoise_tests_files.cmake b/Gems/FastNoise/Code/fastnoise_tests_files.cmake index 08386940f2..4669b0d446 100644 --- a/Gems/FastNoise/Code/fastnoise_tests_files.cmake +++ b/Gems/FastNoise/Code/fastnoise_tests_files.cmake @@ -7,6 +7,7 @@ # set(FILES + Tests/FastNoiseBenchmarks.cpp Tests/FastNoiseTest.cpp Source/FastNoiseModule.h Source/FastNoiseModule.cpp diff --git a/Gems/GradientSignal/Code/Tests/GradientSignalBenchmarks.cpp b/Gems/GradientSignal/Code/Tests/GradientSignalBenchmarks.cpp index bd4ccf5205..6ffb4a31c4 100644 --- a/Gems/GradientSignal/Code/Tests/GradientSignalBenchmarks.cpp +++ b/Gems/GradientSignal/Code/Tests/GradientSignalBenchmarks.cpp @@ -9,6 +9,7 @@ #ifdef HAVE_BENCHMARK #include +#include #include #include @@ -21,220 +22,42 @@ namespace UnitTest class GradientGetValues : public GradientSignalBenchmarkFixture { public: - // We use an enum to list out the different types of GetValue() benchmarks to run so that way we can condense our test cases - // to just take the value in as a benchmark argument and switch on it. Otherwise, we would need to write a different benchmark - // function for each test case for each gradient. - enum GetValuePermutation : int64_t - { - EBUS_GET_VALUE, - EBUS_GET_VALUES, - SAMPLER_GET_VALUE, - SAMPLER_GET_VALUES, - }; - // Create an arbitrary size shape for creating our gradients for benchmark runs. const float TestShapeHalfBounds = 128.0f; - - void FillQueryPositions(AZStd::vector& positions, float height, float width) - { - size_t index = 0; - for (float y = 0.0f; y < height; y += 1.0f) - { - for (float x = 0.0f; x < width; x += 1.0f) - { - positions[index++] = AZ::Vector3(x, y, 0.0f); - } - } - } - - void RunEBusGetValueBenchmark(benchmark::State& state, const AZ::EntityId& gradientId, int64_t queryRange) - { - AZ_PROFILE_FUNCTION(Entity); - - GradientSignal::GradientSampleParams params; - - // Get the height and width ranges for querying from our benchmark parameters - const float height = aznumeric_cast(queryRange); - const float width = aznumeric_cast(queryRange); - - // Call GetValue() on the EBus for every height and width in our ranges. - for (auto _ : state) - { - for (float y = 0.0f; y < height; y += 1.0f) - { - for (float x = 0.0f; x < width; x += 1.0f) - { - float value = 0.0f; - params.m_position = AZ::Vector3(x, y, 0.0f); - GradientSignal::GradientRequestBus::EventResult( - value, gradientId, &GradientSignal::GradientRequestBus::Events::GetValue, params); - benchmark::DoNotOptimize(value); - } - } - } - } - - void RunEBusGetValuesBenchmark(benchmark::State& state, const AZ::EntityId& gradientId, int64_t queryRange) - { - AZ_PROFILE_FUNCTION(Entity); - - // Get the height and width ranges for querying from our benchmark parameters - float height = aznumeric_cast(queryRange); - float width = aznumeric_cast(queryRange); - int64_t totalQueryPoints = queryRange * queryRange; - - // Call GetValues() for every height and width in our ranges. - for (auto _ : state) - { - // Set up our vector of query positions. This is done inside the benchmark timing since we're counting the work to create - // each query position in the single GetValue() call benchmarks, and will make the timing more directly comparable. - AZStd::vector positions(totalQueryPoints); - FillQueryPositions(positions, height, width); - - // Query and get the results. - AZStd::vector results(totalQueryPoints); - GradientSignal::GradientRequestBus::Event( - gradientId, &GradientSignal::GradientRequestBus::Events::GetValues, positions, results); - } - } - - void RunSamplerGetValueBenchmark(benchmark::State& state, const AZ::EntityId& gradientId, int64_t queryRange) - { - AZ_PROFILE_FUNCTION(Entity); - - // Create a gradient sampler to use for querying our gradient. - GradientSignal::GradientSampler gradientSampler; - gradientSampler.m_gradientId = gradientId; - - // Get the height and width ranges for querying from our benchmark parameters - const float height = aznumeric_cast(queryRange); - const float width = aznumeric_cast(queryRange); - - // Call GetValue() through the GradientSampler for every height and width in our ranges. - for (auto _ : state) - { - for (float y = 0.0f; y < height; y += 1.0f) - { - for (float x = 0.0f; x < width; x += 1.0f) - { - GradientSignal::GradientSampleParams params; - params.m_position = AZ::Vector3(x, y, 0.0f); - float value = gradientSampler.GetValue(params); - benchmark::DoNotOptimize(value); - } - } - } - } - - void RunSamplerGetValuesBenchmark(benchmark::State& state, const AZ::EntityId& gradientId, int64_t queryRange) - { - AZ_PROFILE_FUNCTION(Entity); - - // Create a gradient sampler to use for querying our gradient. - GradientSignal::GradientSampler gradientSampler; - gradientSampler.m_gradientId = gradientId; - - // Get the height and width ranges for querying from our benchmark parameters - const float height = aznumeric_cast(queryRange); - const float width = aznumeric_cast(queryRange); - const int64_t totalQueryPoints = queryRange * queryRange; - - // Call GetValues() through the GradientSampler for every height and width in our ranges. - for (auto _ : state) - { - // Set up our vector of query positions. This is done inside the benchmark timing since we're counting the work to create - // each query position in the single GetValue() call benchmarks, and will make the timing more directly comparable. - AZStd::vector positions(totalQueryPoints); - FillQueryPositions(positions, height, width); - - // Query and get the results. - AZStd::vector results(totalQueryPoints); - gradientSampler.GetValues(positions, results); - } - } - - void RunGetValueOrGetValuesBenchmark(benchmark::State& state, const AZ::EntityId& gradientId) - { - switch (state.range(0)) - { - case GetValuePermutation::EBUS_GET_VALUE: - RunEBusGetValueBenchmark(state, gradientId, state.range(1)); - break; - case GetValuePermutation::EBUS_GET_VALUES: - RunEBusGetValuesBenchmark(state, gradientId, state.range(1)); - break; - case GetValuePermutation::SAMPLER_GET_VALUE: - RunSamplerGetValueBenchmark(state, gradientId, state.range(1)); - break; - case GetValuePermutation::SAMPLER_GET_VALUES: - RunSamplerGetValuesBenchmark(state, gradientId, state.range(1)); - break; - default: - AZ_Assert(false, "Benchmark permutation type not supported."); - } - } }; -// Because there's no good way to label different enums in the output results (they just appear as integer values), we work around it by -// registering one set of benchmark runs for each enum value and use ArgNames() to give it a friendly name in the results. -#define GRADIENT_SIGNAL_GET_VALUES_BENCHMARK_REGISTER_F(Fixture, Func) \ - BENCHMARK_REGISTER_F(Fixture, Func) \ - ->Args({ GradientGetValues::GetValuePermutation::EBUS_GET_VALUE, 1024 }) \ - ->Args({ GradientGetValues::GetValuePermutation::EBUS_GET_VALUE, 2048 }) \ - ->Args({ GradientGetValues::GetValuePermutation::EBUS_GET_VALUE, 4096 }) \ - ->ArgNames({ "EbusGetValue", "size" }) \ - ->Unit(::benchmark::kMillisecond); \ - BENCHMARK_REGISTER_F(Fixture, Func) \ - ->Args({ GradientGetValues::GetValuePermutation::EBUS_GET_VALUES, 1024 }) \ - ->Args({ GradientGetValues::GetValuePermutation::EBUS_GET_VALUES, 2048 }) \ - ->Args({ GradientGetValues::GetValuePermutation::EBUS_GET_VALUES, 4096 }) \ - ->ArgNames({ "EbusGetValues", "size" }) \ - ->Unit(::benchmark::kMillisecond); \ - BENCHMARK_REGISTER_F(Fixture, Func) \ - ->Args({ GradientGetValues::GetValuePermutation::SAMPLER_GET_VALUE, 1024 }) \ - ->Args({ GradientGetValues::GetValuePermutation::SAMPLER_GET_VALUE, 2048 }) \ - ->Args({ GradientGetValues::GetValuePermutation::SAMPLER_GET_VALUE, 4096 }) \ - ->ArgNames({ "SamplerGetValue", "size" }) \ - ->Unit(::benchmark::kMillisecond); \ - BENCHMARK_REGISTER_F(Fixture, Func) \ - ->Args({ GradientGetValues::GetValuePermutation::SAMPLER_GET_VALUES, 1024 }) \ - ->Args({ GradientGetValues::GetValuePermutation::SAMPLER_GET_VALUES, 2048 }) \ - ->Args({ GradientGetValues::GetValuePermutation::SAMPLER_GET_VALUES, 4096 }) \ - ->ArgNames({ "SamplerGetValues", "size" }) \ - ->Unit(::benchmark::kMillisecond); - // -------------------------------------------------------------------------------------- // Base Gradients BENCHMARK_DEFINE_F(GradientGetValues, BM_ConstantGradient)(benchmark::State& state) { auto entity = BuildTestConstantGradient(TestShapeHalfBounds); - RunGetValueOrGetValuesBenchmark(state, entity->GetId()); + GradientSignalTestHelpers::RunGetValueOrGetValuesBenchmark(state, entity->GetId()); } BENCHMARK_DEFINE_F(GradientGetValues, BM_ImageGradient)(benchmark::State& state) { auto entity = BuildTestImageGradient(TestShapeHalfBounds); - RunGetValueOrGetValuesBenchmark(state, entity->GetId()); + GradientSignalTestHelpers::RunGetValueOrGetValuesBenchmark(state, entity->GetId()); } BENCHMARK_DEFINE_F(GradientGetValues, BM_PerlinGradient)(benchmark::State& state) { auto entity = BuildTestPerlinGradient(TestShapeHalfBounds); - RunGetValueOrGetValuesBenchmark(state, entity->GetId()); + GradientSignalTestHelpers::RunGetValueOrGetValuesBenchmark(state, entity->GetId()); } BENCHMARK_DEFINE_F(GradientGetValues, BM_RandomGradient)(benchmark::State& state) { auto entity = BuildTestRandomGradient(TestShapeHalfBounds); - RunGetValueOrGetValuesBenchmark(state, entity->GetId()); + GradientSignalTestHelpers::RunGetValueOrGetValuesBenchmark(state, entity->GetId()); } BENCHMARK_DEFINE_F(GradientGetValues, BM_ShapeAreaFalloffGradient)(benchmark::State& state) { auto entity = BuildTestShapeAreaFalloffGradient(TestShapeHalfBounds); - RunGetValueOrGetValuesBenchmark(state, entity->GetId()); + GradientSignalTestHelpers::RunGetValueOrGetValuesBenchmark(state, entity->GetId()); } GRADIENT_SIGNAL_GET_VALUES_BENCHMARK_REGISTER_F(GradientGetValues, BM_ConstantGradient); @@ -250,21 +73,21 @@ namespace UnitTest { auto baseEntity = BuildTestRandomGradient(TestShapeHalfBounds); auto entity = BuildTestDitherGradient(TestShapeHalfBounds, baseEntity->GetId()); - RunGetValueOrGetValuesBenchmark(state, entity->GetId()); + GradientSignalTestHelpers::RunGetValueOrGetValuesBenchmark(state, entity->GetId()); } BENCHMARK_DEFINE_F(GradientGetValues, BM_InvertGradient)(benchmark::State& state) { auto baseEntity = BuildTestRandomGradient(TestShapeHalfBounds); auto entity = BuildTestDitherGradient(TestShapeHalfBounds, baseEntity->GetId()); - RunGetValueOrGetValuesBenchmark(state, entity->GetId()); + GradientSignalTestHelpers::RunGetValueOrGetValuesBenchmark(state, entity->GetId()); } BENCHMARK_DEFINE_F(GradientGetValues, BM_LevelsGradient)(benchmark::State& state) { auto baseEntity = BuildTestRandomGradient(TestShapeHalfBounds); auto entity = BuildTestLevelsGradient(TestShapeHalfBounds, baseEntity->GetId()); - RunGetValueOrGetValuesBenchmark(state, entity->GetId()); + GradientSignalTestHelpers::RunGetValueOrGetValuesBenchmark(state, entity->GetId()); } BENCHMARK_DEFINE_F(GradientGetValues, BM_MixedGradient)(benchmark::State& state) @@ -272,35 +95,35 @@ namespace UnitTest auto baseEntity = BuildTestRandomGradient(TestShapeHalfBounds); auto mixedEntity = BuildTestConstantGradient(TestShapeHalfBounds); auto entity = BuildTestMixedGradient(TestShapeHalfBounds, baseEntity->GetId(), mixedEntity->GetId()); - RunGetValueOrGetValuesBenchmark(state, entity->GetId()); + GradientSignalTestHelpers::RunGetValueOrGetValuesBenchmark(state, entity->GetId()); } BENCHMARK_DEFINE_F(GradientGetValues, BM_PosterizeGradient)(benchmark::State& state) { auto baseEntity = BuildTestRandomGradient(TestShapeHalfBounds); auto entity = BuildTestPosterizeGradient(TestShapeHalfBounds, baseEntity->GetId()); - RunGetValueOrGetValuesBenchmark(state, entity->GetId()); + GradientSignalTestHelpers::RunGetValueOrGetValuesBenchmark(state, entity->GetId()); } BENCHMARK_DEFINE_F(GradientGetValues, BM_ReferenceGradient)(benchmark::State& state) { auto baseEntity = BuildTestRandomGradient(TestShapeHalfBounds); auto entity = BuildTestReferenceGradient(TestShapeHalfBounds, baseEntity->GetId()); - RunGetValueOrGetValuesBenchmark(state, entity->GetId()); + GradientSignalTestHelpers::RunGetValueOrGetValuesBenchmark(state, entity->GetId()); } BENCHMARK_DEFINE_F(GradientGetValues, BM_SmoothStepGradient)(benchmark::State& state) { auto baseEntity = BuildTestRandomGradient(TestShapeHalfBounds); auto entity = BuildTestSmoothStepGradient(TestShapeHalfBounds, baseEntity->GetId()); - RunGetValueOrGetValuesBenchmark(state, entity->GetId()); + GradientSignalTestHelpers::RunGetValueOrGetValuesBenchmark(state, entity->GetId()); } BENCHMARK_DEFINE_F(GradientGetValues, BM_ThresholdGradient)(benchmark::State& state) { auto baseEntity = BuildTestRandomGradient(TestShapeHalfBounds); auto entity = BuildTestThresholdGradient(TestShapeHalfBounds, baseEntity->GetId()); - RunGetValueOrGetValuesBenchmark(state, entity->GetId()); + GradientSignalTestHelpers::RunGetValueOrGetValuesBenchmark(state, entity->GetId()); } GRADIENT_SIGNAL_GET_VALUES_BENCHMARK_REGISTER_F(GradientGetValues, BM_DitherGradient); @@ -321,7 +144,7 @@ namespace UnitTest CreateMockSurfaceDataSystem(AZ::Aabb::CreateFromMinMax(AZ::Vector3(-TestShapeHalfBounds), AZ::Vector3(TestShapeHalfBounds))); auto entity = BuildTestSurfaceAltitudeGradient(TestShapeHalfBounds); - RunGetValueOrGetValuesBenchmark(state, entity->GetId()); + GradientSignalTestHelpers::RunGetValueOrGetValuesBenchmark(state, entity->GetId()); } BENCHMARK_DEFINE_F(GradientGetValues, BM_SurfaceMaskGradient)(benchmark::State& state) @@ -330,7 +153,7 @@ namespace UnitTest CreateMockSurfaceDataSystem(AZ::Aabb::CreateFromMinMax(AZ::Vector3(-TestShapeHalfBounds), AZ::Vector3(TestShapeHalfBounds))); auto entity = BuildTestSurfaceMaskGradient(TestShapeHalfBounds); - RunGetValueOrGetValuesBenchmark(state, entity->GetId()); + GradientSignalTestHelpers::RunGetValueOrGetValuesBenchmark(state, entity->GetId()); } BENCHMARK_DEFINE_F(GradientGetValues, BM_SurfaceSlopeGradient)(benchmark::State& state) @@ -339,7 +162,7 @@ namespace UnitTest CreateMockSurfaceDataSystem(AZ::Aabb::CreateFromMinMax(AZ::Vector3(-TestShapeHalfBounds), AZ::Vector3(TestShapeHalfBounds))); auto entity = BuildTestSurfaceSlopeGradient(TestShapeHalfBounds); - RunGetValueOrGetValuesBenchmark(state, entity->GetId()); + GradientSignalTestHelpers::RunGetValueOrGetValuesBenchmark(state, entity->GetId()); } GRADIENT_SIGNAL_GET_VALUES_BENCHMARK_REGISTER_F(GradientGetValues, BM_SurfaceAltitudeGradient); diff --git a/Gems/GradientSignal/Code/Tests/GradientSignalGetValuesTests.cpp b/Gems/GradientSignal/Code/Tests/GradientSignalGetValuesTests.cpp index 6c4ebcc4c0..f0ad53ee64 100644 --- a/Gems/GradientSignal/Code/Tests/GradientSignalGetValuesTests.cpp +++ b/Gems/GradientSignal/Code/Tests/GradientSignalGetValuesTests.cpp @@ -8,6 +8,7 @@ #include +#include #include namespace UnitTest @@ -18,79 +19,36 @@ namespace UnitTest // Create an arbitrary size shape for comparing values within. It should be large enough that we detect any value anomalies // but small enough that the tests run quickly. const float TestShapeHalfBounds = 128.0f; - - void CompareGetValueAndGetValues(AZ::EntityId gradientEntityId) - { - // Create a gradient sampler and run through a series of points to see if they match expectations. - - const AZ::Aabb queryRegion = AZ::Aabb::CreateFromMinMax(AZ::Vector3(-TestShapeHalfBounds), AZ::Vector3(TestShapeHalfBounds)); - const AZ::Vector2 stepSize(1.0f, 1.0f); - - GradientSignal::GradientSampler gradientSampler; - gradientSampler.m_gradientId = gradientEntityId; - - const size_t numSamplesX = aznumeric_cast(ceil(queryRegion.GetExtents().GetX() / stepSize.GetX())); - const size_t numSamplesY = aznumeric_cast(ceil(queryRegion.GetExtents().GetY() / stepSize.GetY())); - - // Build up the list of positions to query. - AZStd::vector positions(numSamplesX * numSamplesY); - size_t index = 0; - for (size_t yIndex = 0; yIndex < numSamplesY; yIndex++) - { - float y = queryRegion.GetMin().GetY() + (stepSize.GetY() * yIndex); - for (size_t xIndex = 0; xIndex < numSamplesX; xIndex++) - { - float x = queryRegion.GetMin().GetX() + (stepSize.GetX() * xIndex); - positions[index++] = AZ::Vector3(x, y, 0.0f); - } - } - - // Get the results from GetValues - AZStd::vector results(numSamplesX * numSamplesY); - gradientSampler.GetValues(positions, results); - - // For each position, call GetValue and verify that the values match. - for (size_t positionIndex = 0; positionIndex < positions.size(); positionIndex++) - { - GradientSignal::GradientSampleParams params; - params.m_position = positions[positionIndex]; - float value = gradientSampler.GetValue(params); - - // We use ASSERT_NEAR instead of EXPECT_NEAR because if one value doesn't match, they probably all won't, so there's no - // reason to keep running and printing failures for every value. - ASSERT_NEAR(value, results[positionIndex], 0.000001f); - } - } }; TEST_F(GradientSignalGetValuesTestsFixture, ImageGradientComponent_VerifyGetValueAndGetValuesMatch) { auto entity = BuildTestImageGradient(TestShapeHalfBounds); - CompareGetValueAndGetValues(entity->GetId()); + GradientSignalTestHelpers::CompareGetValueAndGetValues(entity->GetId(), TestShapeHalfBounds); } TEST_F(GradientSignalGetValuesTestsFixture, PerlinGradientComponent_VerifyGetValueAndGetValuesMatch) { auto entity = BuildTestPerlinGradient(TestShapeHalfBounds); - CompareGetValueAndGetValues(entity->GetId()); + GradientSignalTestHelpers::CompareGetValueAndGetValues(entity->GetId(), TestShapeHalfBounds); } TEST_F(GradientSignalGetValuesTestsFixture, RandomGradientComponent_VerifyGetValueAndGetValuesMatch) { auto entity = BuildTestRandomGradient(TestShapeHalfBounds); - CompareGetValueAndGetValues(entity->GetId()); + GradientSignalTestHelpers::CompareGetValueAndGetValues(entity->GetId(), TestShapeHalfBounds); } TEST_F(GradientSignalGetValuesTestsFixture, ConstantGradientComponent_VerifyGetValueAndGetValuesMatch) { auto entity = BuildTestConstantGradient(TestShapeHalfBounds); - CompareGetValueAndGetValues(entity->GetId()); + GradientSignalTestHelpers::CompareGetValueAndGetValues(entity->GetId(), TestShapeHalfBounds); } TEST_F(GradientSignalGetValuesTestsFixture, ShapeAreaFalloffGradientComponent_VerifyGetValueAndGetValuesMatch) { auto entity = BuildTestShapeAreaFalloffGradient(TestShapeHalfBounds); - CompareGetValueAndGetValues(entity->GetId()); + GradientSignalTestHelpers::CompareGetValueAndGetValues(entity->GetId(), TestShapeHalfBounds); } TEST_F(GradientSignalGetValuesTestsFixture, DitherGradientComponent_VerifyGetValueAndGetValuesMatch) @@ -98,21 +56,21 @@ namespace UnitTest auto baseEntity = BuildTestRandomGradient(TestShapeHalfBounds); auto entity = BuildTestDitherGradient(TestShapeHalfBounds, baseEntity->GetId()); - CompareGetValueAndGetValues(entity->GetId()); + GradientSignalTestHelpers::CompareGetValueAndGetValues(entity->GetId(), TestShapeHalfBounds); } TEST_F(GradientSignalGetValuesTestsFixture, InvertGradientComponent_VerifyGetValueAndGetValuesMatch) { auto baseEntity = BuildTestRandomGradient(TestShapeHalfBounds); auto entity = BuildTestInvertGradient(TestShapeHalfBounds, baseEntity->GetId()); - CompareGetValueAndGetValues(entity->GetId()); + GradientSignalTestHelpers::CompareGetValueAndGetValues(entity->GetId(), TestShapeHalfBounds); } TEST_F(GradientSignalGetValuesTestsFixture, LevelsGradientComponent_VerifyGetValueAndGetValuesMatch) { auto baseEntity = BuildTestRandomGradient(TestShapeHalfBounds); auto entity = BuildTestLevelsGradient(TestShapeHalfBounds, baseEntity->GetId()); - CompareGetValueAndGetValues(entity->GetId()); + GradientSignalTestHelpers::CompareGetValueAndGetValues(entity->GetId(), TestShapeHalfBounds); } TEST_F(GradientSignalGetValuesTestsFixture, MixedGradientComponent_VerifyGetValueAndGetValuesMatch) @@ -120,35 +78,35 @@ namespace UnitTest auto baseEntity = BuildTestRandomGradient(TestShapeHalfBounds); auto mixedEntity = BuildTestConstantGradient(TestShapeHalfBounds); auto entity = BuildTestMixedGradient(TestShapeHalfBounds, baseEntity->GetId(), mixedEntity->GetId()); - CompareGetValueAndGetValues(entity->GetId()); + GradientSignalTestHelpers::CompareGetValueAndGetValues(entity->GetId(), TestShapeHalfBounds); } TEST_F(GradientSignalGetValuesTestsFixture, PosterizeGradientComponent_VerifyGetValueAndGetValuesMatch) { auto baseEntity = BuildTestRandomGradient(TestShapeHalfBounds); auto entity = BuildTestPosterizeGradient(TestShapeHalfBounds, baseEntity->GetId()); - CompareGetValueAndGetValues(entity->GetId()); + GradientSignalTestHelpers::CompareGetValueAndGetValues(entity->GetId(), TestShapeHalfBounds); } TEST_F(GradientSignalGetValuesTestsFixture, ReferenceGradientComponent_VerifyGetValueAndGetValuesMatch) { auto baseEntity = BuildTestRandomGradient(TestShapeHalfBounds); auto entity = BuildTestReferenceGradient(TestShapeHalfBounds, baseEntity->GetId()); - CompareGetValueAndGetValues(entity->GetId()); + GradientSignalTestHelpers::CompareGetValueAndGetValues(entity->GetId(), TestShapeHalfBounds); } TEST_F(GradientSignalGetValuesTestsFixture, SmoothStepGradientComponent_VerifyGetValueAndGetValuesMatch) { auto baseEntity = BuildTestRandomGradient(TestShapeHalfBounds); auto entity = BuildTestSmoothStepGradient(TestShapeHalfBounds, baseEntity->GetId()); - CompareGetValueAndGetValues(entity->GetId()); + GradientSignalTestHelpers::CompareGetValueAndGetValues(entity->GetId(), TestShapeHalfBounds); } TEST_F(GradientSignalGetValuesTestsFixture, ThresholdGradientComponent_VerifyGetValueAndGetValuesMatch) { auto baseEntity = BuildTestRandomGradient(TestShapeHalfBounds); auto entity = BuildTestThresholdGradient(TestShapeHalfBounds, baseEntity->GetId()); - CompareGetValueAndGetValues(entity->GetId()); + GradientSignalTestHelpers::CompareGetValueAndGetValues(entity->GetId(), TestShapeHalfBounds); } TEST_F(GradientSignalGetValuesTestsFixture, SurfaceAltitudeGradientComponent_VerifyGetValueAndGetValuesMatch) @@ -157,7 +115,7 @@ namespace UnitTest CreateMockSurfaceDataSystem(AZ::Aabb::CreateFromMinMax(AZ::Vector3(-TestShapeHalfBounds), AZ::Vector3(TestShapeHalfBounds))); auto entity = BuildTestSurfaceAltitudeGradient(TestShapeHalfBounds); - CompareGetValueAndGetValues(entity->GetId()); + GradientSignalTestHelpers::CompareGetValueAndGetValues(entity->GetId(), TestShapeHalfBounds); } TEST_F(GradientSignalGetValuesTestsFixture, SurfaceMaskGradientComponent_VerifyGetValueAndGetValuesMatch) @@ -166,7 +124,7 @@ namespace UnitTest CreateMockSurfaceDataSystem(AZ::Aabb::CreateFromMinMax(AZ::Vector3(-TestShapeHalfBounds), AZ::Vector3(TestShapeHalfBounds))); auto entity = BuildTestSurfaceMaskGradient(TestShapeHalfBounds); - CompareGetValueAndGetValues(entity->GetId()); + GradientSignalTestHelpers::CompareGetValueAndGetValues(entity->GetId(), TestShapeHalfBounds); } TEST_F(GradientSignalGetValuesTestsFixture, SurfaceSlopeGradientComponent_VerifyGetValueAndGetValuesMatch) @@ -175,7 +133,7 @@ namespace UnitTest CreateMockSurfaceDataSystem(AZ::Aabb::CreateFromMinMax(AZ::Vector3(-TestShapeHalfBounds), AZ::Vector3(TestShapeHalfBounds))); auto entity = BuildTestSurfaceSlopeGradient(TestShapeHalfBounds); - CompareGetValueAndGetValues(entity->GetId()); + GradientSignalTestHelpers::CompareGetValueAndGetValues(entity->GetId(), TestShapeHalfBounds); } } diff --git a/Gems/GradientSignal/Code/Tests/GradientSignalTestHelpers.cpp b/Gems/GradientSignal/Code/Tests/GradientSignalTestHelpers.cpp new file mode 100644 index 0000000000..46cc3475e8 --- /dev/null +++ b/Gems/GradientSignal/Code/Tests/GradientSignalTestHelpers.cpp @@ -0,0 +1,203 @@ +/* + * Copyright (c) Contributors to the Open 3D Engine Project. + * For complete copyright and license terms please see the LICENSE at the root of this distribution. + * + * SPDX-License-Identifier: Apache-2.0 OR MIT + * + */ + + +#include +#include +#include + +namespace UnitTest +{ + void GradientSignalTestHelpers::CompareGetValueAndGetValues(AZ::EntityId gradientEntityId, float shapeHalfBounds) + { + // Create a gradient sampler and run through a series of points to see if they match expectations. + + const AZ::Aabb queryRegion = AZ::Aabb::CreateFromMinMax(AZ::Vector3(-shapeHalfBounds), AZ::Vector3(shapeHalfBounds)); + const AZ::Vector2 stepSize(1.0f, 1.0f); + + GradientSignal::GradientSampler gradientSampler; + gradientSampler.m_gradientId = gradientEntityId; + + const size_t numSamplesX = aznumeric_cast(ceil(queryRegion.GetExtents().GetX() / stepSize.GetX())); + const size_t numSamplesY = aznumeric_cast(ceil(queryRegion.GetExtents().GetY() / stepSize.GetY())); + + // Build up the list of positions to query. + AZStd::vector positions(numSamplesX * numSamplesY); + size_t index = 0; + for (size_t yIndex = 0; yIndex < numSamplesY; yIndex++) + { + float y = queryRegion.GetMin().GetY() + (stepSize.GetY() * yIndex); + for (size_t xIndex = 0; xIndex < numSamplesX; xIndex++) + { + float x = queryRegion.GetMin().GetX() + (stepSize.GetX() * xIndex); + positions[index++] = AZ::Vector3(x, y, 0.0f); + } + } + + // Get the results from GetValues + AZStd::vector results(numSamplesX * numSamplesY); + gradientSampler.GetValues(positions, results); + + // For each position, call GetValue and verify that the values match. + for (size_t positionIndex = 0; positionIndex < positions.size(); positionIndex++) + { + GradientSignal::GradientSampleParams params; + params.m_position = positions[positionIndex]; + float value = gradientSampler.GetValue(params); + + // We use ASSERT_NEAR instead of EXPECT_NEAR because if one value doesn't match, they probably all won't, so there's no + // reason to keep running and printing failures for every value. + ASSERT_NEAR(value, results[positionIndex], 0.000001f); + } + } + +#ifdef HAVE_BENCHMARK + + void GradientSignalTestHelpers::FillQueryPositions(AZStd::vector& positions, float height, float width) + { + size_t index = 0; + for (float y = 0.0f; y < height; y += 1.0f) + { + for (float x = 0.0f; x < width; x += 1.0f) + { + positions[index++] = AZ::Vector3(x, y, 0.0f); + } + } + } + + void GradientSignalTestHelpers::RunEBusGetValueBenchmark(benchmark::State& state, const AZ::EntityId& gradientId, int64_t queryRange) + { + AZ_PROFILE_FUNCTION(Entity); + + GradientSignal::GradientSampleParams params; + + // Get the height and width ranges for querying from our benchmark parameters + const float height = aznumeric_cast(queryRange); + const float width = aznumeric_cast(queryRange); + + // Call GetValue() on the EBus for every height and width in our ranges. + for (auto _ : state) + { + for (float y = 0.0f; y < height; y += 1.0f) + { + for (float x = 0.0f; x < width; x += 1.0f) + { + float value = 0.0f; + params.m_position = AZ::Vector3(x, y, 0.0f); + GradientSignal::GradientRequestBus::EventResult( + value, gradientId, &GradientSignal::GradientRequestBus::Events::GetValue, params); + benchmark::DoNotOptimize(value); + } + } + } + } + + void GradientSignalTestHelpers::RunEBusGetValuesBenchmark(benchmark::State& state, const AZ::EntityId& gradientId, int64_t queryRange) + { + AZ_PROFILE_FUNCTION(Entity); + + // Get the height and width ranges for querying from our benchmark parameters + float height = aznumeric_cast(queryRange); + float width = aznumeric_cast(queryRange); + int64_t totalQueryPoints = queryRange * queryRange; + + // Call GetValues() for every height and width in our ranges. + for (auto _ : state) + { + // Set up our vector of query positions. This is done inside the benchmark timing since we're counting the work to create + // each query position in the single GetValue() call benchmarks, and will make the timing more directly comparable. + AZStd::vector positions(totalQueryPoints); + FillQueryPositions(positions, height, width); + + // Query and get the results. + AZStd::vector results(totalQueryPoints); + GradientSignal::GradientRequestBus::Event( + gradientId, &GradientSignal::GradientRequestBus::Events::GetValues, positions, results); + } + } + + void GradientSignalTestHelpers::RunSamplerGetValueBenchmark(benchmark::State& state, const AZ::EntityId& gradientId, int64_t queryRange) + { + AZ_PROFILE_FUNCTION(Entity); + + // Create a gradient sampler to use for querying our gradient. + GradientSignal::GradientSampler gradientSampler; + gradientSampler.m_gradientId = gradientId; + + // Get the height and width ranges for querying from our benchmark parameters + const float height = aznumeric_cast(queryRange); + const float width = aznumeric_cast(queryRange); + + // Call GetValue() through the GradientSampler for every height and width in our ranges. + for (auto _ : state) + { + for (float y = 0.0f; y < height; y += 1.0f) + { + for (float x = 0.0f; x < width; x += 1.0f) + { + GradientSignal::GradientSampleParams params; + params.m_position = AZ::Vector3(x, y, 0.0f); + float value = gradientSampler.GetValue(params); + benchmark::DoNotOptimize(value); + } + } + } + } + + void GradientSignalTestHelpers::RunSamplerGetValuesBenchmark( + benchmark::State& state, const AZ::EntityId& gradientId, int64_t queryRange) + { + AZ_PROFILE_FUNCTION(Entity); + + // Create a gradient sampler to use for querying our gradient. + GradientSignal::GradientSampler gradientSampler; + gradientSampler.m_gradientId = gradientId; + + // Get the height and width ranges for querying from our benchmark parameters + const float height = aznumeric_cast(queryRange); + const float width = aznumeric_cast(queryRange); + const int64_t totalQueryPoints = queryRange * queryRange; + + // Call GetValues() through the GradientSampler for every height and width in our ranges. + for (auto _ : state) + { + // Set up our vector of query positions. This is done inside the benchmark timing since we're counting the work to create + // each query position in the single GetValue() call benchmarks, and will make the timing more directly comparable. + AZStd::vector positions(totalQueryPoints); + FillQueryPositions(positions, height, width); + + // Query and get the results. + AZStd::vector results(totalQueryPoints); + gradientSampler.GetValues(positions, results); + } + } + + void GradientSignalTestHelpers::RunGetValueOrGetValuesBenchmark(benchmark::State& state, const AZ::EntityId& gradientId) + { + switch (state.range(0)) + { + case GetValuePermutation::EBUS_GET_VALUE: + RunEBusGetValueBenchmark(state, gradientId, state.range(1)); + break; + case GetValuePermutation::EBUS_GET_VALUES: + RunEBusGetValuesBenchmark(state, gradientId, state.range(1)); + break; + case GetValuePermutation::SAMPLER_GET_VALUE: + RunSamplerGetValueBenchmark(state, gradientId, state.range(1)); + break; + case GetValuePermutation::SAMPLER_GET_VALUES: + RunSamplerGetValuesBenchmark(state, gradientId, state.range(1)); + break; + default: + AZ_Assert(false, "Benchmark permutation type not supported."); + } + } +#endif +} + + diff --git a/Gems/GradientSignal/Code/Tests/GradientSignalTestHelpers.h b/Gems/GradientSignal/Code/Tests/GradientSignalTestHelpers.h new file mode 100644 index 0000000000..8a175939ee --- /dev/null +++ b/Gems/GradientSignal/Code/Tests/GradientSignalTestHelpers.h @@ -0,0 +1,76 @@ +/* + * Copyright (c) Contributors to the Open 3D Engine Project. + * For complete copyright and license terms please see the LICENSE at the root of this distribution. + * + * SPDX-License-Identifier: Apache-2.0 OR MIT + * + */ +#pragma once + +#include +#include +#include +#include + +namespace UnitTest +{ + class GradientSignalTestHelpers + { + public: + static void CompareGetValueAndGetValues(AZ::EntityId gradientEntityId, float shapeHalfBounds); + +#ifdef HAVE_BENCHMARK + // We use an enum to list out the different types of GetValue() benchmarks to run so that way we can condense our test cases + // to just take the value in as a benchmark argument and switch on it. Otherwise, we would need to write a different benchmark + // function for each test case for each gradient. + enum GetValuePermutation : int64_t + { + EBUS_GET_VALUE, + EBUS_GET_VALUES, + SAMPLER_GET_VALUE, + SAMPLER_GET_VALUES, + }; + + static void FillQueryPositions(AZStd::vector& positions, float height, float width); + + static void RunEBusGetValueBenchmark(benchmark::State& state, const AZ::EntityId& gradientId, int64_t queryRange); + static void RunEBusGetValuesBenchmark(benchmark::State& state, const AZ::EntityId& gradientId, int64_t queryRange); + static void RunSamplerGetValueBenchmark(benchmark::State& state, const AZ::EntityId& gradientId, int64_t queryRange); + static void RunSamplerGetValuesBenchmark(benchmark::State& state, const AZ::EntityId& gradientId, int64_t queryRange); + static void RunGetValueOrGetValuesBenchmark(benchmark::State& state, const AZ::EntityId& gradientId); + +// Because there's no good way to label different enums in the output results (they just appear as integer values), we work around it by +// registering one set of benchmark runs for each enum value and use ArgNames() to give it a friendly name in the results. +#ifndef GRADIENT_SIGNAL_GET_VALUES_BENCHMARK_REGISTER_F +#define GRADIENT_SIGNAL_GET_VALUES_BENCHMARK_REGISTER_F(Fixture, Func) \ + BENCHMARK_REGISTER_F(Fixture, Func) \ + ->Args({ GradientSignalTestHelpers::GetValuePermutation::EBUS_GET_VALUE, 1024 }) \ + ->Args({ GradientSignalTestHelpers::GetValuePermutation::EBUS_GET_VALUE, 2048 }) \ + ->Args({ GradientSignalTestHelpers::GetValuePermutation::EBUS_GET_VALUE, 4096 }) \ + ->ArgNames({ "EbusGetValue", "size" }) \ + ->Unit(::benchmark::kMillisecond); \ + BENCHMARK_REGISTER_F(Fixture, Func) \ + ->Args({ GradientSignalTestHelpers::GetValuePermutation::EBUS_GET_VALUES, 1024 }) \ + ->Args({ GradientSignalTestHelpers::GetValuePermutation::EBUS_GET_VALUES, 2048 }) \ + ->Args({ GradientSignalTestHelpers::GetValuePermutation::EBUS_GET_VALUES, 4096 }) \ + ->ArgNames({ "EbusGetValues", "size" }) \ + ->Unit(::benchmark::kMillisecond); \ + BENCHMARK_REGISTER_F(Fixture, Func) \ + ->Args({ GradientSignalTestHelpers::GetValuePermutation::SAMPLER_GET_VALUE, 1024 }) \ + ->Args({ GradientSignalTestHelpers::GetValuePermutation::SAMPLER_GET_VALUE, 2048 }) \ + ->Args({ GradientSignalTestHelpers::GetValuePermutation::SAMPLER_GET_VALUE, 4096 }) \ + ->ArgNames({ "SamplerGetValue", "size" }) \ + ->Unit(::benchmark::kMillisecond); \ + BENCHMARK_REGISTER_F(Fixture, Func) \ + ->Args({ GradientSignalTestHelpers::GetValuePermutation::SAMPLER_GET_VALUES, 1024 }) \ + ->Args({ GradientSignalTestHelpers::GetValuePermutation::SAMPLER_GET_VALUES, 2048 }) \ + ->Args({ GradientSignalTestHelpers::GetValuePermutation::SAMPLER_GET_VALUES, 4096 }) \ + ->ArgNames({ "SamplerGetValues", "size" }) \ + ->Unit(::benchmark::kMillisecond); +#endif + +#endif + }; + + +} diff --git a/Gems/GradientSignal/Code/gradientsignal_shared_tests_files.cmake b/Gems/GradientSignal/Code/gradientsignal_shared_tests_files.cmake index 7d867b0a33..98ab57b7b0 100644 --- a/Gems/GradientSignal/Code/gradientsignal_shared_tests_files.cmake +++ b/Gems/GradientSignal/Code/gradientsignal_shared_tests_files.cmake @@ -7,6 +7,8 @@ # set(FILES + Tests/GradientSignalTestHelpers.cpp + Tests/GradientSignalTestHelpers.h Tests/GradientSignalTestFixtures.cpp Tests/GradientSignalTestFixtures.h Tests/GradientSignalTestMocks.cpp From 63d755b8f152bf062952bb7527de2bbb357441f9 Mon Sep 17 00:00:00 2001 From: AMZN-byrcolin <68035668+byrcolin@users.noreply.github.com> Date: Wed, 19 Jan 2022 17:09:40 -0800 Subject: [PATCH 6/7] fix launcher not showing gems (#7015) Signed-off-by: byrcolin --- Code/Tools/ProjectManager/Source/PythonBindings.cpp | 4 ++-- Gems/Atom/Asset/ImageProcessingAtom/gem.json | 2 +- Gems/Atom/Bootstrap/gem.json | 2 +- Gems/Atom/Component/DebugCamera/gem.json | 2 +- Gems/Atom/Feature/Common/gem.json | 2 +- Gems/Atom/RHI/DX12/gem.json | 2 +- Gems/Atom/RHI/Metal/gem.json | 2 +- Gems/Atom/RHI/Null/gem.json | 2 +- Gems/Atom/RHI/Vulkan/gem.json | 2 +- Gems/Atom/RHI/gem.json | 2 +- Gems/Atom/RPI/gem.json | 2 +- Gems/Atom/Tools/AtomToolsFramework/gem.json | 2 +- Gems/AtomLyIntegration/AtomBridge/gem.json | 2 +- Gems/AtomLyIntegration/AtomFont/gem.json | 2 +- Gems/AtomLyIntegration/AtomImGuiTools/gem.json | 2 +- Gems/AtomLyIntegration/AtomViewportDisplayIcons/gem.json | 2 +- Gems/AtomLyIntegration/AtomViewportDisplayInfo/gem.json | 2 +- Gems/AtomLyIntegration/CommonFeatures/gem.json | 2 +- Gems/AtomLyIntegration/EMotionFXAtom/gem.json | 2 +- Gems/AtomLyIntegration/ImguiAtom/gem.json | 2 +- 20 files changed, 21 insertions(+), 21 deletions(-) diff --git a/Code/Tools/ProjectManager/Source/PythonBindings.cpp b/Code/Tools/ProjectManager/Source/PythonBindings.cpp index 7c436a3a70..60959d4090 100644 --- a/Code/Tools/ProjectManager/Source/PythonBindings.cpp +++ b/Code/Tools/ProjectManager/Source/PythonBindings.cpp @@ -408,7 +408,7 @@ namespace O3DE::ProjectManager } // check if engine path is registered - auto allEngines = m_manifest.attr("get_engines")(); + auto allEngines = m_manifest.attr("get_manifest_engines")(); if (pybind11::isinstance(allEngines)) { const AZ::IO::FixedMaxPath enginePathFixed(Py_To_String(enginePath)); @@ -891,7 +891,7 @@ namespace O3DE::ProjectManager bool result = ExecuteWithLock([&] { // external projects - for (auto path : m_manifest.attr("get_projects")()) + for (auto path : m_manifest.attr("get_manifest_projects")()) { projects.push_back(ProjectInfoFromPath(path)); } diff --git a/Gems/Atom/Asset/ImageProcessingAtom/gem.json b/Gems/Atom/Asset/ImageProcessingAtom/gem.json index c2af4b7e7e..baa46268b3 100644 --- a/Gems/Atom/Asset/ImageProcessingAtom/gem.json +++ b/Gems/Atom/Asset/ImageProcessingAtom/gem.json @@ -6,7 +6,7 @@ "origin": "Open 3D Engine - o3de.org", "origin_url": "https://github.com/o3de/o3de", "type": "Code", - "summary": "", + "summary": "Image processing for Atom", "canonical_tags": [ "Gem" ], diff --git a/Gems/Atom/Bootstrap/gem.json b/Gems/Atom/Bootstrap/gem.json index 543efe0f34..726021235f 100644 --- a/Gems/Atom/Bootstrap/gem.json +++ b/Gems/Atom/Bootstrap/gem.json @@ -6,7 +6,7 @@ "origin": "Open 3D Engine - o3de.org", "origin_url": "https://github.com/o3de/o3de", "type": "Code", - "summary": "", + "summary": "Atom Bootstrap", "canonical_tags": [ "Gem" ], diff --git a/Gems/Atom/Component/DebugCamera/gem.json b/Gems/Atom/Component/DebugCamera/gem.json index 74d88a21b6..678cce3045 100644 --- a/Gems/Atom/Component/DebugCamera/gem.json +++ b/Gems/Atom/Component/DebugCamera/gem.json @@ -6,7 +6,7 @@ "origin": "Open 3D Engine - o3de.org", "origin_url": "https://github.com/o3de/o3de", "type": "Code", - "summary": "", + "summary": "Debug Camera component for Atom", "canonical_tags": [ "Gem" ], diff --git a/Gems/Atom/Feature/Common/gem.json b/Gems/Atom/Feature/Common/gem.json index f4c936dc4a..d915c55b1d 100644 --- a/Gems/Atom/Feature/Common/gem.json +++ b/Gems/Atom/Feature/Common/gem.json @@ -6,7 +6,7 @@ "origin": "Open 3D Engine - o3de.org", "origin_url": "https://github.com/o3de/o3de", "type": "Code", - "summary": "", + "summary": "Common features for Atom", "canonical_tags": [ "Gem" ], diff --git a/Gems/Atom/RHI/DX12/gem.json b/Gems/Atom/RHI/DX12/gem.json index 803ae4f4d0..67d91790a9 100644 --- a/Gems/Atom/RHI/DX12/gem.json +++ b/Gems/Atom/RHI/DX12/gem.json @@ -6,7 +6,7 @@ "origin": "Open 3D Engine - o3de.org", "origin_url": "https://github.com/o3de/o3de", "type": "Code", - "summary": "", + "summary": "DX12 RHI for Atom", "canonical_tags": [ "Gem" ], diff --git a/Gems/Atom/RHI/Metal/gem.json b/Gems/Atom/RHI/Metal/gem.json index 0257048bd3..555b86523c 100644 --- a/Gems/Atom/RHI/Metal/gem.json +++ b/Gems/Atom/RHI/Metal/gem.json @@ -6,7 +6,7 @@ "origin": "Open 3D Engine - o3de.org", "origin_url": "https://github.com/o3de/o3de", "type": "Code", - "summary": "", + "summary": "Metal RHI for Atom", "canonical_tags": [ "Gem" ], diff --git a/Gems/Atom/RHI/Null/gem.json b/Gems/Atom/RHI/Null/gem.json index 1ea2eb4cb0..d531aa4ab5 100644 --- a/Gems/Atom/RHI/Null/gem.json +++ b/Gems/Atom/RHI/Null/gem.json @@ -6,7 +6,7 @@ "origin": "Open 3D Engine - o3de.org", "origin_url": "https://github.com/o3de/o3de", "type": "Code", - "summary": "", + "summary": "Atom Null RHI", "canonical_tags": [ "Gem" ], diff --git a/Gems/Atom/RHI/Vulkan/gem.json b/Gems/Atom/RHI/Vulkan/gem.json index 508ad85c75..5d49085ac5 100644 --- a/Gems/Atom/RHI/Vulkan/gem.json +++ b/Gems/Atom/RHI/Vulkan/gem.json @@ -6,7 +6,7 @@ "origin": "Open 3D Engine - o3de.org", "origin_url": "https://github.com/o3de/o3de", "type": "Code", - "summary": "", + "summary": "Vulcan RHI for Atom", "canonical_tags": [ "Gem" ], diff --git a/Gems/Atom/RHI/gem.json b/Gems/Atom/RHI/gem.json index 858a64fc17..49ec18ea53 100644 --- a/Gems/Atom/RHI/gem.json +++ b/Gems/Atom/RHI/gem.json @@ -6,7 +6,7 @@ "origin": "Open 3D Engine - o3de.org", "origin_url": "https://github.com/o3de/o3de", "type": "Code", - "summary": "", + "summary": "RHI for Atom", "canonical_tags": [ "Gem" ], diff --git a/Gems/Atom/RPI/gem.json b/Gems/Atom/RPI/gem.json index 0acef5179b..fe135c3e90 100644 --- a/Gems/Atom/RPI/gem.json +++ b/Gems/Atom/RPI/gem.json @@ -6,7 +6,7 @@ "origin": "Open 3D Engine - o3de.org", "origin_url": "https://github.com/o3de/o3de", "type": "Code", - "summary": "", + "summary": "RPI for Atom", "canonical_tags": [ "Gem" ], diff --git a/Gems/Atom/Tools/AtomToolsFramework/gem.json b/Gems/Atom/Tools/AtomToolsFramework/gem.json index 6e5a7b311a..a86244e7cc 100644 --- a/Gems/Atom/Tools/AtomToolsFramework/gem.json +++ b/Gems/Atom/Tools/AtomToolsFramework/gem.json @@ -6,7 +6,7 @@ "origin": "Open 3D Engine - o3de.org", "origin_url": "https://github.com/o3de/o3de", "type": "Code", - "summary": "", + "summary": "Tools Framework for Atom", "canonical_tags": [ "Gem" ], diff --git a/Gems/AtomLyIntegration/AtomBridge/gem.json b/Gems/AtomLyIntegration/AtomBridge/gem.json index 5a8512c90d..87a10aa6d3 100644 --- a/Gems/AtomLyIntegration/AtomBridge/gem.json +++ b/Gems/AtomLyIntegration/AtomBridge/gem.json @@ -6,7 +6,7 @@ "origin": "Open 3D Engine - o3de.org", "origin_url": "https://github.com/o3de/o3de", "type": "Code", - "summary": "", + "summary": "Atom Bridge", "canonical_tags": [ "Gem" ], diff --git a/Gems/AtomLyIntegration/AtomFont/gem.json b/Gems/AtomLyIntegration/AtomFont/gem.json index d979509059..4f5ba75ff2 100644 --- a/Gems/AtomLyIntegration/AtomFont/gem.json +++ b/Gems/AtomLyIntegration/AtomFont/gem.json @@ -6,7 +6,7 @@ "origin": "Open 3D Engine - o3de.org", "origin_url": "https://github.com/o3de/o3de", "type": "Code", - "summary": "", + "summary": "Font Rendering for Atom", "canonical_tags": [ "Gem" ], diff --git a/Gems/AtomLyIntegration/AtomImGuiTools/gem.json b/Gems/AtomLyIntegration/AtomImGuiTools/gem.json index 205120f6f0..2ae8edfa57 100644 --- a/Gems/AtomLyIntegration/AtomImGuiTools/gem.json +++ b/Gems/AtomLyIntegration/AtomImGuiTools/gem.json @@ -6,7 +6,7 @@ "origin": "Open 3D Engine - o3de.org", "origin_url": "https://github.com/o3de/o3de", "type": "Tool", - "summary": "", + "summary": "ImGui tools for Atom", "canonical_tags": [ "Gem" ], diff --git a/Gems/AtomLyIntegration/AtomViewportDisplayIcons/gem.json b/Gems/AtomLyIntegration/AtomViewportDisplayIcons/gem.json index cff957c1f1..a7b9dab980 100644 --- a/Gems/AtomLyIntegration/AtomViewportDisplayIcons/gem.json +++ b/Gems/AtomLyIntegration/AtomViewportDisplayIcons/gem.json @@ -6,7 +6,7 @@ "origin": "Open 3D Engine - o3de.org", "origin_url": "https://github.com/o3de/o3de", "type": "Code", - "summary": "", + "summary": "Viewport display icons for Atom", "canonical_tags": [ "Gem" ], diff --git a/Gems/AtomLyIntegration/AtomViewportDisplayInfo/gem.json b/Gems/AtomLyIntegration/AtomViewportDisplayInfo/gem.json index a2bc92c76d..0deeeef602 100644 --- a/Gems/AtomLyIntegration/AtomViewportDisplayInfo/gem.json +++ b/Gems/AtomLyIntegration/AtomViewportDisplayInfo/gem.json @@ -6,7 +6,7 @@ "origin": "Open 3D Engine - o3de.org", "origin_url": "https://github.com/o3de/o3de", "type": "Code", - "summary": "", + "summary": "Viewport Display Information for Atom", "canonical_tags": [ "Gem" ], diff --git a/Gems/AtomLyIntegration/CommonFeatures/gem.json b/Gems/AtomLyIntegration/CommonFeatures/gem.json index a06f607fab..b6290679b9 100644 --- a/Gems/AtomLyIntegration/CommonFeatures/gem.json +++ b/Gems/AtomLyIntegration/CommonFeatures/gem.json @@ -6,7 +6,7 @@ "origin": "Open 3D Engine - o3de.org", "origin_url": "https://github.com/o3de/o3de", "type": "Code", - "summary": "", + "summary": "Common features for Atom", "canonical_tags": [ "Gem" ], diff --git a/Gems/AtomLyIntegration/EMotionFXAtom/gem.json b/Gems/AtomLyIntegration/EMotionFXAtom/gem.json index 8bea93da91..3847432cf7 100644 --- a/Gems/AtomLyIntegration/EMotionFXAtom/gem.json +++ b/Gems/AtomLyIntegration/EMotionFXAtom/gem.json @@ -6,7 +6,7 @@ "origin": "Open 3D Engine - o3de.org", "origin_url": "https://github.com/o3de/o3de", "type": "Code", - "summary": "", + "summary": "EmotionFX for Atom", "canonical_tags": [ "Gem" ], diff --git a/Gems/AtomLyIntegration/ImguiAtom/gem.json b/Gems/AtomLyIntegration/ImguiAtom/gem.json index 4c65d80e33..70ff1c0414 100644 --- a/Gems/AtomLyIntegration/ImguiAtom/gem.json +++ b/Gems/AtomLyIntegration/ImguiAtom/gem.json @@ -6,7 +6,7 @@ "origin": "Open 3D Engine - o3de.org", "origin_url": "https://github.com/o3de/o3de", "type": "Code", - "summary": "", + "summary": "ImGui support for Atom", "canonical_tags": [ "Gem" ], From e1b245859140d8625e163da5181e39390dc6520f Mon Sep 17 00:00:00 2001 From: Ignacio Martinez <82394219+AMZN-Igarri@users.noreply.github.com> Date: Thu, 20 Jan 2022 14:09:00 +0100 Subject: [PATCH 7/7] Asset Browser Collapse All Fix (#6996) * Added Icon Signed-off-by: AMZN-Igarri <82394219+AMZN-Igarri@users.noreply.github.com> * Fixed indent in ui file Signed-off-by: AMZN-Igarri <82394219+AMZN-Igarri@users.noreply.github.com> --- .../Icons/AssetBrowser/Collapse_All.svg | 14 +++++++++++ .../AzAssetBrowser/AzAssetBrowserWindow.cpp | 22 +++++++++++++++- .../AzAssetBrowser/AzAssetBrowserWindow.ui | 25 ++++++++++++------- 3 files changed, 51 insertions(+), 10 deletions(-) create mode 100644 Assets/Editor/Icons/AssetBrowser/Collapse_All.svg diff --git a/Assets/Editor/Icons/AssetBrowser/Collapse_All.svg b/Assets/Editor/Icons/AssetBrowser/Collapse_All.svg new file mode 100644 index 0000000000..7c7a7b85bd --- /dev/null +++ b/Assets/Editor/Icons/AssetBrowser/Collapse_All.svg @@ -0,0 +1,14 @@ + + + + + + + + diff --git a/Code/Editor/AzAssetBrowser/AzAssetBrowserWindow.cpp b/Code/Editor/AzAssetBrowser/AzAssetBrowserWindow.cpp index a7faea36f6..36e08982a7 100644 --- a/Code/Editor/AzAssetBrowser/AzAssetBrowserWindow.cpp +++ b/Code/Editor/AzAssetBrowser/AzAssetBrowserWindow.cpp @@ -32,6 +32,15 @@ AZ_POP_DISABLE_DLL_EXPORT_MEMBER_WARNING AZ_CVAR_EXTERNED(bool, ed_useNewAssetBrowserTableView); +namespace AzToolsFramework +{ + namespace AssetBrowser + { + static constexpr const char* CollapseAllIcon = "Assets/Editor/Icons/AssetBrowser/Collapse_All.svg"; + static constexpr const char* MenuIcon = ":/Menu/menu.svg"; + } // namespace AssetBrowser +} // namespace AzToolsFramework + class ListenerForShowAssetEditorEvent : public QObject , private AzToolsFramework::EditorEvents::Bus::Handler @@ -87,10 +96,21 @@ AzAssetBrowserWindow::AzAssetBrowserWindow(QWidget* parent) m_assetBrowserModel->SetFilterModel(m_filterModel.data()); + m_ui->m_collapseAllButton->setAutoRaise(true); // hover highlight + m_ui->m_collapseAllButton->setIcon(QIcon(AzAssetBrowser::CollapseAllIcon)); + + connect( + m_ui->m_collapseAllButton, &QToolButton::clicked, this, + [this]() + { + m_ui->m_assetBrowserTreeViewWidget->collapseAll(); + }); + if (ed_useNewAssetBrowserTableView) { m_ui->m_toggleDisplayViewBtn->setVisible(true); - m_ui->m_toggleDisplayViewBtn->setIcon(QIcon(":/Menu/menu.svg")); + m_ui->m_toggleDisplayViewBtn->setAutoRaise(true); + m_ui->m_toggleDisplayViewBtn->setIcon(QIcon(AzAssetBrowser::MenuIcon)); m_tableModel->setFilterRole(Qt::DisplayRole); m_tableModel->setSourceModel(m_filterModel.data()); diff --git a/Code/Editor/AzAssetBrowser/AzAssetBrowserWindow.ui b/Code/Editor/AzAssetBrowser/AzAssetBrowserWindow.ui index a345438aed..2cc7c57ccd 100644 --- a/Code/Editor/AzAssetBrowser/AzAssetBrowserWindow.ui +++ b/Code/Editor/AzAssetBrowser/AzAssetBrowserWindow.ui @@ -72,6 +72,22 @@ + + + + Qt::ClickFocus + + + + + + 3 + + + + + + @@ -143,15 +159,6 @@ true - - false - - - true - - - false -