diff --git a/AutomatedTesting/Assets/Destruction/cinder_wall_complex.blast b/AutomatedTesting/Assets/Destruction/cinder_wall_complex.blast new file mode 100644 index 0000000000..fcf67594c7 Binary files /dev/null and b/AutomatedTesting/Assets/Destruction/cinder_wall_complex.blast differ diff --git a/AutomatedTesting/Assets/Destruction/cinder_wall_complex.fbx b/AutomatedTesting/Assets/Destruction/cinder_wall_complex.fbx new file mode 100644 index 0000000000..62c305c35e --- /dev/null +++ b/AutomatedTesting/Assets/Destruction/cinder_wall_complex.fbx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7f94f2634eacb4d7bee20dacc45edef96e4d268f1adb7960b8aa8f3b6e2906ed +size 6867609 diff --git a/AutomatedTesting/Assets/Prefabs/Bush.prefab b/AutomatedTesting/Assets/Prefabs/Bush.prefab new file mode 100644 index 0000000000..ef497bdcd0 --- /dev/null +++ b/AutomatedTesting/Assets/Prefabs/Bush.prefab @@ -0,0 +1,129 @@ +{ + "ContainerEntity": { + "Id": "ContainerEntity", + "Name": "Bush", + "Components": { + "Component_[1140272189295067758]": { + "$type": "EditorInspectorComponent", + "Id": 1140272189295067758 + }, + "Component_[13437832196484687256]": { + "$type": "EditorOnlyEntityComponent", + "Id": 13437832196484687256 + }, + "Component_[1553903646452669645]": { + "$type": "EditorDisabledCompositionComponent", + "Id": 1553903646452669645 + }, + "Component_[15914009348632444632]": { + "$type": "EditorEntitySortComponent", + "Id": 15914009348632444632, + "Child Entity Order": [ + "Entity_[7511491868318]" + ] + }, + "Component_[18046340308818780248]": { + "$type": "EditorPrefabComponent", + "Id": 18046340308818780248 + }, + "Component_[1948833233489872938]": { + "$type": "{27F1E1A1-8D9D-4C3B-BD3A-AFB9762449C0} TransformComponent", + "Id": 1948833233489872938, + "Parent Entity": "" + }, + "Component_[2903632350157981339]": { + "$type": "SelectionComponent", + "Id": 2903632350157981339 + }, + "Component_[48827510535192710]": { + "$type": "EditorPendingCompositionComponent", + "Id": 48827510535192710 + }, + "Component_[5609536793322429681]": { + "$type": "EditorLockComponent", + "Id": 5609536793322429681 + }, + "Component_[5859168386298620990]": { + "$type": "EditorEntityIconComponent", + "Id": 5859168386298620990 + }, + "Component_[6604616929271524505]": { + "$type": "EditorVisibilityComponent", + "Id": 6604616929271524505 + } + } + }, + "Entities": { + "Entity_[7511491868318]": { + "Id": "Entity_[7511491868318]", + "Name": "Bush", + "Components": { + "Component_[10227459330338484901]": { + "$type": "EditorInspectorComponent", + "Id": 10227459330338484901, + "ComponentOrderEntryArray": [ + { + "ComponentId": 4998941225335869157 + }, + { + "ComponentId": 9922994635792843826, + "SortIndex": 1 + } + ] + }, + "Component_[10972351222359420947]": { + "$type": "EditorOnlyEntityComponent", + "Id": 10972351222359420947 + }, + "Component_[12101122374155214392]": { + "$type": "EditorPendingCompositionComponent", + "Id": 12101122374155214392 + }, + "Component_[1535264614652988260]": { + "$type": "SelectionComponent", + "Id": 1535264614652988260 + }, + "Component_[16367811417907891218]": { + "$type": "EditorVisibilityComponent", + "Id": 16367811417907891218 + }, + "Component_[17044216787716682880]": { + "$type": "EditorEntitySortComponent", + "Id": 17044216787716682880 + }, + "Component_[2129822594969629430]": { + "$type": "EditorEntityIconComponent", + "Id": 2129822594969629430 + }, + "Component_[2838015156782745450]": { + "$type": "EditorLockComponent", + "Id": 2838015156782745450 + }, + "Component_[4998941225335869157]": { + "$type": "{27F1E1A1-8D9D-4C3B-BD3A-AFB9762449C0} TransformComponent", + "Id": 4998941225335869157, + "Parent Entity": "ContainerEntity" + }, + "Component_[8773358049076362578]": { + "$type": "EditorDisabledCompositionComponent", + "Id": 8773358049076362578 + }, + "Component_[9922994635792843826]": { + "$type": "AZ::Render::EditorMeshComponent", + "Id": 9922994635792843826, + "Controller": { + "Configuration": { + "ModelAsset": { + "assetId": { + "guid": "{1201406D-FB20-5B5F-B9B5-6A6E8DE00A14}", + "subId": 276506120 + }, + "assetHint": "assets/objects/foliage/bush_privet_01.azmodel" + } + } + } + } + } + } + } +} \ No newline at end of file diff --git a/AutomatedTesting/Assets/Prefabs/BushFlowerBlender.prefab b/AutomatedTesting/Assets/Prefabs/BushFlowerBlender.prefab new file mode 100644 index 0000000000..b938701b6a --- /dev/null +++ b/AutomatedTesting/Assets/Prefabs/BushFlowerBlender.prefab @@ -0,0 +1,2249 @@ +{ + "ContainerEntity": { + "Id": "ContainerEntity", + "Name": "BushFlowerBlender", + "Components": { + "Component_[10351434005293588180]": { + "$type": "EditorLockComponent", + "Id": 10351434005293588180 + }, + "Component_[10967554916960846519]": { + "$type": "EditorOnlyEntityComponent", + "Id": 10967554916960846519 + }, + "Component_[14400678265986305456]": { + "$type": "EditorEntityIconComponent", + "Id": 14400678265986305456 + }, + "Component_[15365520792759708998]": { + "$type": "EditorDisabledCompositionComponent", + "Id": 15365520792759708998 + }, + "Component_[16281192066639198814]": { + "$type": "EditorEntitySortComponent", + "Id": 16281192066639198814, + "Child Entity Order": [ + "Entity_[263598916892318]" + ] + }, + "Component_[16356049875968660722]": { + "$type": "{27F1E1A1-8D9D-4C3B-BD3A-AFB9762449C0} TransformComponent", + "Id": 16356049875968660722, + "Parent Entity": "" + }, + "Component_[16391695178646515457]": { + "$type": "SelectionComponent", + "Id": 16391695178646515457 + }, + "Component_[16407238476365087382]": { + "$type": "EditorVisibilityComponent", + "Id": 16407238476365087382 + }, + "Component_[3542701736829700396]": { + "$type": "EditorPendingCompositionComponent", + "Id": 3542701736829700396 + }, + "Component_[5160094530340900971]": { + "$type": "EditorInspectorComponent", + "Id": 5160094530340900971 + }, + "Component_[6432428663776737136]": { + "$type": "EditorPrefabComponent", + "Id": 6432428663776737136 + } + } + }, + "Entities": { + "Entity_[263573147088542]": { + "Id": "Entity_[263573147088542]", + "Name": "BushSpawner", + "Components": { + "Component_[11886309121583108836]": { + "$type": "EditorPositionModifierComponent", + "Id": 11886309121583108836, + "Configuration": { + "GradientX": { + "GradientId": "Entity_[263590326957726]" + }, + "GradientY": { + "GradientId": "Entity_[263590326957726]" + }, + "GradientZ": { + "GradientId": "" + } + } + }, + "Component_[1240444912193942742]": { + "$type": "{DD96FD51-A86B-48BC-A6AB-89183B538269} EditorSpawnerComponent", + "Id": 1240444912193942742, + "PreviewEntity": "Entity_[263573147088542]" + }, + "Component_[12813702285187817973]": { + "$type": "EditorInspectorComponent", + "Id": 12813702285187817973, + "ComponentOrderEntryArray": [ + { + "ComponentId": 18133156195370267728 + }, + { + "ComponentId": 13450250419263773680, + "SortIndex": 1 + }, + { + "ComponentId": 8841963751527151666, + "SortIndex": 2 + }, + { + "ComponentId": 1240444912193942742, + "SortIndex": 3 + }, + { + "ComponentId": 17991239182321715249, + "SortIndex": 4 + }, + { + "ComponentId": 14175761523159824993, + "SortIndex": 5 + }, + { + "ComponentId": 2884829698060689565, + "SortIndex": 6 + }, + { + "ComponentId": 11886309121583108836, + "SortIndex": 7 + } + ] + }, + "Component_[13179606361687972691]": { + "$type": "EditorEntityIconComponent", + "Id": 13179606361687972691 + }, + "Component_[13450250419263773680]": { + "$type": "EditorReferenceShapeComponent", + "Id": 13450250419263773680, + "Configuration": { + "ShapeEntityId": "Entity_[263607506826910]" + } + }, + "Component_[13688014277574607552]": { + "$type": "EditorOnlyEntityComponent", + "Id": 13688014277574607552 + }, + "Component_[14175761523159824993]": { + "$type": "EditorDistributionFilterComponent", + "Id": 14175761523159824993, + "Configuration": { + "ThresholdMin": 0.289000004529953, + "ThresholdMax": 0.5690000057220459, + "Gradient": { + "GradientId": "Entity_[263603211859614]" + } + } + }, + "Component_[14232774271081092639]": { + "$type": "EditorLockComponent", + "Id": 14232774271081092639 + }, + "Component_[14811533745267383811]": { + "$type": "EditorDisabledCompositionComponent", + "Id": 14811533745267383811 + }, + "Component_[17540078415915694273]": { + "$type": "EditorVisibilityComponent", + "Id": 17540078415915694273 + }, + "Component_[17991239182321715249]": { + "$type": "EditorRotationModifierComponent", + "Id": 17991239182321715249, + "Configuration": { + "GradientX": { + "GradientId": "" + }, + "GradientY": { + "GradientId": "" + }, + "GradientZ": { + "GradientId": "Entity_[263590326957726]" + } + } + }, + "Component_[18133156195370267728]": { + "$type": "{27F1E1A1-8D9D-4C3B-BD3A-AFB9762449C0} TransformComponent", + "Id": 18133156195370267728, + "Parent Entity": "Entity_[263607506826910]" + }, + "Component_[2884829698060689565]": { + "$type": "EditorScaleModifierComponent", + "Id": 2884829698060689565, + "Configuration": { + "RangeMin": 0.75, + "RangeMax": 1.25, + "Gradient": { + "GradientId": "Entity_[263590326957726]" + } + } + }, + "Component_[50628676751372416]": { + "$type": "EditorEntitySortComponent", + "Id": 50628676751372416, + "Child Entity Order": [ + "Entity_[263603211859614]", + "Entity_[263590326957726]" + ] + }, + "Component_[5689270312836823309]": { + "$type": "SelectionComponent", + "Id": 5689270312836823309 + }, + "Component_[7105803915999711758]": { + "$type": "EditorPendingCompositionComponent", + "Id": 7105803915999711758 + }, + "Component_[8841963751527151666]": { + "$type": "EditorDescriptorListComponent", + "Id": 8841963751527151666, + "Configuration": { + "Descriptors": [ + { + "SpawnerType": "{74BEEDB5-81CF-409F-B375-0D93D81EF2E3}", + "InstanceSpawner": { + "$type": "PrefabInstanceSpawner", + "SpawnableAsset": { + "assetId": { + "guid": "{EE51E73C-D753-54AC-A1C0-4F29844FB6C3}", + "subId": 2740536329 + }, + "assetHint": "assets/prefabs/bush.spawnable" + } + } + } + ] + } + } + } + }, + "Entity_[263577442055838]": { + "Id": "Entity_[263577442055838]", + "Name": "RandomNoise", + "Components": { + "Component_[13412023990029767074]": { + "$type": "EditorRandomGradientComponent", + "Id": 13412023990029767074, + "PreviewEntity": "Entity_[263577442055838]" + }, + "Component_[14048059127502350032]": { + "$type": "{27F1E1A1-8D9D-4C3B-BD3A-AFB9762449C0} TransformComponent", + "Id": 14048059127502350032, + "Parent Entity": "Entity_[263581737023134]" + }, + "Component_[15585968636846328006]": { + "$type": "EditorEntitySortComponent", + "Id": 15585968636846328006 + }, + "Component_[17356242264256499333]": { + "$type": "EditorOnlyEntityComponent", + "Id": 17356242264256499333 + }, + "Component_[2157320692130316849]": { + "$type": "EditorLockComponent", + "Id": 2157320692130316849 + }, + "Component_[2167582872687341084]": { + "$type": "EditorReferenceShapeComponent", + "Id": 2167582872687341084, + "Configuration": { + "ShapeEntityId": "Entity_[263607506826910]" + } + }, + "Component_[2794166072748175035]": { + "$type": "SelectionComponent", + "Id": 2794166072748175035 + }, + "Component_[4784966656524567789]": { + "$type": "EditorVisibilityComponent", + "Id": 4784966656524567789 + }, + "Component_[6185400249317227261]": { + "$type": "EditorDisabledCompositionComponent", + "Id": 6185400249317227261 + }, + "Component_[639949486729001685]": { + "$type": "EditorGradientTransformComponent", + "Id": 639949486729001685, + "Configuration": { + "ShapeReference": "", + "Bounds": [ + 50.0, + 50.0, + 1.0 + ] + } + }, + "Component_[7347819195697153472]": { + "$type": "EditorEntityIconComponent", + "Id": 7347819195697153472 + }, + "Component_[9225409585951117678]": { + "$type": "EditorInspectorComponent", + "Id": 9225409585951117678, + "ComponentOrderEntryArray": [ + { + "ComponentId": 14048059127502350032 + }, + { + "ComponentId": 2167582872687341084, + "SortIndex": 1 + }, + { + "ComponentId": 639949486729001685, + "SortIndex": 2 + }, + { + "ComponentId": 13412023990029767074, + "SortIndex": 3 + } + ] + }, + "Component_[9667056664436803603]": { + "$type": "EditorPendingCompositionComponent", + "Id": 9667056664436803603 + } + } + }, + "Entity_[263581737023134]": { + "Id": "Entity_[263581737023134]", + "Name": "FlowerSpawner", + "Components": { + "Component_[10064436441176637741]": { + "$type": "EditorDisabledCompositionComponent", + "Id": 10064436441176637741 + }, + "Component_[10418076448308581948]": { + "$type": "EditorRotationModifierComponent", + "Id": 10418076448308581948, + "Configuration": { + "GradientX": { + "GradientId": "" + }, + "GradientY": { + "GradientId": "" + }, + "GradientZ": { + "GradientId": "Entity_[263577442055838]" + } + } + }, + "Component_[12484622175138429315]": { + "$type": "EditorOnlyEntityComponent", + "Id": 12484622175138429315 + }, + "Component_[12590590072231203407]": { + "$type": "EditorLockComponent", + "Id": 12590590072231203407 + }, + "Component_[13079591667184987458]": { + "$type": "EditorScaleModifierComponent", + "Id": 13079591667184987458, + "Configuration": { + "RangeMin": 0.75, + "RangeMax": 1.25, + "Gradient": { + "GradientId": "Entity_[263577442055838]" + } + } + }, + "Component_[13174773394274524631]": { + "$type": "EditorInspectorComponent", + "Id": 13174773394274524631, + "ComponentOrderEntryArray": [ + { + "ComponentId": 1915862229814997128 + }, + { + "ComponentId": 582800388831726963, + "SortIndex": 1 + }, + { + "ComponentId": 18006385801184712266, + "SortIndex": 2 + }, + { + "ComponentId": 6902499453501456890, + "SortIndex": 3 + }, + { + "ComponentId": 10418076448308581948, + "SortIndex": 4 + }, + { + "ComponentId": 13983302912005698250, + "SortIndex": 5 + }, + { + "ComponentId": 13079591667184987458, + "SortIndex": 6 + }, + { + "ComponentId": 7912787520673119502, + "SortIndex": 7 + } + ] + }, + "Component_[13200009872392504010]": { + "$type": "EditorEntitySortComponent", + "Id": 13200009872392504010, + "Child Entity Order": [ + "Entity_[263594621925022]", + "Entity_[263577442055838]" + ] + }, + "Component_[13983302912005698250]": { + "$type": "EditorDistributionFilterComponent", + "Id": 13983302912005698250, + "Configuration": { + "ThresholdMin": 0.2879999876022339, + "ThresholdMax": 0.5680000185966492, + "Gradient": { + "GradientId": "Entity_[263586031990430]" + } + } + }, + "Component_[14726174657215669218]": { + "$type": "EditorPendingCompositionComponent", + "Id": 14726174657215669218 + }, + "Component_[18006385801184712266]": { + "$type": "EditorDescriptorListComponent", + "Id": 18006385801184712266, + "Configuration": { + "Descriptors": [ + { + "SpawnerType": "{74BEEDB5-81CF-409F-B375-0D93D81EF2E3}", + "InstanceSpawner": { + "$type": "PrefabInstanceSpawner", + "SpawnableAsset": { + "assetId": { + "guid": "{80C0CF4E-9A5E-544B-B89E-BC980175A259}", + "subId": 3875079122 + }, + "assetHint": "assets/prefabs/pinkflower.spawnable" + } + } + }, + { + "SpawnerType": "{74BEEDB5-81CF-409F-B375-0D93D81EF2E3}", + "InstanceSpawner": { + "$type": "PrefabInstanceSpawner", + "SpawnableAsset": { + "assetId": { + "guid": "{20DD1202-A434-5482-9FB9-AED4C78F6CBF}", + "subId": 2669863854 + }, + "assetHint": "assets/prefabs/purpleflower.spawnable" + } + } + }, + { + "SpawnerType": "{23C40FD4-A55F-4BD3-BE5B-DC5423F217C2}", + "InstanceSpawner": { + "$type": "EmptyInstanceSpawner" + } + } + ] + } + }, + "Component_[1915862229814997128]": { + "$type": "{27F1E1A1-8D9D-4C3B-BD3A-AFB9762449C0} TransformComponent", + "Id": 1915862229814997128, + "Parent Entity": "Entity_[263607506826910]" + }, + "Component_[2123416208548010747]": { + "$type": "SelectionComponent", + "Id": 2123416208548010747 + }, + "Component_[4172073657954183661]": { + "$type": "EditorVisibilityComponent", + "Id": 4172073657954183661 + }, + "Component_[4297556504463195307]": { + "$type": "EditorEntityIconComponent", + "Id": 4297556504463195307 + }, + "Component_[582800388831726963]": { + "$type": "EditorReferenceShapeComponent", + "Id": 582800388831726963, + "Configuration": { + "ShapeEntityId": "Entity_[263607506826910]" + } + }, + "Component_[6902499453501456890]": { + "$type": "{DD96FD51-A86B-48BC-A6AB-89183B538269} EditorSpawnerComponent", + "Id": 6902499453501456890, + "PreviewEntity": "Entity_[263581737023134]" + }, + "Component_[7912787520673119502]": { + "$type": "EditorPositionModifierComponent", + "Id": 7912787520673119502, + "Configuration": { + "GradientX": { + "GradientId": "Entity_[263577442055838]" + }, + "GradientY": { + "GradientId": "Entity_[263577442055838]" + }, + "GradientZ": { + "GradientId": "" + } + } + } + } + }, + "Entity_[263586031990430]": { + "Id": "Entity_[263586031990430]", + "Name": "Invert", + "Components": { + "Component_[11123278080744920525]": { + "$type": "EditorEntitySortComponent", + "Id": 11123278080744920525 + }, + "Component_[1199715693160400161]": { + "$type": "EditorInspectorComponent", + "Id": 1199715693160400161, + "ComponentOrderEntryArray": [ + { + "ComponentId": 7438979211266329827 + }, + { + "ComponentId": 6027557066164356793, + "SortIndex": 1 + }, + { + "ComponentId": 8903771095804438921, + "SortIndex": 2 + } + ] + }, + "Component_[12162816428693886169]": { + "$type": "EditorEntityIconComponent", + "Id": 12162816428693886169 + }, + "Component_[14493180089799969074]": { + "$type": "EditorVisibilityComponent", + "Id": 14493180089799969074 + }, + "Component_[16206759293595766479]": { + "$type": "EditorPendingCompositionComponent", + "Id": 16206759293595766479 + }, + "Component_[17566144032052847628]": { + "$type": "SelectionComponent", + "Id": 17566144032052847628 + }, + "Component_[17784057508127919200]": { + "$type": "EditorLockComponent", + "Id": 17784057508127919200 + }, + "Component_[18377773171420051348]": { + "$type": "EditorDisabledCompositionComponent", + "Id": 18377773171420051348 + }, + "Component_[6027557066164356793]": { + "$type": "EditorReferenceShapeComponent", + "Id": 6027557066164356793, + "Configuration": { + "ShapeEntityId": "Entity_[263607506826910]" + } + }, + "Component_[7438979211266329827]": { + "$type": "{27F1E1A1-8D9D-4C3B-BD3A-AFB9762449C0} TransformComponent", + "Id": 7438979211266329827, + "Parent Entity": "Entity_[263594621925022]" + }, + "Component_[8421650081106982664]": { + "$type": "EditorOnlyEntityComponent", + "Id": 8421650081106982664 + }, + "Component_[8903771095804438921]": { + "$type": "EditorInvertGradientComponent", + "Id": 8903771095804438921, + "Configuration": { + "Gradient": { + "GradientId": "Entity_[263594621925022]" + } + }, + "PreviewEntity": "Entity_[263586031990430]" + } + } + }, + "Entity_[263590326957726]": { + "Id": "Entity_[263590326957726]", + "Name": "RandomNoise", + "Components": { + "Component_[10420548607186596407]": { + "$type": "SelectionComponent", + "Id": 10420548607186596407 + }, + "Component_[11351507264577024072]": { + "$type": "{27F1E1A1-8D9D-4C3B-BD3A-AFB9762449C0} TransformComponent", + "Id": 11351507264577024072, + "Parent Entity": "Entity_[263573147088542]" + }, + "Component_[11576941520191560445]": { + "$type": "EditorEntityIconComponent", + "Id": 11576941520191560445 + }, + "Component_[11787535428542045683]": { + "$type": "EditorPendingCompositionComponent", + "Id": 11787535428542045683 + }, + "Component_[11946132649485953311]": { + "$type": "EditorEntitySortComponent", + "Id": 11946132649485953311 + }, + "Component_[11970417753234451570]": { + "$type": "EditorOnlyEntityComponent", + "Id": 11970417753234451570 + }, + "Component_[13743879269876214143]": { + "$type": "EditorVisibilityComponent", + "Id": 13743879269876214143 + }, + "Component_[15614946697365576378]": { + "$type": "EditorDisabledCompositionComponent", + "Id": 15614946697365576378 + }, + "Component_[17045174842161759045]": { + "$type": "EditorLockComponent", + "Id": 17045174842161759045 + }, + "Component_[3107716031616536910]": { + "$type": "EditorInspectorComponent", + "Id": 3107716031616536910, + "ComponentOrderEntryArray": [ + { + "ComponentId": 11351507264577024072 + }, + { + "ComponentId": 6316453818295975755, + "SortIndex": 1 + }, + { + "ComponentId": 4846745402056100407, + "SortIndex": 2 + }, + { + "ComponentId": 8967153379180885152, + "SortIndex": 3 + } + ] + }, + "Component_[4846745402056100407]": { + "$type": "EditorGradientTransformComponent", + "Id": 4846745402056100407, + "Configuration": { + "ShapeReference": "", + "Bounds": [ + 50.0, + 50.0, + 1.0 + ] + } + }, + "Component_[6316453818295975755]": { + "$type": "EditorReferenceShapeComponent", + "Id": 6316453818295975755, + "Configuration": { + "ShapeEntityId": "Entity_[263573147088542]" + } + }, + "Component_[8967153379180885152]": { + "$type": "EditorRandomGradientComponent", + "Id": 8967153379180885152, + "PreviewEntity": "Entity_[263590326957726]" + } + } + }, + "Entity_[263594621925022]": { + "Id": "Entity_[263594621925022]", + "Name": "PerlinNoise", + "Components": { + "Component_[15798567753940523121]": { + "$type": "EditorPerlinGradientComponent", + "Id": 15798567753940523121, + "Configuration": { + "randomSeed": 33, + "frequency": 0.25 + }, + "PreviewEntity": "Entity_[263594621925022]" + }, + "Component_[16035848776632936419]": { + "$type": "EditorPendingCompositionComponent", + "Id": 16035848776632936419 + }, + "Component_[16434108759160050253]": { + "$type": "EditorVisibilityComponent", + "Id": 16434108759160050253 + }, + "Component_[16805003046507210760]": { + "$type": "EditorReferenceShapeComponent", + "Id": 16805003046507210760, + "Configuration": { + "ShapeEntityId": "Entity_[263607506826910]" + } + }, + "Component_[17679463569742913027]": { + "$type": "EditorOnlyEntityComponent", + "Id": 17679463569742913027 + }, + "Component_[18285870860955961523]": { + "$type": "SelectionComponent", + "Id": 18285870860955961523 + }, + "Component_[2330427084045350198]": { + "$type": "EditorDisabledCompositionComponent", + "Id": 2330427084045350198 + }, + "Component_[5921906930080711994]": { + "$type": "EditorEntitySortComponent", + "Id": 5921906930080711994, + "Child Entity Order": [ + "Entity_[263586031990430]" + ] + }, + "Component_[764117453152842781]": { + "$type": "{27F1E1A1-8D9D-4C3B-BD3A-AFB9762449C0} TransformComponent", + "Id": 764117453152842781, + "Parent Entity": "Entity_[263581737023134]" + }, + "Component_[7701931249281891300]": { + "$type": "EditorEntityIconComponent", + "Id": 7701931249281891300 + }, + "Component_[7967070680905543315]": { + "$type": "EditorInspectorComponent", + "Id": 7967070680905543315, + "ComponentOrderEntryArray": [ + { + "ComponentId": 764117453152842781 + }, + { + "ComponentId": 16805003046507210760, + "SortIndex": 1 + }, + { + "ComponentId": 8029154041194694200, + "SortIndex": 2 + }, + { + "ComponentId": 15798567753940523121, + "SortIndex": 3 + } + ] + }, + "Component_[8029154041194694200]": { + "$type": "EditorGradientTransformComponent", + "Id": 8029154041194694200, + "Configuration": { + "ShapeReference": "", + "Bounds": [ + 50.0, + 50.0, + 1.0 + ] + } + }, + "Component_[8660028910391135744]": { + "$type": "EditorLockComponent", + "Id": 8660028910391135744 + } + } + }, + "Entity_[263598916892318]": { + "Id": "Entity_[263598916892318]", + "Name": "LandscapeCanvas", + "Components": { + "Component_[12967746135199800648]": { + "$type": "EditorVisibilityComponent", + "Id": 12967746135199800648 + }, + "Component_[13081062505162225823]": { + "$type": "EditorDisabledCompositionComponent", + "Id": 13081062505162225823 + }, + "Component_[16021195931295059075]": { + "$type": "EditorPendingCompositionComponent", + "Id": 16021195931295059075 + }, + "Component_[16134261272053586014]": { + "$type": "EditorEntityIconComponent", + "Id": 16134261272053586014 + }, + "Component_[17500735767968801510]": { + "$type": "EditorLandscapeCanvasComponent", + "Id": 17500735767968801510, + "Graph": { + "m_nodes": [ + { + "Key": 1, + "Value": { + "$type": "CylinderShapeNode", + "m_propertySlots": [ + { + "Key": { + "m_name": "EntityName" + }, + "Value": { + "m_value": { + "$type": "{03AAAB3F-5C47-5A66-9EBC-D5FA4DB353C9} AZStd::string", + "Value": "BushFlowerBlender" + } + } + } + ], + "m_vegetationEntityId": "Entity_[263607506826910]", + "m_componentId": 6683290476113150719 + } + }, + { + "Key": 2, + "Value": { + "$type": "RandomNoiseGradientNode", + "m_propertySlots": [ + { + "Key": { + "m_name": "EntityName" + }, + "Value": { + "m_value": { + "$type": "{03AAAB3F-5C47-5A66-9EBC-D5FA4DB353C9} AZStd::string", + "Value": "RandomNoise" + } + } + } + ], + "m_inputDataSlots": [ + { + "Key": { + "m_name": "PreviewBounds" + }, + "Value": { + "m_value": { + "$type": "EntityId", + "Value": "" + } + } + } + ], + "m_vegetationEntityId": "Entity_[263590326957726]", + "m_componentId": 8967153379180885152 + } + }, + { + "Key": 3, + "Value": { + "$type": "SpawnerAreaNode", + "m_propertySlots": [ + { + "Key": { + "m_name": "EntityName" + }, + "Value": { + "m_value": { + "$type": "{03AAAB3F-5C47-5A66-9EBC-D5FA4DB353C9} AZStd::string", + "Value": "BushSpawner" + } + } + } + ], + "m_inputDataSlots": [ + { + "Key": { + "m_name": "PlacementBounds" + }, + "Value": { + "m_value": { + "$type": "EntityId", + "Value": "" + } + } + } + ], + "m_vegetationEntityId": "Entity_[263573147088542]", + "m_componentId": 1240444912193942742 + } + }, + { + "Key": 4, + "Value": { + "$type": "PerlinNoiseGradientNode", + "m_propertySlots": [ + { + "Key": { + "m_name": "EntityName" + }, + "Value": { + "m_value": { + "$type": "{03AAAB3F-5C47-5A66-9EBC-D5FA4DB353C9} AZStd::string", + "Value": "PerlinNoise" + } + } + } + ], + "m_inputDataSlots": [ + { + "Key": { + "m_name": "PreviewBounds" + }, + "Value": { + "m_value": { + "$type": "EntityId", + "Value": "" + } + } + } + ], + "m_vegetationEntityId": "Entity_[263603211859614]", + "m_componentId": 10160640699095155981 + } + }, + { + "Key": 5, + "Value": { + "$type": "RandomNoiseGradientNode", + "m_propertySlots": [ + { + "Key": { + "m_name": "EntityName" + }, + "Value": { + "m_value": { + "$type": "{03AAAB3F-5C47-5A66-9EBC-D5FA4DB353C9} AZStd::string", + "Value": "RandomNoise" + } + } + } + ], + "m_inputDataSlots": [ + { + "Key": { + "m_name": "PreviewBounds" + }, + "Value": { + "m_value": { + "$type": "EntityId", + "Value": "" + } + } + } + ], + "m_vegetationEntityId": "Entity_[263577442055838]", + "m_componentId": 13412023990029767074 + } + }, + { + "Key": 6, + "Value": { + "$type": "SpawnerAreaNode", + "m_propertySlots": [ + { + "Key": { + "m_name": "EntityName" + }, + "Value": { + "m_value": { + "$type": "{03AAAB3F-5C47-5A66-9EBC-D5FA4DB353C9} AZStd::string", + "Value": "FlowerSpawner" + } + } + } + ], + "m_inputDataSlots": [ + { + "Key": { + "m_name": "PlacementBounds" + }, + "Value": { + "m_value": { + "$type": "EntityId", + "Value": "" + } + } + } + ], + "m_vegetationEntityId": "Entity_[263581737023134]", + "m_componentId": 6902499453501456890 + } + }, + { + "Key": 7, + "Value": { + "$type": "AreaBlenderNode", + "m_propertySlots": [ + { + "Key": { + "m_name": "EntityName" + }, + "Value": { + "m_value": { + "$type": "{03AAAB3F-5C47-5A66-9EBC-D5FA4DB353C9} AZStd::string", + "Value": "BushFlowerBlender" + } + } + } + ], + "m_extendableSlots": { + "InboundArea": [ + { + "m_value": { + "$type": "EntityId", + "Value": "" + } + }, + { + "m_value": { + "$type": "EntityId", + "Value": "" + }, + "m_subId": 1 + } + ] + }, + "m_vegetationEntityId": "Entity_[263607506826910]", + "m_componentId": 7229206794941734410 + } + }, + { + "Key": 8, + "Value": { + "$type": "PerlinNoiseGradientNode", + "m_propertySlots": [ + { + "Key": { + "m_name": "EntityName" + }, + "Value": { + "m_value": { + "$type": "{03AAAB3F-5C47-5A66-9EBC-D5FA4DB353C9} AZStd::string", + "Value": "PerlinNoise" + } + } + } + ], + "m_inputDataSlots": [ + { + "Key": { + "m_name": "PreviewBounds" + }, + "Value": { + "m_value": { + "$type": "EntityId", + "Value": "" + } + } + } + ], + "m_vegetationEntityId": "Entity_[263594621925022]", + "m_componentId": 15798567753940523121 + } + }, + { + "Key": 9, + "Value": { + "$type": "InvertGradientModifierNode", + "m_propertySlots": [ + { + "Key": { + "m_name": "EntityName" + }, + "Value": { + "m_value": { + "$type": "{03AAAB3F-5C47-5A66-9EBC-D5FA4DB353C9} AZStd::string", + "Value": "Invert" + } + } + } + ], + "m_inputDataSlots": [ + { + "Key": { + "m_name": "InboundGradient" + }, + "Value": { + "m_value": { + "$type": "EntityId", + "Value": "" + } + } + }, + { + "Key": { + "m_name": "PreviewBounds" + }, + "Value": { + "m_value": { + "$type": "EntityId", + "Value": "" + } + } + } + ], + "m_vegetationEntityId": "Entity_[263586031990430]", + "m_componentId": 8903771095804438921 + } + }, + { + "Key": 10, + "Value": { + "$type": "RotationModifierNode", + "m_inputDataSlots": [ + { + "Key": { + "m_name": "InboundGradientX" + }, + "Value": { + "m_value": { + "$type": "EntityId", + "Value": "" + } + } + }, + { + "Key": { + "m_name": "InboundGradientY" + }, + "Value": { + "m_value": { + "$type": "EntityId", + "Value": "" + } + } + }, + { + "Key": { + "m_name": "InboundGradientZ" + }, + "Value": { + "m_value": { + "$type": "EntityId", + "Value": "" + } + } + } + ], + "m_vegetationEntityId": "Entity_[263573147088542]", + "m_componentId": 17991239182321715249 + } + }, + { + "Key": 11, + "Value": { + "$type": "DistributionFilterNode", + "m_inputDataSlots": [ + { + "Key": { + "m_name": "InboundGradient" + }, + "Value": { + "m_value": { + "$type": "EntityId", + "Value": "" + } + } + } + ], + "m_vegetationEntityId": "Entity_[263573147088542]", + "m_componentId": 14175761523159824993 + } + }, + { + "Key": 12, + "Value": { + "$type": "ScaleModifierNode", + "m_inputDataSlots": [ + { + "Key": { + "m_name": "InboundGradient" + }, + "Value": { + "m_value": { + "$type": "EntityId", + "Value": "" + } + } + } + ], + "m_vegetationEntityId": "Entity_[263573147088542]", + "m_componentId": 2884829698060689565 + } + }, + { + "Key": 13, + "Value": { + "$type": "PositionModifierNode", + "m_inputDataSlots": [ + { + "Key": { + "m_name": "InboundGradientX" + }, + "Value": { + "m_value": { + "$type": "EntityId", + "Value": "" + } + } + }, + { + "Key": { + "m_name": "InboundGradientY" + }, + "Value": { + "m_value": { + "$type": "EntityId", + "Value": "" + } + } + }, + { + "Key": { + "m_name": "InboundGradientZ" + }, + "Value": { + "m_value": { + "$type": "EntityId", + "Value": "" + } + } + } + ], + "m_vegetationEntityId": "Entity_[263573147088542]", + "m_componentId": 11886309121583108836 + } + }, + { + "Key": 14, + "Value": { + "$type": "RotationModifierNode", + "m_inputDataSlots": [ + { + "Key": { + "m_name": "InboundGradientX" + }, + "Value": { + "m_value": { + "$type": "EntityId", + "Value": "" + } + } + }, + { + "Key": { + "m_name": "InboundGradientY" + }, + "Value": { + "m_value": { + "$type": "EntityId", + "Value": "" + } + } + }, + { + "Key": { + "m_name": "InboundGradientZ" + }, + "Value": { + "m_value": { + "$type": "EntityId", + "Value": "" + } + } + } + ], + "m_vegetationEntityId": "Entity_[263581737023134]", + "m_componentId": 10418076448308581948 + } + }, + { + "Key": 15, + "Value": { + "$type": "DistributionFilterNode", + "m_inputDataSlots": [ + { + "Key": { + "m_name": "InboundGradient" + }, + "Value": { + "m_value": { + "$type": "EntityId", + "Value": "" + } + } + } + ], + "m_vegetationEntityId": "Entity_[263581737023134]", + "m_componentId": 13983302912005698250 + } + }, + { + "Key": 16, + "Value": { + "$type": "ScaleModifierNode", + "m_inputDataSlots": [ + { + "Key": { + "m_name": "InboundGradient" + }, + "Value": { + "m_value": { + "$type": "EntityId", + "Value": "" + } + } + } + ], + "m_vegetationEntityId": "Entity_[263581737023134]", + "m_componentId": 13079591667184987458 + } + }, + { + "Key": 17, + "Value": { + "$type": "PositionModifierNode", + "m_inputDataSlots": [ + { + "Key": { + "m_name": "InboundGradientX" + }, + "Value": { + "m_value": { + "$type": "EntityId", + "Value": "" + } + } + }, + { + "Key": { + "m_name": "InboundGradientY" + }, + "Value": { + "m_value": { + "$type": "EntityId", + "Value": "" + } + } + }, + { + "Key": { + "m_name": "InboundGradientZ" + }, + "Value": { + "m_value": { + "$type": "EntityId", + "Value": "" + } + } + } + ], + "m_vegetationEntityId": "Entity_[263581737023134]", + "m_componentId": 7912787520673119502 + } + } + ], + "m_connections": [ + { + "m_sourceEndpoint": [ + 8, + { + "m_name": "OutboundGradient" + } + ], + "m_targetEndpoint": [ + 9, + { + "m_name": "InboundGradient" + } + ] + }, + { + "m_sourceEndpoint": [ + 3, + { + "m_name": "OutboundArea" + } + ], + "m_targetEndpoint": [ + 7, + { + "m_name": "InboundArea" + } + ] + }, + { + "m_sourceEndpoint": [ + 6, + { + "m_name": "OutboundArea" + } + ], + "m_targetEndpoint": [ + 7, + { + "m_name": "InboundArea", + "m_subId": 1 + } + ] + }, + { + "m_sourceEndpoint": [ + 1, + { + "m_name": "Bounds" + } + ], + "m_targetEndpoint": [ + 3, + { + "m_name": "PlacementBounds" + } + ] + }, + { + "m_sourceEndpoint": [ + 1, + { + "m_name": "Bounds" + } + ], + "m_targetEndpoint": [ + 6, + { + "m_name": "PlacementBounds" + } + ] + }, + { + "m_sourceEndpoint": [ + 2, + { + "m_name": "OutboundGradient" + } + ], + "m_targetEndpoint": [ + 10, + { + "m_name": "InboundGradientZ" + } + ] + }, + { + "m_sourceEndpoint": [ + 4, + { + "m_name": "OutboundGradient" + } + ], + "m_targetEndpoint": [ + 11, + { + "m_name": "InboundGradient" + } + ] + }, + { + "m_sourceEndpoint": [ + 2, + { + "m_name": "OutboundGradient" + } + ], + "m_targetEndpoint": [ + 12, + { + "m_name": "InboundGradient" + } + ] + }, + { + "m_sourceEndpoint": [ + 2, + { + "m_name": "OutboundGradient" + } + ], + "m_targetEndpoint": [ + 13, + { + "m_name": "InboundGradientX" + } + ] + }, + { + "m_sourceEndpoint": [ + 2, + { + "m_name": "OutboundGradient" + } + ], + "m_targetEndpoint": [ + 13, + { + "m_name": "InboundGradientY" + } + ] + }, + { + "m_sourceEndpoint": [ + 5, + { + "m_name": "OutboundGradient" + } + ], + "m_targetEndpoint": [ + 14, + { + "m_name": "InboundGradientZ" + } + ] + }, + { + "m_sourceEndpoint": [ + 9, + { + "m_name": "OutboundGradient" + } + ], + "m_targetEndpoint": [ + 15, + { + "m_name": "InboundGradient" + } + ] + }, + { + "m_sourceEndpoint": [ + 5, + { + "m_name": "OutboundGradient" + } + ], + "m_targetEndpoint": [ + 16, + { + "m_name": "InboundGradient" + } + ] + }, + { + "m_sourceEndpoint": [ + 5, + { + "m_name": "OutboundGradient" + } + ], + "m_targetEndpoint": [ + 17, + { + "m_name": "InboundGradientX" + } + ] + }, + { + "m_sourceEndpoint": [ + 5, + { + "m_name": "OutboundGradient" + } + ], + "m_targetEndpoint": [ + 17, + { + "m_name": "InboundGradientY" + } + ] + } + ], + "m_uiMetadata": { + "m_sceneMetadata": { + "ComponentData": { + "{5F84B500-8C45-40D1-8EFC-A5306B241444}": { + "$type": "SceneComponentSaveData", + "ViewParams": { + "Scale": 0.3771495156249999, + "AnchorX": -498.4760437011719, + "AnchorY": 808.6978149414063 + } + } + } + }, + "m_nodeMetadata": [ + { + "Key": 2, + "Value": { + "ComponentData": { + "{24CB38BB-1705-4EC5-8F63-B574571B4DCD}": { + "$type": "NodeSaveData" + }, + "{328FF15C-C302-458F-A43D-E1794DE0904E}": { + "$type": "GeneralNodeTitleComponentSaveData", + "PaletteOverride": "GradientNodeTitlePalette" + }, + "{7CC444B1-F9B3-41B5-841B-0C4F2179F111}": { + "$type": "GeometrySaveData", + "Position": [ + 100.0, + 580.0 + ] + }, + "{B0B99C8A-03AF-4CF6-A926-F65C874C3D97}": { + "$type": "StylingComponentSaveData" + }, + "{B1F49A35-8408-40DA-B79E-F1E3B64322CE}": { + "$type": "PersistentIdComponentSaveData", + "PersistentId": "{2D583FA2-5659-491F-8914-6302420E3F0B}" + } + } + } + }, + { + "Key": 3, + "Value": { + "ComponentData": { + "{24CB38BB-1705-4EC5-8F63-B574571B4DCD}": { + "$type": "NodeSaveData" + }, + "{328FF15C-C302-458F-A43D-E1794DE0904E}": { + "$type": "GeneralNodeTitleComponentSaveData", + "PaletteOverride": "VegetationAreaNodeTitlePalette" + }, + "{7CC444B1-F9B3-41B5-841B-0C4F2179F111}": { + "$type": "GeometrySaveData", + "Position": [ + 480.0, + 600.0 + ] + }, + "{B0B99C8A-03AF-4CF6-A926-F65C874C3D97}": { + "$type": "StylingComponentSaveData" + }, + "{B1F49A35-8408-40DA-B79E-F1E3B64322CE}": { + "$type": "PersistentIdComponentSaveData", + "PersistentId": "{A26480C4-A80B-4B36-ADE1-918E4541EA2B}" + } + } + } + }, + { + "Key": 5, + "Value": { + "ComponentData": { + "{24CB38BB-1705-4EC5-8F63-B574571B4DCD}": { + "$type": "NodeSaveData" + }, + "{328FF15C-C302-458F-A43D-E1794DE0904E}": { + "$type": "GeneralNodeTitleComponentSaveData", + "PaletteOverride": "GradientNodeTitlePalette" + }, + "{7CC444B1-F9B3-41B5-841B-0C4F2179F111}": { + "$type": "GeometrySaveData", + "Position": [ + 100.0, + 1540.0 + ] + }, + "{B0B99C8A-03AF-4CF6-A926-F65C874C3D97}": { + "$type": "StylingComponentSaveData" + }, + "{B1F49A35-8408-40DA-B79E-F1E3B64322CE}": { + "$type": "PersistentIdComponentSaveData", + "PersistentId": "{6CE9EA8B-85E7-4E17-B1D6-CA97D9D65276}" + } + } + } + }, + { + "Key": 6, + "Value": { + "ComponentData": { + "{24CB38BB-1705-4EC5-8F63-B574571B4DCD}": { + "$type": "NodeSaveData" + }, + "{328FF15C-C302-458F-A43D-E1794DE0904E}": { + "$type": "GeneralNodeTitleComponentSaveData", + "PaletteOverride": "VegetationAreaNodeTitlePalette" + }, + "{7CC444B1-F9B3-41B5-841B-0C4F2179F111}": { + "$type": "GeometrySaveData", + "Position": [ + 480.0, + 1560.0 + ] + }, + "{B0B99C8A-03AF-4CF6-A926-F65C874C3D97}": { + "$type": "StylingComponentSaveData" + }, + "{B1F49A35-8408-40DA-B79E-F1E3B64322CE}": { + "$type": "PersistentIdComponentSaveData", + "PersistentId": "{8FABE49F-1D73-46FE-8616-A982EEE46DDD}" + } + } + } + }, + { + "Key": 7, + "Value": { + "ComponentData": { + "{24CB38BB-1705-4EC5-8F63-B574571B4DCD}": { + "$type": "NodeSaveData" + }, + "{328FF15C-C302-458F-A43D-E1794DE0904E}": { + "$type": "GeneralNodeTitleComponentSaveData", + "PaletteOverride": "VegetationAreaNodeTitlePalette" + }, + "{7CC444B1-F9B3-41B5-841B-0C4F2179F111}": { + "$type": "GeometrySaveData", + "Position": [ + 840.0, + 1580.0 + ] + }, + "{B0B99C8A-03AF-4CF6-A926-F65C874C3D97}": { + "$type": "StylingComponentSaveData" + }, + "{B1F49A35-8408-40DA-B79E-F1E3B64322CE}": { + "$type": "PersistentIdComponentSaveData", + "PersistentId": "{C5EEBC1D-B91B-4852-A41D-425C6FED3FB9}" + } + } + } + }, + { + "Key": 9, + "Value": { + "ComponentData": { + "{24CB38BB-1705-4EC5-8F63-B574571B4DCD}": { + "$type": "NodeSaveData" + }, + "{328FF15C-C302-458F-A43D-E1794DE0904E}": { + "$type": "GeneralNodeTitleComponentSaveData", + "PaletteOverride": "GradientModifierNodeTitlePalette" + }, + "{7CC444B1-F9B3-41B5-841B-0C4F2179F111}": { + "$type": "GeometrySaveData", + "Position": [ + 480.0, + 2060.0 + ] + }, + "{B0B99C8A-03AF-4CF6-A926-F65C874C3D97}": { + "$type": "StylingComponentSaveData" + }, + "{B1F49A35-8408-40DA-B79E-F1E3B64322CE}": { + "$type": "PersistentIdComponentSaveData", + "PersistentId": "{5EB76670-0CBE-4F2A-9AE7-F65709D0BE92}" + } + } + } + }, + { + "Key": 10, + "Value": { + "ComponentData": { + "{24CB38BB-1705-4EC5-8F63-B574571B4DCD}": { + "$type": "NodeSaveData" + }, + "{328FF15C-C302-458F-A43D-E1794DE0904E}": { + "$type": "GeneralNodeTitleComponentSaveData", + "PaletteOverride": "VegetationAreaNodeTitlePalette" + }, + "{7CC444B1-F9B3-41B5-841B-0C4F2179F111}": { + "$type": "GeometrySaveData", + "Position": [ + 6.0, + 147.0 + ] + }, + "{B0B99C8A-03AF-4CF6-A926-F65C874C3D97}": { + "$type": "StylingComponentSaveData" + }, + "{B1F49A35-8408-40DA-B79E-F1E3B64322CE}": { + "$type": "PersistentIdComponentSaveData", + "PersistentId": "{5CB69A73-F7BA-4F76-AB86-F343052C3D7D}" + } + } + } + }, + { + "Key": 11, + "Value": { + "ComponentData": { + "{24CB38BB-1705-4EC5-8F63-B574571B4DCD}": { + "$type": "NodeSaveData" + }, + "{328FF15C-C302-458F-A43D-E1794DE0904E}": { + "$type": "GeneralNodeTitleComponentSaveData", + "PaletteOverride": "VegetationAreaNodeTitlePalette" + }, + "{7CC444B1-F9B3-41B5-841B-0C4F2179F111}": { + "$type": "GeometrySaveData", + "Position": [ + 6.0, + 367.0 + ] + }, + "{B0B99C8A-03AF-4CF6-A926-F65C874C3D97}": { + "$type": "StylingComponentSaveData" + }, + "{B1F49A35-8408-40DA-B79E-F1E3B64322CE}": { + "$type": "PersistentIdComponentSaveData", + "PersistentId": "{235DEBEC-E3F8-43C1-BA7E-41475B834D70}" + } + } + } + }, + { + "Key": 12, + "Value": { + "ComponentData": { + "{24CB38BB-1705-4EC5-8F63-B574571B4DCD}": { + "$type": "NodeSaveData" + }, + "{328FF15C-C302-458F-A43D-E1794DE0904E}": { + "$type": "GeneralNodeTitleComponentSaveData", + "PaletteOverride": "VegetationAreaNodeTitlePalette" + }, + "{7CC444B1-F9B3-41B5-841B-0C4F2179F111}": { + "$type": "GeometrySaveData", + "Position": [ + 6.0, + 288.0 + ] + }, + "{B0B99C8A-03AF-4CF6-A926-F65C874C3D97}": { + "$type": "StylingComponentSaveData" + }, + "{B1F49A35-8408-40DA-B79E-F1E3B64322CE}": { + "$type": "PersistentIdComponentSaveData", + "PersistentId": "{9E56E7B6-2ECE-42F9-9A23-FF7D192209D2}" + } + } + } + }, + { + "Key": 13, + "Value": { + "ComponentData": { + "{24CB38BB-1705-4EC5-8F63-B574571B4DCD}": { + "$type": "NodeSaveData" + }, + "{328FF15C-C302-458F-A43D-E1794DE0904E}": { + "$type": "GeneralNodeTitleComponentSaveData", + "PaletteOverride": "VegetationAreaNodeTitlePalette" + }, + "{7CC444B1-F9B3-41B5-841B-0C4F2179F111}": { + "$type": "GeometrySaveData", + "Position": [ + 6.0, + 6.0 + ] + }, + "{B0B99C8A-03AF-4CF6-A926-F65C874C3D97}": { + "$type": "StylingComponentSaveData" + }, + "{B1F49A35-8408-40DA-B79E-F1E3B64322CE}": { + "$type": "PersistentIdComponentSaveData", + "PersistentId": "{61759FE6-E6F7-4F4B-819B-FBFE125D7389}" + } + } + } + }, + { + "Key": 14, + "Value": { + "ComponentData": { + "{24CB38BB-1705-4EC5-8F63-B574571B4DCD}": { + "$type": "NodeSaveData" + }, + "{328FF15C-C302-458F-A43D-E1794DE0904E}": { + "$type": "GeneralNodeTitleComponentSaveData", + "PaletteOverride": "VegetationAreaNodeTitlePalette" + }, + "{7CC444B1-F9B3-41B5-841B-0C4F2179F111}": { + "$type": "GeometrySaveData", + "Position": [ + 6.0, + 147.0 + ] + }, + "{B0B99C8A-03AF-4CF6-A926-F65C874C3D97}": { + "$type": "StylingComponentSaveData" + }, + "{B1F49A35-8408-40DA-B79E-F1E3B64322CE}": { + "$type": "PersistentIdComponentSaveData", + "PersistentId": "{0AC1C6C8-7CC1-4068-A87D-F4B92AE8FCAF}" + } + } + } + }, + { + "Key": 15, + "Value": { + "ComponentData": { + "{24CB38BB-1705-4EC5-8F63-B574571B4DCD}": { + "$type": "NodeSaveData" + }, + "{328FF15C-C302-458F-A43D-E1794DE0904E}": { + "$type": "GeneralNodeTitleComponentSaveData", + "PaletteOverride": "VegetationAreaNodeTitlePalette" + }, + "{7CC444B1-F9B3-41B5-841B-0C4F2179F111}": { + "$type": "GeometrySaveData", + "Position": [ + 6.0, + 367.0 + ] + }, + "{B0B99C8A-03AF-4CF6-A926-F65C874C3D97}": { + "$type": "StylingComponentSaveData" + }, + "{B1F49A35-8408-40DA-B79E-F1E3B64322CE}": { + "$type": "PersistentIdComponentSaveData", + "PersistentId": "{5D698B90-830F-46FE-ADD8-6164EA098C3E}" + } + } + } + }, + { + "Key": 16, + "Value": { + "ComponentData": { + "{24CB38BB-1705-4EC5-8F63-B574571B4DCD}": { + "$type": "NodeSaveData" + }, + "{328FF15C-C302-458F-A43D-E1794DE0904E}": { + "$type": "GeneralNodeTitleComponentSaveData", + "PaletteOverride": "VegetationAreaNodeTitlePalette" + }, + "{7CC444B1-F9B3-41B5-841B-0C4F2179F111}": { + "$type": "GeometrySaveData", + "Position": [ + 6.0, + 288.0 + ] + }, + "{B0B99C8A-03AF-4CF6-A926-F65C874C3D97}": { + "$type": "StylingComponentSaveData" + }, + "{B1F49A35-8408-40DA-B79E-F1E3B64322CE}": { + "$type": "PersistentIdComponentSaveData", + "PersistentId": "{9DE6DE4A-2E6F-44BA-B292-3CD2215C1D5B}" + } + } + } + }, + { + "Key": 17, + "Value": { + "ComponentData": { + "{24CB38BB-1705-4EC5-8F63-B574571B4DCD}": { + "$type": "NodeSaveData" + }, + "{328FF15C-C302-458F-A43D-E1794DE0904E}": { + "$type": "GeneralNodeTitleComponentSaveData", + "PaletteOverride": "VegetationAreaNodeTitlePalette" + }, + "{7CC444B1-F9B3-41B5-841B-0C4F2179F111}": { + "$type": "GeometrySaveData", + "Position": [ + 6.0, + 6.0 + ] + }, + "{B0B99C8A-03AF-4CF6-A926-F65C874C3D97}": { + "$type": "StylingComponentSaveData" + }, + "{B1F49A35-8408-40DA-B79E-F1E3B64322CE}": { + "$type": "PersistentIdComponentSaveData", + "PersistentId": "{57FA822D-629F-4949-A8D7-D675544EBC0A}" + } + } + } + } + ] + }, + "m_nodeWrappings": [ + { + "Key": 10, + "Value": [ + 3, + 1 + ] + }, + { + "Key": 11, + "Value": [ + 3, + 6 + ] + }, + { + "Key": 12, + "Value": [ + 3, + 2 + ] + }, + { + "Key": 13, + "Value": [ + 3, + {} + ] + }, + { + "Key": 14, + "Value": [ + 6, + 1 + ] + }, + { + "Key": 15, + "Value": [ + 6, + 6 + ] + }, + { + "Key": 16, + "Value": [ + 6, + 2 + ] + }, + { + "Key": 17, + "Value": [ + 6, + {} + ] + } + ] + } + }, + "Component_[17574651838531525263]": { + "$type": "EditorEntitySortComponent", + "Id": 17574651838531525263, + "Child Entity Order": [ + "Entity_[263607506826910]" + ] + }, + "Component_[3086205760978540160]": { + "$type": "EditorLockComponent", + "Id": 3086205760978540160 + }, + "Component_[3102230753208284750]": { + "$type": "EditorInspectorComponent", + "Id": 3102230753208284750, + "ComponentOrderEntryArray": [ + { + "ComponentId": 5796173638130327223 + }, + { + "ComponentId": 17500735767968801510, + "SortIndex": 1 + } + ] + }, + "Component_[4695341524212000585]": { + "$type": "EditorOnlyEntityComponent", + "Id": 4695341524212000585 + }, + "Component_[5796173638130327223]": { + "$type": "{27F1E1A1-8D9D-4C3B-BD3A-AFB9762449C0} TransformComponent", + "Id": 5796173638130327223, + "Parent Entity": "ContainerEntity" + }, + "Component_[8278362871021770878]": { + "$type": "SelectionComponent", + "Id": 8278362871021770878 + } + } + }, + "Entity_[263603211859614]": { + "Id": "Entity_[263603211859614]", + "Name": "PerlinNoise", + "Components": { + "Component_[10006546776757889020]": { + "$type": "EditorVisibilityComponent", + "Id": 10006546776757889020 + }, + "Component_[10160640699095155981]": { + "$type": "EditorPerlinGradientComponent", + "Id": 10160640699095155981, + "Configuration": { + "randomSeed": 33, + "frequency": 0.25 + }, + "PreviewEntity": "Entity_[263603211859614]" + }, + "Component_[11506183926478566822]": { + "$type": "EditorEntitySortComponent", + "Id": 11506183926478566822 + }, + "Component_[13160180411150366392]": { + "$type": "EditorLockComponent", + "Id": 13160180411150366392 + }, + "Component_[15083697380300161163]": { + "$type": "EditorDisabledCompositionComponent", + "Id": 15083697380300161163 + }, + "Component_[15404456223257061245]": { + "$type": "EditorInspectorComponent", + "Id": 15404456223257061245, + "ComponentOrderEntryArray": [ + { + "ComponentId": 6484803030406851652 + }, + { + "ComponentId": 4912800286535654244, + "SortIndex": 1 + }, + { + "ComponentId": 2395166459126906105, + "SortIndex": 2 + }, + { + "ComponentId": 10160640699095155981, + "SortIndex": 3 + } + ] + }, + "Component_[2395166459126906105]": { + "$type": "EditorGradientTransformComponent", + "Id": 2395166459126906105, + "Configuration": { + "ShapeReference": "", + "Bounds": [ + 50.0, + 50.0, + 1.0 + ] + } + }, + "Component_[4417011400526470160]": { + "$type": "EditorEntityIconComponent", + "Id": 4417011400526470160 + }, + "Component_[4601061670472962302]": { + "$type": "EditorPendingCompositionComponent", + "Id": 4601061670472962302 + }, + "Component_[4912800286535654244]": { + "$type": "EditorReferenceShapeComponent", + "Id": 4912800286535654244, + "Configuration": { + "ShapeEntityId": "Entity_[263607506826910]" + } + }, + "Component_[6233982345083723563]": { + "$type": "SelectionComponent", + "Id": 6233982345083723563 + }, + "Component_[6484803030406851652]": { + "$type": "{27F1E1A1-8D9D-4C3B-BD3A-AFB9762449C0} TransformComponent", + "Id": 6484803030406851652, + "Parent Entity": "Entity_[263573147088542]" + }, + "Component_[6813813525871080299]": { + "$type": "EditorOnlyEntityComponent", + "Id": 6813813525871080299 + } + } + }, + "Entity_[263607506826910]": { + "Id": "Entity_[263607506826910]", + "Name": "BushFlowerBlender", + "Components": { + "Component_[13725600808872754587]": { + "$type": "EditorEntityIconComponent", + "Id": 13725600808872754587 + }, + "Component_[15959807606564505710]": { + "$type": "{27F1E1A1-8D9D-4C3B-BD3A-AFB9762449C0} TransformComponent", + "Id": 15959807606564505710, + "Parent Entity": "Entity_[263598916892318]" + }, + "Component_[1596826146661515925]": { + "$type": "EditorPendingCompositionComponent", + "Id": 1596826146661515925 + }, + "Component_[4525591661239956058]": { + "$type": "EditorVisibilityComponent", + "Id": 4525591661239956058 + }, + "Component_[6683290476113150719]": { + "$type": "EditorCylinderShapeComponent", + "Id": 6683290476113150719, + "CylinderShape": { + "Configuration": { + "Radius": 25.0 + } + } + }, + "Component_[6879394931668195375]": { + "$type": "EditorEntitySortComponent", + "Id": 6879394931668195375, + "Child Entity Order": [ + "Entity_[263573147088542]", + "Entity_[263581737023134]" + ] + }, + "Component_[7229206794941734410]": { + "$type": "EditorAreaBlenderComponent", + "Id": 7229206794941734410, + "Configuration": { + "Operations": [ + "Entity_[263573147088542]", + "Entity_[263581737023134]" + ] + }, + "PreviewEntity": "Entity_[263607506826910]" + }, + "Component_[8772711204845372843]": { + "$type": "EditorLockComponent", + "Id": 8772711204845372843 + }, + "Component_[8959345022109725835]": { + "$type": "SelectionComponent", + "Id": 8959345022109725835 + }, + "Component_[9094488642973843583]": { + "$type": "EditorDisabledCompositionComponent", + "Id": 9094488642973843583 + }, + "Component_[9112960617967513749]": { + "$type": "EditorInspectorComponent", + "Id": 9112960617967513749, + "ComponentOrderEntryArray": [ + { + "ComponentId": 15959807606564505710 + }, + { + "ComponentId": 7229206794941734410, + "SortIndex": 1 + }, + { + "ComponentId": 6683290476113150719, + "SortIndex": 2 + } + ] + }, + "Component_[9541665258597207652]": { + "$type": "EditorOnlyEntityComponent", + "Id": 9541665258597207652 + } + } + } + } +} \ No newline at end of file diff --git a/AutomatedTesting/Assets/Prefabs/PurpleFlower.prefab b/AutomatedTesting/Assets/Prefabs/PurpleFlower.prefab new file mode 100644 index 0000000000..a8716ec099 --- /dev/null +++ b/AutomatedTesting/Assets/Prefabs/PurpleFlower.prefab @@ -0,0 +1,129 @@ +{ + "ContainerEntity": { + "Id": "ContainerEntity", + "Name": "PurpleFlower", + "Components": { + "Component_[10519928302743666073]": { + "$type": "EditorPrefabComponent", + "Id": 10519928302743666073 + }, + "Component_[13894087802180240181]": { + "$type": "{27F1E1A1-8D9D-4C3B-BD3A-AFB9762449C0} TransformComponent", + "Id": 13894087802180240181, + "Parent Entity": "" + }, + "Component_[15788541052719571801]": { + "$type": "EditorEntityIconComponent", + "Id": 15788541052719571801 + }, + "Component_[15842981265136092481]": { + "$type": "SelectionComponent", + "Id": 15842981265136092481 + }, + "Component_[16360384897559021149]": { + "$type": "EditorInspectorComponent", + "Id": 16360384897559021149 + }, + "Component_[16713545675046303279]": { + "$type": "EditorVisibilityComponent", + "Id": 16713545675046303279 + }, + "Component_[1806734194268113785]": { + "$type": "EditorPendingCompositionComponent", + "Id": 1806734194268113785 + }, + "Component_[5392020700593853313]": { + "$type": "EditorEntitySortComponent", + "Id": 5392020700593853313, + "Child Entity Order": [ + "Entity_[14335611090324]" + ] + }, + "Component_[5995854518752659458]": { + "$type": "EditorLockComponent", + "Id": 5995854518752659458 + }, + "Component_[6963022284400845376]": { + "$type": "EditorDisabledCompositionComponent", + "Id": 6963022284400845376 + }, + "Component_[8055275578170091546]": { + "$type": "EditorOnlyEntityComponent", + "Id": 8055275578170091546 + } + } + }, + "Entities": { + "Entity_[14335611090324]": { + "Id": "Entity_[14335611090324]", + "Name": "PurpleFlower", + "Components": { + "Component_[10887353073528055802]": { + "$type": "EditorPendingCompositionComponent", + "Id": 10887353073528055802 + }, + "Component_[12641127425852859189]": { + "$type": "AZ::Render::EditorMeshComponent", + "Id": 12641127425852859189, + "Controller": { + "Configuration": { + "ModelAsset": { + "assetId": { + "guid": "{D493A670-6D82-5AE9-A2C8-A2EB02684F71}", + "subId": 284799939 + }, + "assetHint": "assets/objects/foliage/grass_flower_purple.azmodel" + } + } + } + }, + "Component_[14406733303466080015]": { + "$type": "EditorInspectorComponent", + "Id": 14406733303466080015, + "ComponentOrderEntryArray": [ + { + "ComponentId": 9231452352781000222 + }, + { + "ComponentId": 12641127425852859189, + "SortIndex": 1 + } + ] + }, + "Component_[1452384341905923012]": { + "$type": "EditorLockComponent", + "Id": 1452384341905923012 + }, + "Component_[2215454016415585892]": { + "$type": "EditorDisabledCompositionComponent", + "Id": 2215454016415585892 + }, + "Component_[4104108067383423623]": { + "$type": "EditorVisibilityComponent", + "Id": 4104108067383423623 + }, + "Component_[4197335450471807917]": { + "$type": "SelectionComponent", + "Id": 4197335450471807917 + }, + "Component_[6877680739064997650]": { + "$type": "EditorOnlyEntityComponent", + "Id": 6877680739064997650 + }, + "Component_[7372550507186490390]": { + "$type": "EditorEntityIconComponent", + "Id": 7372550507186490390 + }, + "Component_[7673532337364366244]": { + "$type": "EditorEntitySortComponent", + "Id": 7673532337364366244 + }, + "Component_[9231452352781000222]": { + "$type": "{27F1E1A1-8D9D-4C3B-BD3A-AFB9762449C0} TransformComponent", + "Id": 9231452352781000222, + "Parent Entity": "ContainerEntity" + } + } + } + } +} \ No newline at end of file diff --git a/AutomatedTesting/Assets/TestAnim/parent_tops.fbx b/AutomatedTesting/Assets/TestAnim/parent_tops.fbx new file mode 100644 index 0000000000..f13323ae8b --- /dev/null +++ b/AutomatedTesting/Assets/TestAnim/parent_tops.fbx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3789abdf439a6d70438fd4bb1e06881ae6686a4699209c6bc371d22d161e5347 +size 26476 diff --git a/AutomatedTesting/Assets/TestAnim/parenting_test_default.fbx b/AutomatedTesting/Assets/TestAnim/parenting_test_default.fbx new file mode 100644 index 0000000000..d3e189bdc5 --- /dev/null +++ b/AutomatedTesting/Assets/TestAnim/parenting_test_default.fbx @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:c987d7d79685fda83efcffb7e1afbcd356c37fc68ec5c663a89b02d4df10caea +size 46412 diff --git a/AutomatedTesting/Assets/VegDescriptorLists/flower_pink.vegdescriptorlist b/AutomatedTesting/Assets/VegDescriptorLists/flower_pink.vegdescriptorlist index 372cafbdce..9120d992c7 100644 --- a/AutomatedTesting/Assets/VegDescriptorLists/flower_pink.vegdescriptorlist +++ b/AutomatedTesting/Assets/VegDescriptorLists/flower_pink.vegdescriptorlist @@ -2,11 +2,11 @@ - + - + - + diff --git a/AutomatedTesting/Gem/Code/Source/AutoGen/NetworkTestLevelEntityComponent.AutoComponent.xml b/AutomatedTesting/Gem/Code/Source/AutoGen/NetworkTestLevelEntityComponent.AutoComponent.xml new file mode 100644 index 0000000000..2fd196a2f6 --- /dev/null +++ b/AutomatedTesting/Gem/Code/Source/AutoGen/NetworkTestLevelEntityComponent.AutoComponent.xml @@ -0,0 +1,15 @@ + + + + + + + + + diff --git a/AutomatedTesting/Gem/Code/Source/AutoGen/NetworkTestPlayerComponent.AutoComponent.xml b/AutomatedTesting/Gem/Code/Source/AutoGen/NetworkTestPlayerComponent.AutoComponent.xml index 251d2b25af..b4dd35d741 100644 --- a/AutomatedTesting/Gem/Code/Source/AutoGen/NetworkTestPlayerComponent.AutoComponent.xml +++ b/AutomatedTesting/Gem/Code/Source/AutoGen/NetworkTestPlayerComponent.AutoComponent.xml @@ -29,8 +29,6 @@ - - diff --git a/AutomatedTesting/Gem/Code/automatedtesting_files.cmake b/AutomatedTesting/Gem/Code/automatedtesting_files.cmake index eb619104a4..1f6dbbd772 100644 --- a/AutomatedTesting/Gem/Code/automatedtesting_files.cmake +++ b/AutomatedTesting/Gem/Code/automatedtesting_files.cmake @@ -12,4 +12,5 @@ set(FILES Source/AutomatedTestingSystemComponent.cpp Source/AutomatedTestingSystemComponent.h Source/AutoGen/NetworkTestPlayerComponent.AutoComponent.xml + Source/AutoGen/NetworkTestLevelEntityComponent.AutoComponent.xml ) diff --git a/AutomatedTesting/Gem/PythonTests/AWS/CMakeLists.txt b/AutomatedTesting/Gem/PythonTests/AWS/CMakeLists.txt index c8629bbe8b..10e90ecbfc 100644 --- a/AutomatedTesting/Gem/PythonTests/AWS/CMakeLists.txt +++ b/AutomatedTesting/Gem/PythonTests/AWS/CMakeLists.txt @@ -12,12 +12,6 @@ ################################################################################ if(PAL_TRAIT_BUILD_TESTS_SUPPORTED AND PAL_TRAIT_BUILD_HOST_TOOLS) - # Only enable AWS automated tests on Windows - set(SUPPORTED_PLATFORMS "Windows" "Linux") - if (NOT "${PAL_PLATFORM_NAME}" IN_LIST SUPPORTED_PLATFORMS) - return() - endif() - ly_add_pytest( NAME AutomatedTesting::AWSTests TEST_SUITE awsi diff --git a/AutomatedTesting/Gem/PythonTests/AWS/README.md b/AutomatedTesting/Gem/PythonTests/AWS/README.md index a25f39d9c2..73ef685261 100644 --- a/AutomatedTesting/Gem/PythonTests/AWS/README.md +++ b/AutomatedTesting/Gem/PythonTests/AWS/README.md @@ -3,7 +3,7 @@ ## Prerequisites 1. Build the O3DE Editor and AutomatedTesting.GameLauncher in Profile. 2. Install the latest version of NodeJs. -3. AWS CLI is installed and configured following [Configuration and Credential File Settings](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html). +3. AWS CLI is installed and AWS crendentials are configured via [environment variables](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-envvars.html) or [default profile](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-files.html). 4. [AWS Cloud Development Kit (CDK)](https://docs.aws.amazon.com/cdk/latest/guide/getting_started.html#getting_started_install) is installed. ## Deploy CDK Applications diff --git a/AutomatedTesting/Gem/PythonTests/AWS/common/aws_credentials.py b/AutomatedTesting/Gem/PythonTests/AWS/common/aws_credentials.py index c6401f2828..d0bbfe7c3e 100644 --- a/AutomatedTesting/Gem/PythonTests/AWS/common/aws_credentials.py +++ b/AutomatedTesting/Gem/PythonTests/AWS/common/aws_credentials.py @@ -68,6 +68,10 @@ class AwsCredentials: if (len(self._credentials.sections()) == 0) and (not self._credentials_file_exists): os.remove(self._credentials_path) return + + credentials_file_dir = os.path.dirname(self._credentials_path) + if not os.path.isdir(credentials_file_dir): + os.makedirs(credentials_file_dir) with open(self._credentials_path, 'w+') as credential_file: self._credentials.write(credential_file) diff --git a/AutomatedTesting/Gem/PythonTests/AWS/common/aws_utils.py b/AutomatedTesting/Gem/PythonTests/AWS/common/aws_utils.py index 92f3762e71..2a5efbd03f 100644 --- a/AutomatedTesting/Gem/PythonTests/AWS/common/aws_utils.py +++ b/AutomatedTesting/Gem/PythonTests/AWS/common/aws_utils.py @@ -16,7 +16,7 @@ logging.getLogger('nose').setLevel(logging.WARNING) class AwsUtils: def __init__(self, arn: str, session_name: str, region_name: str): - local_session = boto3.Session(profile_name='default') + local_session = boto3.Session() local_sts_client = local_session.client('sts') self._local_account_id = local_sts_client.get_caller_identity()["Account"] logger.info(f'Local Account Id: {self._local_account_id}') diff --git a/AutomatedTesting/Gem/PythonTests/AWS/common/constants.py b/AutomatedTesting/Gem/PythonTests/AWS/common/constants.py index b12aca5f29..a38974073a 100644 --- a/AutomatedTesting/Gem/PythonTests/AWS/common/constants.py +++ b/AutomatedTesting/Gem/PythonTests/AWS/common/constants.py @@ -6,11 +6,13 @@ SPDX-License-Identifier: Apache-2.0 OR MIT """ import os +import platform # ARN of the IAM role to assume for retrieving temporary AWS credentials ASSUME_ROLE_ARN = os.environ.get('ASSUME_ROLE_ARN', 'arn:aws:iam::645075835648:role/o3de-automation-tests') # Name of the AWS project deployed by the CDK applications -AWS_PROJECT_NAME = os.environ.get('O3DE_AWS_PROJECT_NAME', 'AWSAUTO') +AWS_PROJECT_NAME = os.environ.get('O3DE_AWS_PROJECT_NAME').upper() if os.environ.get('O3DE_AWS_PROJECT_NAME') else \ + (os.environ.get('BRANCH_NAME', '') + '-' + os.environ.get('PIPELINE_NAME', '') + '-' + platform.system()).upper() # Region for the existing CloudFormation stacks used by the automation tests AWS_REGION = os.environ.get('O3DE_AWS_DEPLOY_REGION', 'us-east-1') # Name of the default resource mapping config file used by the automation tests diff --git a/AutomatedTesting/Gem/PythonTests/Atom/TestSuite_Main.py b/AutomatedTesting/Gem/PythonTests/Atom/TestSuite_Main.py index f1e66ac492..8fc9838b52 100644 --- a/AutomatedTesting/Gem/PythonTests/Atom/TestSuite_Main.py +++ b/AutomatedTesting/Gem/PythonTests/Atom/TestSuite_Main.py @@ -21,7 +21,11 @@ TEST_DIRECTORY = os.path.join(os.path.dirname(__file__), "tests") @pytest.mark.parametrize("launcher_platform", ['windows_editor']) class TestAutomation(EditorTestSuite): - enable_prefab_system = False + enable_prefab_system = True + + @pytest.mark.test_case_id("C36529679") + class AtomLevelLoadTest_Editor(EditorSharedTest): + from Atom.tests import hydra_Atom_LevelLoadTest as test_module @pytest.mark.test_case_id("C36525657") class AtomEditorComponents_BloomAdded(EditorSharedTest): @@ -120,6 +124,14 @@ class TestAutomation(EditorTestSuite): class AtomEditorComponents_SSAOAdded(EditorSharedTest): from Atom.tests import hydra_AtomEditorComponents_SSAOAdded as test_module + @pytest.mark.test_case_id("C36529666") + class AtomEditorComponentsLevel_DiffuseGlobalIlluminationAdded(EditorSharedTest): + from Atom.tests import hydra_AtomEditorComponentsLevel_DiffuseGlobalIlluminationAdded as test_module + + @pytest.mark.test_case_id("C36525660") + class AtomEditorComponentsLevel_DisplayMapperAdded(EditorSharedTest): + from Atom.tests import hydra_AtomEditorComponentsLevel_DisplayMapperAdded as test_module + class ShaderAssetBuilder_RecompilesShaderAsChainOfDependenciesChanges(EditorSharedTest): from Atom.tests import hydra_ShaderAssetBuilder_RecompilesShaderAsChainOfDependenciesChanges as test_module diff --git a/AutomatedTesting/Gem/PythonTests/Atom/TestSuite_Sandbox.py b/AutomatedTesting/Gem/PythonTests/Atom/TestSuite_Sandbox.py index bd0477a1db..5299e55a2b 100644 --- a/AutomatedTesting/Gem/PythonTests/Atom/TestSuite_Sandbox.py +++ b/AutomatedTesting/Gem/PythonTests/Atom/TestSuite_Sandbox.py @@ -26,13 +26,3 @@ class TestAutomation(EditorTestSuite): @pytest.mark.test_case_id("C36525660") class AtomEditorComponents_DisplayMapperAdded(EditorSharedTest): from Atom.tests import hydra_AtomEditorComponents_DisplayMapperAdded as test_module - - # this test causes editor to crash when using slices. once automation transitions to prefabs it should pass - @pytest.mark.test_case_id("C36529666") - class AtomEditorComponentsLevel_DiffuseGlobalIlluminationAdded(EditorSharedTest): - from Atom.tests import hydra_AtomEditorComponentsLevel_DiffuseGlobalIlluminationAdded as test_module - - # this test causes editor to crash when using slices. once automation transitions to prefabs it should pass - @pytest.mark.test_case_id("C36525660") - class AtomEditorComponentsLevel_DisplayMapperAdded(EditorSharedTest): - from Atom.tests import hydra_AtomEditorComponentsLevel_DisplayMapperAdded as test_module diff --git a/AutomatedTesting/Gem/PythonTests/Atom/atom_utils/atom_constants.py b/AutomatedTesting/Gem/PythonTests/Atom/atom_utils/atom_constants.py index e6d6ac7fb1..339108090f 100644 --- a/AutomatedTesting/Gem/PythonTests/Atom/atom_utils/atom_constants.py +++ b/AutomatedTesting/Gem/PythonTests/Atom/atom_utils/atom_constants.py @@ -32,6 +32,8 @@ GLOBAL_ILLUMINATION_QUALITY = { 'High': 2, } +# Level list used in Editor Level Load Test +LEVEL_LIST = ["hermanubis", "hermanubis_high", "macbeth_shaderballs", "PbrMaterialChart", "ShadowTest", "Sponza"] class AtomComponentProperties: """ @@ -195,11 +197,13 @@ class AtomComponentProperties: def entity_reference(property: str = 'name') -> str: """ Entity Reference component properties. + - 'EntityIdReferences' component container of entityId references. Initially empty. :param property: From the last element of the property tree path. Default 'name' for component name string. :return: Full property path OR component name if no property specified. """ properties = { 'name': 'Entity Reference', + 'EntityIdReferences': 'Controller|Configuration|EntityIdReferences', } return properties[property] diff --git a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponentsLevel_DiffuseGlobalIlluminationAdded.py b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponentsLevel_DiffuseGlobalIlluminationAdded.py index ddcd5c3c46..0c9b39e354 100644 --- a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponentsLevel_DiffuseGlobalIlluminationAdded.py +++ b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponentsLevel_DiffuseGlobalIlluminationAdded.py @@ -60,7 +60,7 @@ def AtomEditorComponentsLevel_DiffuseGlobalIllumination_AddedToEntity(): # Test setup begins. # Setup: Wait for Editor idle loop before executing Python hydra scripts then open "Base" level. TestHelper.init_idle() - TestHelper.open_level("", "Base") + TestHelper.open_level("Graphics", "base_empty") # Test steps begin. # 1. Add Diffuse Global Illumination level component to the level entity. @@ -86,10 +86,10 @@ def AtomEditorComponentsLevel_DiffuseGlobalIllumination_AddedToEntity(): # 4. Set Quality Level property to Low diffuse_global_illumination_component.set_component_property_value( - AtomComponentProperties.diffuse_global_illumination('Quality Level', GLOBAL_ILLUMINATION_QUALITY['Low'])) + AtomComponentProperties.diffuse_global_illumination('Quality Level'), GLOBAL_ILLUMINATION_QUALITY['Low']) quality = diffuse_global_illumination_component.get_component_property_value( AtomComponentProperties.diffuse_global_illumination('Quality Level')) - Report.result(diffuse_global_illumination_quality, quality == GLOBAL_ILLUMINATION_QUALITY['Low']) + Report.result(Tests.diffuse_global_illumination_quality, quality == GLOBAL_ILLUMINATION_QUALITY['Low']) # 5. Enter/Exit game mode. TestHelper.enter_game_mode(Tests.enter_game_mode) diff --git a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponentsLevel_DisplayMapperAdded.py b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponentsLevel_DisplayMapperAdded.py index c050dd76d4..f9660957bb 100644 --- a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponentsLevel_DisplayMapperAdded.py +++ b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponentsLevel_DisplayMapperAdded.py @@ -67,7 +67,7 @@ def AtomEditorComponentsLevel_DisplayMapper_AddedToEntity(): # Test setup begins. # Setup: Wait for Editor idle loop before executing Python hydra scripts then open "Base" level. TestHelper.init_idle() - TestHelper.open_level("", "Base") + TestHelper.open_level("Graphics", "base_empty") # Test steps begin. # 1. Add Display Mapper level component to the level entity. @@ -102,7 +102,7 @@ def AtomEditorComponentsLevel_DisplayMapper_AddedToEntity(): display_mapper_component.set_component_property_value( AtomComponentProperties.display_mapper('Enable LDR color grading LUT'), True) Report.result( - Test.enable_ldr_color_grading_lut, + Tests.enable_ldr_color_grading_lut, display_mapper_component.get_component_property_value( AtomComponentProperties.display_mapper('Enable LDR color grading LUT')) is True) diff --git a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_BloomAdded.py b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_BloomAdded.py index 56b22eb20d..ce29a1de88 100644 --- a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_BloomAdded.py +++ b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_BloomAdded.py @@ -97,7 +97,7 @@ def AtomEditorComponents_Bloom_AddedToEntity(): # Test setup begins. # Setup: Wait for Editor idle loop before executing Python hydra scripts then open "Base" level. TestHelper.init_idle() - TestHelper.open_level("", "Base") + TestHelper.open_level("Graphics", "base_empty") # Test steps begin. # 1. Create an Bloom entity with no components. @@ -170,10 +170,12 @@ def AtomEditorComponents_Bloom_AddedToEntity(): # 13. UNDO deletion. general.undo() + general.idle_wait_frames(1) Report.result(Tests.deletion_undo, bloom_entity.exists()) # 14. REDO deletion. general.redo() + general.idle_wait_frames(1) Report.result(Tests.deletion_redo, not bloom_entity.exists()) # 15. Look for errors and asserts. diff --git a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_DecalAdded.py b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_DecalAdded.py index e840cf3cf1..eb5e24e3a6 100644 --- a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_DecalAdded.py +++ b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_DecalAdded.py @@ -95,7 +95,7 @@ def AtomEditorComponents_Decal_AddedToEntity(): # Test setup begins. # Setup: Wait for Editor idle loop before executing Python hydra scripts then open "Base" level. TestHelper.init_idle() - TestHelper.open_level("", "Base") + TestHelper.open_level("Graphics", "base_empty") # Test steps begin. # 1. Create a Decal entity with no components. @@ -162,6 +162,7 @@ def AtomEditorComponents_Decal_AddedToEntity(): # 11. REDO deletion. general.redo() + general.idle_wait_frames(1) Report.result(Tests.deletion_redo, not decal_entity.exists()) # 12. Look for errors and asserts. diff --git a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_DeferredFogAdded.py b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_DeferredFogAdded.py index 71163ece94..f1578cbf8d 100644 --- a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_DeferredFogAdded.py +++ b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_DeferredFogAdded.py @@ -97,7 +97,7 @@ def AtomEditorComponents_DeferredFog_AddedToEntity(): # Test setup begins. # Setup: Wait for Editor idle loop before executing Python hydra scripts then open "Base" level. TestHelper.init_idle() - TestHelper.open_level("", "Base") + TestHelper.open_level("Graphics", "base_empty") # Test steps begin. # 1. Create an Deferred Fog entity with no components. @@ -174,10 +174,12 @@ def AtomEditorComponents_DeferredFog_AddedToEntity(): # 13. UNDO deletion. general.undo() + general.idle_wait_frames(1) Report.result(Tests.deletion_undo, deferred_fog_entity.exists()) # 14. REDO deletion. general.redo() + general.idle_wait_frames(1) Report.result(Tests.deletion_redo, not deferred_fog_entity.exists()) # 15. Look for errors and asserts. diff --git a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_DepthOfFieldAdded.py b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_DepthOfFieldAdded.py index e2c5f9c77d..3913420981 100644 --- a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_DepthOfFieldAdded.py +++ b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_DepthOfFieldAdded.py @@ -107,7 +107,7 @@ def AtomEditorComponents_DepthOfField_AddedToEntity(): # Test setup begins. # Setup: Wait for Editor idle loop before executing Python hydra scripts then open "Base" level. TestHelper.init_idle() - TestHelper.open_level("", "Base") + TestHelper.open_level("Graphics", "base_empty") # Test steps begin. # 1. Create a DepthOfField entity with no components. @@ -189,10 +189,12 @@ def AtomEditorComponents_DepthOfField_AddedToEntity(): # 15. UNDO deletion. general.undo() + general.idle_wait_frames(1) Report.result(Tests.deletion_undo, depth_of_field_entity.exists()) # 16. REDO deletion. general.redo() + general.idle_wait_frames(1) Report.result(Tests.deletion_redo, not depth_of_field_entity.exists()) # 17. Look for errors and asserts. diff --git a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_DiffuseProbeGridAdded.py b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_DiffuseProbeGridAdded.py index f42c091057..04b4f7876b 100644 --- a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_DiffuseProbeGridAdded.py +++ b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_DiffuseProbeGridAdded.py @@ -90,7 +90,7 @@ def AtomEditorComponents_DiffuseProbeGrid_AddedToEntity(): # Test setup begins. # Setup: Wait for Editor idle loop before executing Python hydra scripts then open "Base" level. TestHelper.init_idle() - TestHelper.open_level("", "Base") + TestHelper.open_level("Graphics", "base_empty") # Test steps begin. # 1. Create a Diffuse Probe Grid entity with no components. @@ -168,10 +168,12 @@ def AtomEditorComponents_DiffuseProbeGrid_AddedToEntity(): # 12. UNDO deletion. general.undo() + general.idle_wait_frames(1) Report.result(Tests.deletion_undo, diffuse_probe_grid_entity.exists()) # 13. REDO deletion. general.redo() + general.idle_wait_frames(1) Report.result(Tests.deletion_redo, not diffuse_probe_grid_entity.exists()) # 14. Look for errors or asserts. diff --git a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_DirectionalLightAdded.py b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_DirectionalLightAdded.py index f3ffc0f366..19cfbedcd5 100644 --- a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_DirectionalLightAdded.py +++ b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_DirectionalLightAdded.py @@ -95,7 +95,7 @@ def AtomEditorComponents_DirectionalLight_AddedToEntity(): # Test setup begins. # Setup: Wait for Editor idle loop before executing Python hydra scripts then open "Base" level. TestHelper.init_idle() - TestHelper.open_level("", "Base") + TestHelper.open_level("Graphics", "base_empty") # Test steps begin. # 1. Create a Directional Light entity with no components. @@ -168,10 +168,12 @@ def AtomEditorComponents_DirectionalLight_AddedToEntity(): # 12. UNDO deletion. general.undo() + general.idle_wait_frames(1) Report.result(Tests.deletion_undo, directional_light_entity.exists()) # 13. REDO deletion. general.redo() + general.idle_wait_frames(1) Report.result(Tests.deletion_redo, not directional_light_entity.exists()) # 14. Look for errors and asserts. diff --git a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_DisplayMapperAdded.py b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_DisplayMapperAdded.py index 558d69046e..d3ea669eab 100644 --- a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_DisplayMapperAdded.py +++ b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_DisplayMapperAdded.py @@ -91,7 +91,7 @@ def AtomEditorComponents_DisplayMapper_AddedToEntity(): # Test setup begins. # Setup: Wait for Editor idle loop before executing Python hydra scripts then open "Base" level. TestHelper.init_idle() - TestHelper.open_level("", "Base") + TestHelper.open_level("Graphics", "base_empty") # Test steps begin. # 1. Create a Display Mapper entity with no components. @@ -166,10 +166,12 @@ def AtomEditorComponents_DisplayMapper_AddedToEntity(): # 11. UNDO deletion. general.undo() + general.idle_wait_frames(1) Report.result(Tests.deletion_undo, display_mapper_entity.exists()) # 12. REDO deletion. general.redo() + general.idle_wait_frames(1) Report.result(Tests.deletion_redo, not display_mapper_entity.exists()) # 13. Look for errors and asserts. diff --git a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_EntityReferenceAdded.py b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_EntityReferenceAdded.py index dddcca64fa..984774cd37 100644 --- a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_EntityReferenceAdded.py +++ b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_EntityReferenceAdded.py @@ -9,37 +9,58 @@ SPDX-License-Identifier: Apache-2.0 OR MIT class Tests: creation_undo = ( "UNDO Entity creation success", - "UNDO Entity creation failed") + "P0: UNDO Entity creation failed") creation_redo = ( "REDO Entity creation success", - "REDO Entity creation failed") + "P0: REDO Entity creation failed") entity_reference_creation = ( "Entity Reference Entity successfully created", - "Entity Reference Entity failed to be created") + "P0: Entity Reference Entity failed to be created") entity_reference_component = ( "Entity has an Entity Reference component", - "Entity failed to find Entity Reference component") + "P0: Entity failed to find Entity Reference component") enter_game_mode = ( "Entered game mode", - "Failed to enter game mode") + "P0: Failed to enter game mode") exit_game_mode = ( "Exited game mode", - "Couldn't exit game mode") + "P0: Couldn't exit game mode") is_visible = ( "Entity is visible", - "Entity was not visible") + "P0: Entity was not visible") is_hidden = ( "Entity is hidden", - "Entity was not hidden") + "P0: Entity was not hidden") entity_deleted = ( "Entity deleted", - "Entity was not deleted") + "P0: Entity was not deleted") deletion_undo = ( "UNDO deletion success", - "UNDO deletion failed") + "P0: UNDO deletion failed") deletion_redo = ( "REDO deletion success", - "REDO deletion failed") + "P0: REDO deletion failed") + entity_id_references_is_container = ( + "EntityIdReferences is a container property", + "P1: EntityIdReferences is NOT a container property") + container_append = ( + "EntityIdReferences append succeeded", + "P1: EntityIdReferences append did not succeed") + container_add = ( + "EntityIdReferences add succeeded", + "P1: EntityIdReferences add did not succeed") + container_update = ( + "EntityIdReferences update succeeded", + "P1: EntityIdReferences update did not succeed") + container_remove = ( + "EntityIdReferences remove succeeded", + "P1: EntityIdReferences remove did not succeed") + container_reset = ( + "EntityIdReferences reset succeeded", + "P1: EntityIdReferences reset did not succeed") + entity_reference_component_removed = ( + "Entity Reference component removed from entity", + "P1: Entity Reference component NOT removed from entity") def AtomEditorComponents_EntityReference_AddedToEntity(): @@ -60,13 +81,21 @@ def AtomEditorComponents_EntityReference_AddedToEntity(): 2) Add Entity Reference component to Entity Reference entity. 3) UNDO the entity creation and component addition. 4) REDO the entity creation and component addition. - 5) Enter/Exit game mode. - 6) Test IsHidden. - 7) Test IsVisible. - 8) Delete Entity Reference entity. - 9) UNDO deletion. - 10) REDO deletion. - 11) Look for errors. + 5) 'EntityIdReferences' is a container property + 6) Append item to 'EntityIdReferences' + 7) Add item to 'EntityIdReferences' + 8) Update item in 'EntityIdReferences' + 9) Remove item from 'EntityIdReferences' + 10) Reset the container property then put one entity reference back for further tests + 11) Remove component + 12) UNDO component remove + 13) Enter/Exit game mode. + 14) Test IsHidden. + 15) Test IsVisible. + 16) Delete Entity Reference entity. + 17) UNDO deletion. + 18) REDO deletion. + 19) Look for errors. :return: None """ @@ -81,7 +110,7 @@ def AtomEditorComponents_EntityReference_AddedToEntity(): # Test setup begins. # Setup: Wait for Editor idle loop before executing Python hydra scripts then open "Base" level. TestHelper.init_idle() - TestHelper.open_level("", "Base") + TestHelper.open_level("Graphics", "base_empty") # Test steps begin. # 1. Create an Entity Reference entity with no components. @@ -119,33 +148,107 @@ def AtomEditorComponents_EntityReference_AddedToEntity(): general.idle_wait_frames(1) Report.result(Tests.creation_redo, entity_reference_entity.exists()) - # 5. Enter/Exit game mode. + # Entities for EntityIdReferences tests + test_1 = EditorEntity.create_editor_entity('test_1') + test_2 = EditorEntity.create_editor_entity('test_2') + test_3 = EditorEntity.create_editor_entity('test_3') + + # 5. 'EntityIdReferences' is a container property + Report.result( + Tests.entity_id_references_is_container, + entity_reference_component.is_property_container( + AtomComponentProperties.entity_reference('EntityIdReferences'))) + + # 6. Append item to 'EntityIdReferences' + entity_reference_component.append_container_item( + AtomComponentProperties.entity_reference('EntityIdReferences'), test_1.id) + Report.result( + Tests.container_append, + entity_reference_component.get_container_item( + AtomComponentProperties.entity_reference('EntityIdReferences'), 0) == test_1.id) + + # 7. Add item to 'EntityIdReferences' + entity_reference_component.add_container_item( + AtomComponentProperties.entity_reference('EntityIdReferences'), 1, test_1.id) + Report.result( + Tests.container_add, + entity_reference_component.get_container_count( + AtomComponentProperties.entity_reference('EntityIdReferences')) == 2) + + # 8. Update item in 'EntityIdReferences' + entity_reference_component.update_container_item( + AtomComponentProperties.entity_reference('EntityIdReferences'), 1, test_2.id) + Report.result( + Tests.container_update, + entity_reference_component.get_container_item( + AtomComponentProperties.entity_reference('EntityIdReferences'), 1) == test_2.id) + + # 9. Remove item from 'EntityIdReferences' + entity_reference_component.append_container_item( + AtomComponentProperties.entity_reference('EntityIdReferences'), test_3.id) + count_before = entity_reference_component.get_container_count( + AtomComponentProperties.entity_reference('EntityIdReferences')) + entity_reference_component.remove_container_item( + AtomComponentProperties.entity_reference('EntityIdReferences'), 1) + count_after = entity_reference_component.get_container_count( + AtomComponentProperties.entity_reference('EntityIdReferences')) + Report.result( + Tests.container_remove, + ((count_before == 3) and (count_after == 2) and + (entity_reference_component.get_container_item( + AtomComponentProperties.entity_reference('EntityIdReferences'), 1) == test_3.id))) + + # 10. Reset the container property then put one entity reference back for further tests + entity_reference_component.reset_container(AtomComponentProperties.entity_reference('EntityIdReferences')) + general.idle_wait_frames(1) + Report.result( + Tests.container_reset, + entity_reference_component.get_container_count( + AtomComponentProperties.entity_reference('EntityIdReferences')) == 0) + entity_reference_component.append_container_item( + AtomComponentProperties.entity_reference('EntityIdReferences'), test_1.id) + + # 11. Remove component + entity_reference_entity.remove_component(AtomComponentProperties.entity_reference()) + general.idle_wait_frames(1) + Report.result(Tests.entity_reference_component_removed, not entity_reference_entity.has_component( + AtomComponentProperties.entity_reference())) + + # 12. UNDO component remove + general.undo() + general.idle_wait_frames(1) + Report.result(Tests.entity_reference_component, entity_reference_entity.has_component( + AtomComponentProperties.entity_reference())) + + # 13. Enter/Exit game mode. TestHelper.enter_game_mode(Tests.enter_game_mode) general.idle_wait_frames(1) TestHelper.exit_game_mode(Tests.exit_game_mode) - # 6. Test IsHidden. + # 14. Test IsHidden. entity_reference_entity.set_visibility_state(False) Report.result(Tests.is_hidden, entity_reference_entity.is_hidden() is True) - # 7. Test IsVisible. + # 15. Test IsVisible. entity_reference_entity.set_visibility_state(True) general.idle_wait_frames(1) Report.result(Tests.is_visible, entity_reference_entity.is_visible() is True) - # 8. Delete Entity Reference entity. + # 16. Delete Entity Reference entity. entity_reference_entity.delete() Report.result(Tests.entity_deleted, not entity_reference_entity.exists()) - # 9. UNDO deletion. + # 17. UNDO deletion. general.undo() + general.idle_wait_frames(1) Report.result(Tests.deletion_undo, entity_reference_entity.exists()) - # 10. REDO deletion. + # 18. REDO deletion. general.redo() + general.idle_wait_frames(1) Report.result(Tests.deletion_redo, not entity_reference_entity.exists()) - # 11. Look for errors and asserts. + # 19. Look for errors and asserts. TestHelper.wait_for_condition(lambda: error_tracer.has_errors or error_tracer.has_asserts, 1.0) for error_info in error_tracer.errors: Report.info(f"Error: {error_info.filename} {error_info.function} | {error_info.message}") diff --git a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_ExposureControlAdded.py b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_ExposureControlAdded.py index 6fa9660539..f60f0e18be 100644 --- a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_ExposureControlAdded.py +++ b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_ExposureControlAdded.py @@ -101,7 +101,7 @@ def AtomEditorComponents_ExposureControl_AddedToEntity(): # Test setup begins. # Setup: Wait for Editor idle loop before executing Python hydra scripts then open "Base" level. TestHelper.init_idle() - TestHelper.open_level("", "Base") + TestHelper.open_level("Graphics", "base_empty") # Test steps begin. # 1. Creation of Exposure Control entity with no components. @@ -169,10 +169,12 @@ def AtomEditorComponents_ExposureControl_AddedToEntity(): # 12. UNDO deletion. general.undo() + general.idle_wait_frames(1) Report.result(Tests.deletion_undo, exposure_control_entity.exists()) # 13. REDO deletion. general.redo() + general.idle_wait_frames(1) Report.result(Tests.deletion_redo, not exposure_control_entity.exists()) # 14. Look for errors and asserts. diff --git a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_GlobalSkylightIBLAdded.py b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_GlobalSkylightIBLAdded.py index 7f0c38e289..0e8e6fa43e 100644 --- a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_GlobalSkylightIBLAdded.py +++ b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_GlobalSkylightIBLAdded.py @@ -99,7 +99,7 @@ def AtomEditorComponents_GlobalSkylightIBL_AddedToEntity(): # Test setup begins. # Setup: Wait for Editor idle loop before executing Python hydra scripts then open "Base" level. TestHelper.init_idle() - TestHelper.open_level("", "Base") + TestHelper.open_level("Graphics", "base_empty") # Test steps begin. # 1. Create a Global Skylight (IBL) entity with no components. @@ -176,10 +176,12 @@ def AtomEditorComponents_GlobalSkylightIBL_AddedToEntity(): # 11. UNDO deletion. general.undo() + general.idle_wait_frames(1) Report.result(Tests.deletion_undo, global_skylight_entity.exists()) # 12. REDO deletion. general.redo() + general.idle_wait_frames(1) Report.result(Tests.deletion_redo, not global_skylight_entity.exists()) # 13. Look for errors and asserts. diff --git a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_GridAdded.py b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_GridAdded.py index a77a1f50a4..3c6d261f22 100644 --- a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_GridAdded.py +++ b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_GridAdded.py @@ -82,7 +82,7 @@ def AtomEditorComponents_Grid_AddedToEntity(): # Test setup begins. # Setup: Wait for Editor idle loop before executing Python hydra scripts then open "Base" level. TestHelper.init_idle() - TestHelper.open_level("", "Base") + TestHelper.open_level("Graphics", "base_empty") # Test steps begin. # 1. Create a Grid entity with no components. @@ -139,10 +139,12 @@ def AtomEditorComponents_Grid_AddedToEntity(): # 9. UNDO deletion. general.undo() + general.idle_wait_frames(1) Report.result(Tests.deletion_undo, grid_entity.exists()) # 10. REDO deletion. general.redo() + general.idle_wait_frames(1) Report.result(Tests.deletion_redo, not grid_entity.exists()) # 11. Look for errors or asserts. diff --git a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_HDRColorGradingAdded.py b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_HDRColorGradingAdded.py index 4972079fcd..5846206e50 100644 --- a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_HDRColorGradingAdded.py +++ b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_HDRColorGradingAdded.py @@ -96,7 +96,7 @@ def AtomEditorComponents_HDRColorGrading_AddedToEntity(): # Test setup begins. # Setup: Wait for Editor idle loop before executing Python hydra scripts then open "Base" level. TestHelper.init_idle() - TestHelper.open_level("", "Base") + TestHelper.open_level("Graphics", "base_empty") # Test steps begin. # 1. Create an HDR Color Grading entity with no components. @@ -173,10 +173,12 @@ def AtomEditorComponents_HDRColorGrading_AddedToEntity(): # 13. UNDO deletion. general.undo() + general.idle_wait_frames(1) Report.result(Tests.deletion_undo, hdr_color_grading_entity.exists()) # 14. REDO deletion. general.redo() + general.idle_wait_frames(1) Report.result(Tests.deletion_redo, not hdr_color_grading_entity.exists()) # 15. Look for errors and asserts. diff --git a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_HDRiSkyboxAdded.py b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_HDRiSkyboxAdded.py index 0f96bc5424..fc093b60db 100644 --- a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_HDRiSkyboxAdded.py +++ b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_HDRiSkyboxAdded.py @@ -87,7 +87,7 @@ def AtomEditorComponents_HDRiSkybox_AddedToEntity(): # Test setup begins. # Setup: Wait for Editor idle loop before executing Python hydra scripts then open "Base" level. TestHelper.init_idle() - TestHelper.open_level("", "Base") + TestHelper.open_level("Graphics", "base_empty") # Test steps begin. # 1. Create an HDRi Skybox with no components. @@ -158,10 +158,12 @@ def AtomEditorComponents_HDRiSkybox_AddedToEntity(): # 10. UNDO deletion. general.undo() + general.idle_wait_frames(1) Report.result(Tests.deletion_undo, hdri_skybox_entity.exists()) # 11. REDO deletion. general.redo() + general.idle_wait_frames(1) Report.result(Tests.deletion_redo, not hdri_skybox_entity.exists()) # 12. Look for errors or asserts. diff --git a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_LightAdded.py b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_LightAdded.py index 249671556d..75a04612a3 100644 --- a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_LightAdded.py +++ b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_LightAdded.py @@ -89,7 +89,7 @@ def AtomEditorComponents_Light_AddedToEntity(): # Test setup begins. # Setup: Wait for Editor idle loop before executing Python hydra scripts then open "Base" level. TestHelper.init_idle() - TestHelper.open_level("", "Base") + TestHelper.open_level("Graphics", "base_empty") # Test steps begin. # 1. Create a Light entity with no components. @@ -144,10 +144,12 @@ def AtomEditorComponents_Light_AddedToEntity(): # 9. UNDO deletion. general.undo() + general.idle_wait_frames(1) Report.result(Tests.deletion_undo, light_entity.exists()) # 10. REDO deletion. general.redo() + general.idle_wait_frames(1) Report.result(Tests.deletion_redo, not light_entity.exists()) # 11. Look for errors asserts. diff --git a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_LookModificationAdded.py b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_LookModificationAdded.py index afb8033426..149af73151 100644 --- a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_LookModificationAdded.py +++ b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_LookModificationAdded.py @@ -104,7 +104,7 @@ def AtomEditorComponents_LookModification_AddedToEntity(): # Test setup begins. # Setup: Wait for Editor idle loop before executing Python hydra scripts then open "Base" level. TestHelper.init_idle() - TestHelper.open_level("", "Base") + TestHelper.open_level("Graphics", "base_empty") # Test steps begin. # 1. Create an Look Modification entity with no components. @@ -192,10 +192,12 @@ def AtomEditorComponents_LookModification_AddedToEntity(): # 14. UNDO deletion. general.undo() + general.idle_wait_frames(1) Report.result(Tests.deletion_undo, look_modification_entity.exists()) # 15. REDO deletion. general.redo() + general.idle_wait_frames(1) Report.result(Tests.deletion_redo, not look_modification_entity.exists()) # 16. Look for errors and asserts. diff --git a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_MaterialAdded.py b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_MaterialAdded.py index c613bb23e7..919a6753f4 100644 --- a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_MaterialAdded.py +++ b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_MaterialAdded.py @@ -102,7 +102,7 @@ def AtomEditorComponents_Material_AddedToEntity(): # Test setup begins. # Setup: Wait for Editor idle loop before executing Python hydra scripts then open "Base" level. TestHelper.init_idle() - TestHelper.open_level("", "Base") + TestHelper.open_level("Graphics", "base_empty") # Test steps begin. # 1. Create a Material entity with no components. @@ -184,10 +184,12 @@ def AtomEditorComponents_Material_AddedToEntity(): # 16. UNDO deletion. general.undo() + general.idle_wait_frames(1) Report.result(Tests.deletion_undo, material_entity.exists()) # 17. REDO deletion. general.redo() + general.idle_wait_frames(1) Report.result(Tests.deletion_redo, not material_entity.exists()) # 18. Look for errors or asserts. diff --git a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_MeshAdded.py b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_MeshAdded.py index 9d56753961..a87ee75b53 100644 --- a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_MeshAdded.py +++ b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_MeshAdded.py @@ -87,7 +87,7 @@ def AtomEditorComponents_Mesh_AddedToEntity(): # Test setup begins. # Setup: Wait for Editor idle loop before executing Python hydra scripts then open "Base" level. TestHelper.init_idle() - TestHelper.open_level("", "Base") + TestHelper.open_level("Graphics", "base_empty") # Test steps begin. # 1. Create a Mesh entity with no components. @@ -151,10 +151,12 @@ def AtomEditorComponents_Mesh_AddedToEntity(): # 10. UNDO deletion. general.undo() + general.idle_wait_frames(1) Report.result(Tests.deletion_undo, mesh_entity.exists()) # 11. REDO deletion. general.redo() + general.idle_wait_frames(1) Report.result(Tests.deletion_redo, not mesh_entity.exists()) # 12. Look for errors or asserts. diff --git a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_OcclusionCullingPlaneAdded.py b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_OcclusionCullingPlaneAdded.py index 4226ae3dfe..56bb5eb68c 100644 --- a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_OcclusionCullingPlaneAdded.py +++ b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_OcclusionCullingPlaneAdded.py @@ -80,7 +80,7 @@ def AtomEditorComponents_OcclusionCullingPlane_AddedToEntity(): # Test setup begins. # Setup: Wait for Editor idle loop before executing Python hydra scripts then open "Base" level. TestHelper.init_idle() - TestHelper.open_level("", "Base") + TestHelper.open_level("Graphics", "base_empty") # Test steps begin. # 1. Create a occlusion culling plane entity with no components. @@ -140,10 +140,12 @@ def AtomEditorComponents_OcclusionCullingPlane_AddedToEntity(): # 9. UNDO deletion. general.undo() + general.idle_wait_frames(1) Report.result(Tests.deletion_undo, occlusion_culling_plane_entity.exists()) # 10. REDO deletion. general.redo() + general.idle_wait_frames(1) Report.result(Tests.deletion_redo, not occlusion_culling_plane_entity.exists()) # 11. Look for errors or asserts. diff --git a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_PhysicalSkyAdded.py b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_PhysicalSkyAdded.py index fa8c626016..e0c558811e 100644 --- a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_PhysicalSkyAdded.py +++ b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_PhysicalSkyAdded.py @@ -89,7 +89,7 @@ def AtomEditorComponents_PhysicalSky_AddedToEntity(): # Test setup begins. # Setup: Wait for Editor idle loop before executing Python hydra scripts then open "Base" level. TestHelper.init_idle() - TestHelper.open_level("", "Base") + TestHelper.open_level("Graphics", "base_empty") # Test steps begin. # 1. Create a Physical Sky entity with no components. @@ -146,10 +146,12 @@ def AtomEditorComponents_PhysicalSky_AddedToEntity(): # 9. UNDO deletion. general.undo() + general.idle_wait_frames(1) Report.result(Tests.deletion_undo, physical_sky_entity.exists()) # 10. REDO deletion. general.redo() + general.idle_wait_frames(1) Report.result(Tests.deletion_redo, not physical_sky_entity.exists()) # 11. Look for errors and asserts. diff --git a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_PostFXGradientWeightModifierAdded.py b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_PostFXGradientWeightModifierAdded.py index 6e4ae2d9ac..b36267433f 100644 --- a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_PostFXGradientWeightModifierAdded.py +++ b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_PostFXGradientWeightModifierAdded.py @@ -92,7 +92,7 @@ def AtomEditorComponents_PostFXGradientWeightModifier_AddedToEntity(): # Test setup begins. # Setup: Wait for Editor idle loop before executing Python hydra scripts then open "Base" level. TestHelper.init_idle() - TestHelper.open_level("", "Base") + TestHelper.open_level("Graphics", "base_empty") # Test steps begin. # 1. Create a PostFX Gradient Weight Modifier entity with no components. @@ -162,10 +162,12 @@ def AtomEditorComponents_PostFXGradientWeightModifier_AddedToEntity(): # 12. UNDO deletion. general.undo() + general.idle_wait_frames(1) Report.result(Tests.deletion_undo, postfx_gradient_weight_entity.exists()) # 13. REDO deletion. general.redo() + general.idle_wait_frames(1) Report.result(Tests.deletion_redo, not postfx_gradient_weight_entity.exists()) # 14. Look for errors or asserts. diff --git a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_PostFXLayerAdded.py b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_PostFXLayerAdded.py index efef4c0a43..07fffb9bde 100644 --- a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_PostFXLayerAdded.py +++ b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_PostFXLayerAdded.py @@ -80,7 +80,7 @@ def AtomEditorComponents_postfx_layer_AddedToEntity(): # Test setup begins. # Setup: Wait for Editor idle loop before executing Python hydra scripts then open "Base" level. TestHelper.init_idle() - TestHelper.open_level("", "Base") + TestHelper.open_level("Graphics", "base_empty") # Test steps begin. # 1. Create a PostFX Layer entity with no components. @@ -137,10 +137,12 @@ def AtomEditorComponents_postfx_layer_AddedToEntity(): # 9. UNDO deletion. general.undo() + general.idle_wait_frames(1) Report.result(Tests.deletion_undo, postfx_layer_entity.exists()) # 10. REDO deletion. general.redo() + general.idle_wait_frames(1) Report.result(Tests.deletion_redo, not postfx_layer_entity.exists()) # 11. Look for errors or asserts. diff --git a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_PostFXRadiusWeightModifierAdded.py b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_PostFXRadiusWeightModifierAdded.py index 228ddfcdc5..616233d2d2 100644 --- a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_PostFXRadiusWeightModifierAdded.py +++ b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_PostFXRadiusWeightModifierAdded.py @@ -92,7 +92,7 @@ def AtomEditorComponents_PostFXRadiusWeightModifier_AddedToEntity(): # Test setup begins. # Setup: Wait for Editor idle loop before executing Python hydra scripts then open "Base" level. TestHelper.init_idle() - TestHelper.open_level("", "Base") + TestHelper.open_level("Graphics", "base_empty") # Test steps begin. # 1. Create a Post FX Radius Weight Modifier entity with no components. @@ -161,10 +161,12 @@ def AtomEditorComponents_PostFXRadiusWeightModifier_AddedToEntity(): # 12. UNDO deletion. general.undo() + general.idle_wait_frames(1) Report.result(Tests.deletion_undo, postfx_radius_weight_entity.exists()) # 13. REDO deletion. general.redo() + general.idle_wait_frames(1) Report.result(Tests.deletion_redo, not postfx_radius_weight_entity.exists()) # 14. Look for errors and asserts. diff --git a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_PostFxShapeWeightModifierAdded.py b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_PostFxShapeWeightModifierAdded.py index 0a37ac6bf7..5f7d571a18 100644 --- a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_PostFxShapeWeightModifierAdded.py +++ b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_PostFxShapeWeightModifierAdded.py @@ -98,7 +98,7 @@ def AtomEditorComponents_postfx_shape_weight_AddedToEntity(): # Test setup begins. # Setup: Wait for Editor idle loop before executing Python hydra scripts then open "Base" level. TestHelper.init_idle() - TestHelper.open_level("", "Base") + TestHelper.open_level("Graphics", "base_empty") # Test steps begin. # 1. Create a PostFx Shape Weight Modifier entity with no components. @@ -188,10 +188,12 @@ def AtomEditorComponents_postfx_shape_weight_AddedToEntity(): # 15. UNDO deletion. general.undo() + general.idle_wait_frames(1) Report.result(Tests.deletion_undo, postfx_shape_weight_entity.exists()) # 16. REDO deletion. general.redo() + general.idle_wait_frames(1) Report.result(Tests.deletion_redo, not postfx_shape_weight_entity.exists()) # 17. Look for errors or asserts. diff --git a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_ReflectionProbeAdded.py b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_ReflectionProbeAdded.py index 70adf9143a..85156b4db6 100644 --- a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_ReflectionProbeAdded.py +++ b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_ReflectionProbeAdded.py @@ -97,7 +97,7 @@ def AtomEditorComponents_ReflectionProbe_AddedToEntity(): # Test setup begins. # Setup: Wait for Editor idle loop before executing Python hydra scripts then open "Base" level. TestHelper.init_idle() - TestHelper.open_level("", "Base") + TestHelper.open_level("Graphics", "base_empty") # Test steps begin. # 1. Create a Reflection Probe entity with no components. @@ -183,10 +183,12 @@ def AtomEditorComponents_ReflectionProbe_AddedToEntity(): # 13. UNDO deletion. general.undo() + general.idle_wait_frames(1) Report.result(Tests.deletion_undo, reflection_probe_entity.exists()) # 14. REDO deletion. general.redo() + general.idle_wait_frames(1) Report.result(Tests.deletion_redo, not reflection_probe_entity.exists()) # 15. Look for errors or asserts. diff --git a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_SSAOAdded.py b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_SSAOAdded.py index 15f40f8b70..09f77c4a9f 100644 --- a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_SSAOAdded.py +++ b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_AtomEditorComponents_SSAOAdded.py @@ -94,7 +94,7 @@ def AtomEditorComponents_SSAO_AddedToEntity(): # Test setup begins. # Setup: Wait for Editor idle loop before executing Python hydra scripts then open "Base" level. TestHelper.init_idle() - TestHelper.open_level("", "Base") + TestHelper.open_level("Graphics", "base_empty") # Test steps begin. # 1. Create a SSAO entity with no components. @@ -163,10 +163,12 @@ def AtomEditorComponents_SSAO_AddedToEntity(): # 12. UNDO deletion. general.undo() + general.idle_wait_frames(1) Report.result(Tests.deletion_undo, ssao_entity.exists()) # 13. REDO deletion. general.redo() + general.idle_wait_frames(1) Report.result(Tests.deletion_redo, not ssao_entity.exists()) # 14. Look for errors and asserts. diff --git a/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_Atom_LevelLoadTest.py b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_Atom_LevelLoadTest.py new file mode 100644 index 0000000000..1efcbe4d01 --- /dev/null +++ b/AutomatedTesting/Gem/PythonTests/Atom/tests/hydra_Atom_LevelLoadTest.py @@ -0,0 +1,72 @@ +""" +Copyright (c) Contributors to the Open 3D Engine Project. +For complete copyright and license terms please see the LICENSE at the root of this distribution. + +SPDX-License-Identifier: Apache-2.0 OR MIT +""" + + +def Atom_LevelLoadTest(): + """ + Summary: + Loads all graphics levels within the AutomatedTesting project in editor. For each level this script will verify that + the level loads, and can enter/exit gameplay without crashing the editor. + + Test setup: + - Store all available levels in a list. + - Set up a for loop to run all checks for each level. + + Expected Behavior: + Test verifies that each level loads, enters/exits game mode, and reports success for all test actions. + + Test Steps for each level: + 1) Create tuple with level load success and failure messages + 2) Open the level using the python test tools command + 3) Verify level is loaded using a separate command, and report success/failure + 4) Enter gameplay and report result using a tuple + 5) Exit Gameplay and report result using a tuple + 6) Look for errors or asserts. + + :return: None + """ + + import azlmbr.legacy.general as general + + from editor_python_test_tools.utils import Report, Tracer, TestHelper + from Atom.atom_utils.atom_constants import LEVEL_LIST + + with Tracer() as error_tracer: + + for level in LEVEL_LIST: + + # 1. Create tuple with level load success and failure messages + level_check_tuple = (f"loaded {level}", f"failed to load {level}") + + # 2. Open the level using the python test tools command + TestHelper.init_idle() + TestHelper.open_level("Graphics", level) + + # 3. Verify level is loaded using a separate command, and report success/failure + Report.result(level_check_tuple, level == general.get_current_level_name()) + + # 4. Enter gameplay and report result using a tuple + enter_game_mode_tuple = (f"{level} entered gameplay successfully ", f"{level} failed to enter gameplay") + TestHelper.enter_game_mode(enter_game_mode_tuple) + general.idle_wait_frames(1) + + # 5. Exit gameplay and report result using a tuple + exit_game_mode_tuple = (f"{level} exited gameplay successfully ", f"{level} failed to exit gameplay") + TestHelper.exit_game_mode(exit_game_mode_tuple) + + + # 6. Look for errors or asserts. + TestHelper.wait_for_condition(lambda: error_tracer.has_errors or error_tracer.has_asserts, 1.0) + for error_info in error_tracer.errors: + Report.info(f"Error: {error_info.filename} {error_info.function} | {error_info.message}") + for assert_info in error_tracer.asserts: + Report.info(f"Assert: {assert_info.filename} {assert_info.function} | {assert_info.message}") + + +if __name__ == "__main__": + from editor_python_test_tools.utils import Report + Report.start_test(Atom_LevelLoadTest) diff --git a/AutomatedTesting/Gem/PythonTests/EditorPythonTestTools/editor_python_test_tools/editor_entity_utils.py b/AutomatedTesting/Gem/PythonTests/EditorPythonTestTools/editor_python_test_tools/editor_entity_utils.py index c3398406ab..d8d4a77a65 100644 --- a/AutomatedTesting/Gem/PythonTests/EditorPythonTestTools/editor_python_test_tools/editor_entity_utils.py +++ b/AutomatedTesting/Gem/PythonTests/EditorPythonTestTools/editor_python_test_tools/editor_entity_utils.py @@ -473,12 +473,11 @@ class EditorEntity: :param component_names: List of component names to remove :return: None """ - type_ids = EditorComponent.get_type_ids(component_names, EditorEntityType.GAME) - for type_id in type_ids: - remove_outcome = editor.EditorComponentAPIBus(bus.Broadcast, "RemoveComponents", self.id, [type_id]) - assert ( - remove_outcome.IsSuccess() - ), f"Failure: could not remove component from '{self.get_name()}'" + component_ids = [component.id for component in self.get_components_of_type(component_names)] + remove_success = editor.EditorComponentAPIBus(bus.Broadcast, "RemoveComponents", component_ids) + assert ( + remove_success + ), f"Failure: could not remove component from entity '{self.get_name()}'" def get_components_of_type(self, component_names: list) -> List[EditorComponent]: """ diff --git a/AutomatedTesting/Gem/PythonTests/EditorPythonTestTools/editor_python_test_tools/hydra_editor_utils.py b/AutomatedTesting/Gem/PythonTests/EditorPythonTestTools/editor_python_test_tools/hydra_editor_utils.py index 36fc6003f7..ac74c611a2 100644 --- a/AutomatedTesting/Gem/PythonTests/EditorPythonTestTools/editor_python_test_tools/hydra_editor_utils.py +++ b/AutomatedTesting/Gem/PythonTests/EditorPythonTestTools/editor_python_test_tools/hydra_editor_utils.py @@ -5,9 +5,9 @@ For complete copyright and license terms please see the LICENSE at the root of t SPDX-License-Identifier: Apache-2.0 OR MIT """ +import collections.abc from typing import List from math import isclose -import collections.abc import azlmbr.bus as bus import azlmbr.editor as editor diff --git a/AutomatedTesting/Gem/PythonTests/EditorPythonTestTools/editor_python_test_tools/prefab_utils.py b/AutomatedTesting/Gem/PythonTests/EditorPythonTestTools/editor_python_test_tools/prefab_utils.py index 016e01bc95..d0e51c4413 100644 --- a/AutomatedTesting/Gem/PythonTests/EditorPythonTestTools/editor_python_test_tools/prefab_utils.py +++ b/AutomatedTesting/Gem/PythonTests/EditorPythonTestTools/editor_python_test_tools/prefab_utils.py @@ -48,8 +48,8 @@ def wait_for_propagation(): # This is a helper class which contains some of the useful information about a prefab instance. class PrefabInstance: - def __init__(self, prefab_file_name: str = None, container_entity: EditorEntity = None): - self.prefab_file_name: str = prefab_file_name + def __init__(self, prefab_file_path: str = None, container_entity: EditorEntity = None): + self.prefab_file_path: str = prefab_file_path self.container_entity: EditorEntity = container_entity def __eq__(self, other): @@ -66,7 +66,7 @@ class PrefabInstance: See if this instance is valid to be used with other prefab operations. :return: Whether the target instance is valid or not. """ - return self.container_entity.id.IsValid() and self.prefab_file_name in Prefab.existing_prefabs + return self.container_entity.id.IsValid() and self.prefab_file_path in Prefab.existing_prefabs def has_editor_prefab_component(self) -> bool: """ @@ -131,7 +131,7 @@ class PrefabInstance: has_correct_parent = reparented_container_entity_parent_id.ToString() == parent_entity_id.ToString() assert has_correct_parent, "Prefab Instance reparented is *not* under the expected parent entity" - current_instance_prefab = Prefab.get_prefab(self.prefab_file_name) + current_instance_prefab = Prefab.get_prefab(self.prefab_file_path) current_instance_prefab.instances.remove(self) self.container_entity = reparented_container_entity @@ -161,46 +161,48 @@ class Prefab: :param file_path: A unique file path of the target prefab. :return: Whether the target prefab is loaded or not. """ - return file_path in Prefab.existing_prefabs - + for entry in Prefab.existing_prefabs: + Report.info(f"PrefabPath: '{entry}'") + + return get_prefab_file_path(file_path) in Prefab.existing_prefabs @classmethod def prefab_exists(cls, file_path: str) -> bool: """ Check if a prefab exists in the directory for files of prefab tests. - :param file_name: A unique file name of the target prefab. + :param file_path: A unique file path of the target prefab. :return: Whether the target prefab exists or not. """ return path.exists(get_prefab_file_path(file_path)) @classmethod - def get_prefab(cls, file_name: str) -> Prefab: + def get_prefab(cls, file_path: str) -> Prefab: """ Return a prefab which can be used immediately. - :param file_name: A unique file name of the target prefab. + :param file_path: A unique file path of the target prefab. :return: The prefab with given file name. """ - assert file_name, "Received an empty file_name" - if Prefab.is_prefab_loaded(file_name): - return Prefab.existing_prefabs[file_name] + assert file_path, "Received an empty file_path" + if Prefab.is_prefab_loaded(file_path): + return Prefab.existing_prefabs[get_prefab_file_path(file_path)] else: - assert Prefab.prefab_exists(file_name), f"Attempted to get a prefab \"{file_name}\" that doesn't exist" - new_prefab = Prefab(file_name) - Prefab.existing_prefabs[file_name] = Prefab(file_name) + assert Prefab.prefab_exists(file_path), f"Attempted to get a prefab \"{file_path}\" that doesn't exist" + new_prefab = Prefab(file_path) + Prefab.existing_prefabs[new_prefab.file_path] = new_prefab return new_prefab @classmethod - def create_prefab(cls, entities: list[EditorEntity], file_name: str, prefab_instance_name: str=None) -> tuple(Prefab, PrefabInstance): + def create_prefab(cls, entities: list[EditorEntity], file_path: str, prefab_instance_name: str=None) -> tuple(Prefab, PrefabInstance): """ Create a prefab in memory and return it. The very first instance of this prefab will also be created. :param entities: The entities that should form the new prefab (along with their descendants). - :param file_name: A unique file name of new prefab. - :param prefab_instance_name: A name for the very first instance generated while prefab creation. The default instance name is the same as file_name. + :param file_path: A unique file path for new prefab. + :param prefab_instance_name: A name for the very first instance generated while prefab creation. The default instance name is the same as the file name in file_path. :return: Created Prefab object and the very first PrefabInstance object owned by the prefab. """ - assert not Prefab.is_prefab_loaded(file_name), f"Can't create Prefab '{file_name}' since the prefab already exists" + assert not Prefab.is_prefab_loaded(file_path), f"Can't create Prefab '{file_path}' since the prefab already exists" - new_prefab = Prefab(file_name) + new_prefab = Prefab(file_path) entity_ids = [entity.id for entity in entities] create_prefab_result = prefab.PrefabPublicRequestBus(bus.Broadcast, 'CreatePrefabInMemory', entity_ids, new_prefab.file_path) assert create_prefab_result.IsSuccess(), f"Prefab operation 'CreatePrefab' failed. Error: {create_prefab_result.GetError()}" @@ -210,15 +212,14 @@ class Prefab: children_entity_ids = container_entity.get_children_ids() assert len(children_entity_ids) == len(entities), f"Entity count of created prefab instance does *not* match the count of given entities." - - if prefab_instance_name: - container_entity.set_name(prefab_instance_name) - + wait_for_propagation() - new_prefab_instance = PrefabInstance(file_name, EditorEntity(container_entity_id)) + new_prefab_instance = PrefabInstance(new_prefab.file_path, EditorEntity(container_entity_id)) + if prefab_instance_name: + new_prefab_instance.container_entity.set_name(prefab_instance_name) new_prefab.instances.add(new_prefab_instance) - Prefab.existing_prefabs[file_name] = new_prefab + Prefab.existing_prefabs[new_prefab.file_path] = new_prefab return new_prefab, new_prefab_instance @classmethod @@ -250,7 +251,7 @@ class Prefab: assert False, "Not all entities and descendants in target prefabs are deleted." for instance in prefab_instances: - instance_deleted_prefab = Prefab.get_prefab(instance.prefab_file_name) + instance_deleted_prefab = Prefab.get_prefab(instance.prefab_file_path) instance_deleted_prefab.instances.remove(instance) instance = PrefabInstance() @@ -290,8 +291,7 @@ class Prefab: prefab_file_path = prefab.PrefabPublicRequestBus(bus.Broadcast, 'GetOwningInstancePrefabPath', duplicate_container_entity_id) assert prefab_file_path, "Returned file path should *not* be empty." - prefab_file_name = Path(prefab_file_path).stem - duplicate_instance_prefab = Prefab.get_prefab(prefab_file_name) + duplicate_instance_prefab = Prefab.get_prefab(prefab_file_path) duplicate_instance = PrefabInstance(prefab_file_path, EditorEntity(duplicate_container_entity_id)) duplicate_instance_prefab.instances.add(duplicate_instance) duplicate_instances.append(duplicate_instance) @@ -324,7 +324,7 @@ class Prefab: wait_for_propagation() - instance_owner_prefab = Prefab.get_prefab(prefab_instance.prefab_file_name) + instance_owner_prefab = Prefab.get_prefab(prefab_instance.prefab_file_path) instance_owner_prefab.instances.remove(prefab_instance) prefab_instance = PrefabInstance() @@ -346,13 +346,13 @@ class Prefab: container_entity_id = instantiate_prefab_result.GetValue() container_entity = EditorEntity(container_entity_id) - if name: - container_entity.set_name(name) - wait_for_propagation() new_prefab_instance = PrefabInstance(self.file_path, EditorEntity(container_entity_id)) - assert not new_prefab_instance in self.instances, "This prefab instance is already existed before this instantiation." + assert not new_prefab_instance in self.instances, "This prefab instance already existed before this instantiation." + if name: + new_prefab_instance.container_entity.set_name(name) + self.instances.add(new_prefab_instance) assert new_prefab_instance.is_at_position(prefab_position), "This prefab instance is *not* at expected position." diff --git a/AutomatedTesting/Gem/PythonTests/Multiplayer/TestSuite_Sandbox.py b/AutomatedTesting/Gem/PythonTests/Multiplayer/TestSuite_Sandbox.py index 8c5f33993d..56c2608762 100644 --- a/AutomatedTesting/Gem/PythonTests/Multiplayer/TestSuite_Sandbox.py +++ b/AutomatedTesting/Gem/PythonTests/Multiplayer/TestSuite_Sandbox.py @@ -35,3 +35,7 @@ class TestAutomation(TestAutomationBase): def test_Multiplayer_AutoComponent_RPC(self, request, workspace, editor, launcher_platform): from .tests import Multiplayer_AutoComponent_RPC as test_module self._run_prefab_test(request, workspace, editor, test_module) + + def test_Multiplayer_SimpleNetworkLevelEntity(self, request, workspace, editor, launcher_platform): + from .tests import Multiplayer_SimpleNetworkLevelEntity as test_module + self._run_prefab_test(request, workspace, editor, test_module) diff --git a/AutomatedTesting/Gem/PythonTests/Multiplayer/tests/Multiplayer_SimpleNetworkLevelEntity.py b/AutomatedTesting/Gem/PythonTests/Multiplayer/tests/Multiplayer_SimpleNetworkLevelEntity.py new file mode 100644 index 0000000000..0d1067269c --- /dev/null +++ b/AutomatedTesting/Gem/PythonTests/Multiplayer/tests/Multiplayer_SimpleNetworkLevelEntity.py @@ -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 +""" + + +# Test Case Title : Check that level entities with network bindings are properly replicated. +# Note: This test should be ran on a fresh editor run; some bugs with spawnables occur only on the first editor play-mode. + + +# fmt: off +class TestSuccessFailTuples(): + enter_game_mode = ("Entered game mode", "Failed to enter game mode") + exit_game_mode = ("Exited game mode", "Couldn't exit game mode") + find_network_player = ("Found network player", "Couldn't find network player") +# fmt: on + + +def Multiplayer_SimpleNetworkLevelEntity(): + r""" + Summary: + Test to make sure that network entities in a level function and are replicated to clients as expected + + Level Description: + - Static + 1. NetLevelEntity. This is a networked entity which has a script attached which prints logs to ensure it's replicated. + + + Expected Outcome: + We should see logs stating that the net-sync'd level entity exists on both server and client. + + :return: + """ + import azlmbr.legacy.general as general + from editor_python_test_tools.utils import Report + from editor_python_test_tools.utils import Tracer + + from editor_python_test_tools.utils import TestHelper as helper + from ly_remote_console.remote_console_commands import RemoteConsole as RemoteConsole + + level_name = "SimpleNetworkLevelEntity" + player_prefab_name = "Player" + player_prefab_path = f"levels/multiplayer/{level_name}/{player_prefab_name}.network.spawnable" + + helper.init_idle() + + # 1) Open Level + helper.open_level("Multiplayer", level_name) + + with Tracer() as section_tracer: + # 2) Enter game mode + helper.multiplayer_enter_game_mode(TestSuccessFailTuples.enter_game_mode, player_prefab_path.lower()) + + # 3) Make sure the network player was spawned + player_id = general.find_game_entity(player_prefab_name) + Report.critical_result(TestSuccessFailTuples.find_network_player, player_id.IsValid()) + + # 4) Check the editor logs for network spawnable errors + ATTEMPTING_INVALID_NETSPAWN_WAIT_TIME_SECONDS = 0.0 # The editor will try to net-spawn its networked level entity before it's even a client. Make sure this didn't happen. + helper.fail_if_log_line_found('NetworkEntityManager', "RequestNetSpawnableInstantiation: Requested spawnable Root.network.spawnable doesn't exist in the NetworkSpawnableLibrary. Please make sure it is a network spawnable", section_tracer.errors, ATTEMPTING_INVALID_NETSPAWN_WAIT_TIME_SECONDS) + + # 5) Ensure the script graph attached to the level entity is running on the server + SCRIPTGRAPH_ENABLED_WAIT_TIME_SECONDS = 0.25 + helper.succeed_if_log_line_found('EditorServer', "Script: SimpleNetworkLevelEntity: On Graph Start", section_tracer.prints, SCRIPTGRAPH_ENABLED_WAIT_TIME_SECONDS) + + + # Exit game mode + helper.exit_game_mode(TestSuccessFailTuples.exit_game_mode) + + + +if __name__ == "__main__": + from editor_python_test_tools.utils import Report + Report.start_test(Multiplayer_SimpleNetworkLevelEntity) diff --git a/AutomatedTesting/Gem/PythonTests/Prefab/TestSuite_Main.py b/AutomatedTesting/Gem/PythonTests/Prefab/TestSuite_Main.py index 6e1f94d358..1fd48ee3c9 100644 --- a/AutomatedTesting/Gem/PythonTests/Prefab/TestSuite_Main.py +++ b/AutomatedTesting/Gem/PythonTests/Prefab/TestSuite_Main.py @@ -38,6 +38,10 @@ class TestAutomation(TestAutomationBase): from Prefab.tests.instantiate_prefab import InstantiatePrefab_ContainingASingleEntity as test_module self._run_prefab_test(request, workspace, editor, test_module) + def test_InstantiatePrefab_FromCreatedPrefabWithSingleEntity(self, request, workspace, editor, launcher_platform): + from Prefab.tests.instantiate_prefab import InstantiatePrefab_FromCreatedPrefabWithSingleEntity as test_module + self._run_prefab_test(request, workspace, editor, test_module) + def test_DeletePrefab_ContainingASingleEntity(self, request, workspace, editor, launcher_platform): from Prefab.tests.delete_prefab import DeletePrefab_ContainingASingleEntity as test_module self._run_prefab_test(request, workspace, editor, test_module) diff --git a/AutomatedTesting/Gem/PythonTests/Prefab/TestSuite_Main_Optimized.py b/AutomatedTesting/Gem/PythonTests/Prefab/TestSuite_Main_Optimized.py index bf67b2c661..816b3b8e75 100644 --- a/AutomatedTesting/Gem/PythonTests/Prefab/TestSuite_Main_Optimized.py +++ b/AutomatedTesting/Gem/PythonTests/Prefab/TestSuite_Main_Optimized.py @@ -45,8 +45,12 @@ class TestAutomationNoAutoTestMode(EditorTestSuite): class test_InstantiatePrefab_ContainingASingleEntity(EditorSharedTest): from .tests.instantiate_prefab import InstantiatePrefab_ContainingASingleEntity as test_module + class test_InstantiatePrefab_FromCreatedPrefabWithSingleEntity(EditorSharedTest): + from .tests.instantiate_prefab import InstantiatePrefab_FromCreatedPrefabWithSingleEntity as test_module + class test_DeletePrefab_ContainingASingleEntity(EditorSharedTest): from .tests.delete_prefab import DeletePrefab_ContainingASingleEntity as test_module class test_DuplicatePrefab_ContainingASingleEntity(EditorSharedTest): - from .tests.duplicate_prefab import DuplicatePrefab_ContainingASingleEntity as test_module \ No newline at end of file + from .tests.duplicate_prefab import DuplicatePrefab_ContainingASingleEntity as test_module + \ No newline at end of file diff --git a/AutomatedTesting/Gem/PythonTests/Prefab/tests/create_prefab/CreatePrefab_UnderAnEntity.py b/AutomatedTesting/Gem/PythonTests/Prefab/tests/create_prefab/CreatePrefab_UnderAnEntity.py index 5033c1da9c..4fdd5e4c4d 100644 --- a/AutomatedTesting/Gem/PythonTests/Prefab/tests/create_prefab/CreatePrefab_UnderAnEntity.py +++ b/AutomatedTesting/Gem/PythonTests/Prefab/tests/create_prefab/CreatePrefab_UnderAnEntity.py @@ -13,7 +13,8 @@ def CreatePrefab_UnderAnEntity(): Test is successful if the new instanced prefab of the child has the parent entity id """ - CAR_PREFAB_FILE_NAME = 'car_prefab' + from pathlib import Path + CAR_PREFAB_FILE_NAME = Path(__file__).stem + 'car_prefab' from editor_python_test_tools.editor_entity_utils import EditorEntity from editor_python_test_tools.prefab_utils import Prefab diff --git a/AutomatedTesting/Gem/PythonTests/Prefab/tests/create_prefab/CreatePrefab_WithSingleEntity.py b/AutomatedTesting/Gem/PythonTests/Prefab/tests/create_prefab/CreatePrefab_WithSingleEntity.py index eb8a262a69..cd6d87a630 100644 --- a/AutomatedTesting/Gem/PythonTests/Prefab/tests/create_prefab/CreatePrefab_WithSingleEntity.py +++ b/AutomatedTesting/Gem/PythonTests/Prefab/tests/create_prefab/CreatePrefab_WithSingleEntity.py @@ -7,7 +7,8 @@ SPDX-License-Identifier: Apache-2.0 OR MIT def CreatePrefab_WithSingleEntity(): - CAR_PREFAB_FILE_NAME = 'car_prefab' + from pathlib import Path + CAR_PREFAB_FILE_NAME = Path(__file__).stem + 'car_prefab' from editor_python_test_tools.editor_entity_utils import EditorEntity from editor_python_test_tools.utils import Report diff --git a/AutomatedTesting/Gem/PythonTests/Prefab/tests/delete_prefab/DeletePrefab_ContainingASingleEntity.py b/AutomatedTesting/Gem/PythonTests/Prefab/tests/delete_prefab/DeletePrefab_ContainingASingleEntity.py index 919168019e..e2c4ead034 100644 --- a/AutomatedTesting/Gem/PythonTests/Prefab/tests/delete_prefab/DeletePrefab_ContainingASingleEntity.py +++ b/AutomatedTesting/Gem/PythonTests/Prefab/tests/delete_prefab/DeletePrefab_ContainingASingleEntity.py @@ -7,7 +7,8 @@ SPDX-License-Identifier: Apache-2.0 OR MIT def DeletePrefab_ContainingASingleEntity(): - CAR_PREFAB_FILE_NAME = 'car_prefab' + from pathlib import Path + CAR_PREFAB_FILE_NAME = Path(__file__).stem + 'car_prefab' from editor_python_test_tools.editor_entity_utils import EditorEntity from editor_python_test_tools.prefab_utils import Prefab diff --git a/AutomatedTesting/Gem/PythonTests/Prefab/tests/detach_prefab/DetachPrefab_UnderAnotherPrefab.py b/AutomatedTesting/Gem/PythonTests/Prefab/tests/detach_prefab/DetachPrefab_UnderAnotherPrefab.py index 69dbcfc89c..326d58023f 100644 --- a/AutomatedTesting/Gem/PythonTests/Prefab/tests/detach_prefab/DetachPrefab_UnderAnotherPrefab.py +++ b/AutomatedTesting/Gem/PythonTests/Prefab/tests/detach_prefab/DetachPrefab_UnderAnotherPrefab.py @@ -7,8 +7,9 @@ SPDX-License-Identifier: Apache-2.0 OR MIT def DetachPrefab_UnderAnotherPrefab(): - CAR_PREFAB_FILE_NAME = 'car_prefab2' - WHEEL_PREFAB_FILE_NAME = 'wheel_prefab2' + from pathlib import Path + CAR_PREFAB_FILE_NAME = Path(__file__).stem + 'car_prefab' + WHEEL_PREFAB_FILE_NAME = Path(__file__).stem + 'wheel_prefab' import editor_python_test_tools.pyside_utils as pyside_utils diff --git a/AutomatedTesting/Gem/PythonTests/Prefab/tests/duplicate_prefab/DuplicatePrefab_ContainingASingleEntity.py b/AutomatedTesting/Gem/PythonTests/Prefab/tests/duplicate_prefab/DuplicatePrefab_ContainingASingleEntity.py index e611303fbb..6acd303e2b 100644 --- a/AutomatedTesting/Gem/PythonTests/Prefab/tests/duplicate_prefab/DuplicatePrefab_ContainingASingleEntity.py +++ b/AutomatedTesting/Gem/PythonTests/Prefab/tests/duplicate_prefab/DuplicatePrefab_ContainingASingleEntity.py @@ -7,7 +7,8 @@ SPDX-License-Identifier: Apache-2.0 OR MIT def DuplicatePrefab_ContainingASingleEntity(): - CAR_PREFAB_FILE_NAME = 'car_prefab' + from pathlib import Path + CAR_PREFAB_FILE_NAME = Path(__file__).stem + 'car_prefab' from editor_python_test_tools.editor_entity_utils import EditorEntity from editor_python_test_tools.prefab_utils import Prefab diff --git a/AutomatedTesting/Gem/PythonTests/Prefab/tests/instantiate_prefab/InstantiatePrefab_FromCreatedPrefabWithSingleEntity.py b/AutomatedTesting/Gem/PythonTests/Prefab/tests/instantiate_prefab/InstantiatePrefab_FromCreatedPrefabWithSingleEntity.py new file mode 100644 index 0000000000..ddd1528533 --- /dev/null +++ b/AutomatedTesting/Gem/PythonTests/Prefab/tests/instantiate_prefab/InstantiatePrefab_FromCreatedPrefabWithSingleEntity.py @@ -0,0 +1,34 @@ +""" +Copyright (c) Contributors to the Open 3D Engine Project. +For complete copyright and license terms please see the LICENSE at the root of this distribution. + +SPDX-License-Identifier: Apache-2.0 OR MIT +""" + +def InstantiatePrefab_FromCreatedPrefabWithSingleEntity(): + + from pathlib import Path + CAR_PREFAB_FILE_NAME = Path(__file__).stem + 'car_prefab' + + from editor_python_test_tools.editor_entity_utils import EditorEntity + from editor_python_test_tools.utils import Report + from editor_python_test_tools.prefab_utils import Prefab + + import Prefab.tests.PrefabTestUtils as prefab_test_utils + + prefab_test_utils.open_base_tests_level() + + # Creates a new entity at the root level + car_entity = EditorEntity.create_editor_entity() + car_prefab_entities = [car_entity] + + # Creates a prefab from the new entity + car_prefab, car_prefab_instance = Prefab.create_prefab(car_prefab_entities, CAR_PREFAB_FILE_NAME) + + # Instantiate another instance and verify + car_prefab_instance_2 = car_prefab.instantiate() + assert car_prefab_instance_2.is_valid(), "Failed to instantiate prefab" + +if __name__ == "__main__": + from editor_python_test_tools.utils import Report + Report.start_test(InstantiatePrefab_FromCreatedPrefabWithSingleEntity) diff --git a/AutomatedTesting/Gem/PythonTests/Prefab/tests/reparent_prefab/ReparentPrefab_UnderAnotherPrefab.py b/AutomatedTesting/Gem/PythonTests/Prefab/tests/reparent_prefab/ReparentPrefab_UnderAnotherPrefab.py index 2c460a3298..49aeb97f63 100644 --- a/AutomatedTesting/Gem/PythonTests/Prefab/tests/reparent_prefab/ReparentPrefab_UnderAnotherPrefab.py +++ b/AutomatedTesting/Gem/PythonTests/Prefab/tests/reparent_prefab/ReparentPrefab_UnderAnotherPrefab.py @@ -7,8 +7,9 @@ SPDX-License-Identifier: Apache-2.0 OR MIT def ReparentPrefab_UnderAnotherPrefab(): - CAR_PREFAB_FILE_NAME = 'car_prefab' - WHEEL_PREFAB_FILE_NAME = 'wheel_prefab' + from pathlib import Path + CAR_PREFAB_FILE_NAME = Path(__file__).stem + 'car_prefab' + WHEEL_PREFAB_FILE_NAME = Path(__file__).stem + 'wheel_prefab' import editor_python_test_tools.pyside_utils as pyside_utils diff --git a/AutomatedTesting/Gem/PythonTests/automatedtesting_shared/landscape_canvas_utils.py b/AutomatedTesting/Gem/PythonTests/automatedtesting_shared/landscape_canvas_utils.py index d54e32089a..333422815f 100755 --- a/AutomatedTesting/Gem/PythonTests/automatedtesting_shared/landscape_canvas_utils.py +++ b/AutomatedTesting/Gem/PythonTests/automatedtesting_shared/landscape_canvas_utils.py @@ -19,12 +19,16 @@ def find_nodes_matching_entity_component(component_name, entity_id): :param entity_id: The entity ID to search for the given component node on :return List of matching nodes """ + component_type_id = hydra.get_component_type_id(component_name) component = editor.EditorComponentAPIBus(bus.Broadcast, 'GetComponentOfType', entity_id, - hydra.get_component_type_id(component_name)) + component_type_id) + if component.IsSuccess(): component_id = component.GetValue() component_node = landscapecanvas.LandscapeCanvasRequestBus(bus.Broadcast, 'GetAllNodesMatchingEntityComponent', component_id) if component_node: print(f"{component_name} node found on entity {entity_id.ToString()}") + else: + print(f"Failed to find {component_name} node on entity {entity_id.ToString()}") return component_node diff --git a/AutomatedTesting/Gem/PythonTests/editor/EditorScripts/Menus_FileMenuOptions.py b/AutomatedTesting/Gem/PythonTests/editor/EditorScripts/Menus_FileMenuOptions.py index 4fcdc371e7..0060a3b29a 100644 --- a/AutomatedTesting/Gem/PythonTests/editor/EditorScripts/Menus_FileMenuOptions.py +++ b/AutomatedTesting/Gem/PythonTests/editor/EditorScripts/Menus_FileMenuOptions.py @@ -32,10 +32,10 @@ def Menus_FileMenuOptions_Work(): file_menu_options = [ ("New Level",), - #("Open Level",), Temporarily disabled due to https://github.com/o3de/o3de/issues/6605 - #("Import",), Temporarily disabled due to https://github.com/o3de/o3de/issues/6746 + ("Open Level",), + #("Import",), #Temporarily disabled due to https://github.com/o3de/o3de/issues/6746 ("Save",), - #("Save As",), Temporarily disabled due to https://github.com/o3de/o3de/issues/6605 + ("Save As",), ("Save Level Statistics",), ("Edit Project Settings",), #("Edit Platform Settings",), Temporarily disabled due to https://github.com/o3de/o3de/issues/6604 diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/CMakeLists.txt b/AutomatedTesting/Gem/PythonTests/largeworlds/CMakeLists.txt index ba607ede32..f016094b26 100644 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/CMakeLists.txt +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/CMakeLists.txt @@ -14,7 +14,7 @@ if(PAL_TRAIT_BUILD_TESTS_SUPPORTED AND PAL_TRAIT_BUILD_HOST_TOOLS AND PAL_TRAIT_ NAME AutomatedTesting::DynamicVegetationTests_Main_Optimized TEST_SERIAL TEST_SUITE main - PATH ${CMAKE_CURRENT_LIST_DIR}/dyn_veg/TestSuite_Main_Optimized.py + PATH ${CMAKE_CURRENT_LIST_DIR}/dyn_veg/TestSuite_Main.py RUNTIME_DEPENDENCIES AZ::AssetProcessor Legacy::Editor @@ -27,7 +27,7 @@ if(PAL_TRAIT_BUILD_TESTS_SUPPORTED AND PAL_TRAIT_BUILD_HOST_TOOLS AND PAL_TRAIT_ NAME AutomatedTesting::DynamicVegetationTests_Periodic_Optimized TEST_SERIAL TEST_SUITE periodic - PATH ${CMAKE_CURRENT_LIST_DIR}/dyn_veg/TestSuite_Periodic_Optimized.py + PATH ${CMAKE_CURRENT_LIST_DIR}/dyn_veg/TestSuite_Periodic.py RUNTIME_DEPENDENCIES AZ::AssetProcessor Legacy::Editor @@ -43,7 +43,7 @@ if(PAL_TRAIT_BUILD_TESTS_SUPPORTED AND PAL_TRAIT_BUILD_HOST_TOOLS AND PAL_TRAIT_ NAME AutomatedTesting::LandscapeCanvasTests_Main_Optimized TEST_SERIAL TEST_SUITE main - PATH ${CMAKE_CURRENT_LIST_DIR}/landscape_canvas/TestSuite_Main_Optimized.py + PATH ${CMAKE_CURRENT_LIST_DIR}/landscape_canvas/TestSuite_Main.py RUNTIME_DEPENDENCIES AZ::AssetProcessor Legacy::Editor @@ -58,7 +58,7 @@ if(PAL_TRAIT_BUILD_TESTS_SUPPORTED AND PAL_TRAIT_BUILD_HOST_TOOLS AND PAL_TRAIT_ NAME AutomatedTesting::GradientSignalTests_Periodic_Optimized TEST_SERIAL TEST_SUITE periodic - PATH ${CMAKE_CURRENT_LIST_DIR}/gradient_signal/TestSuite_Periodic_Optimized.py + PATH ${CMAKE_CURRENT_LIST_DIR}/gradient_signal/TestSuite_Periodic.py RUNTIME_DEPENDENCIES AZ::AssetProcessor Legacy::Editor diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/AltitudeFilter_ComponentAndOverrides_InstancesPlantAtSpecifiedAltitude.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/AltitudeFilter_ComponentAndOverrides_InstancesPlantAtSpecifiedAltitude.py index 66aa6d27ad..aa5e5e4f9c 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/AltitudeFilter_ComponentAndOverrides_InstancesPlantAtSpecifiedAltitude.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/AltitudeFilter_ComponentAndOverrides_InstancesPlantAtSpecifiedAltitude.py @@ -51,22 +51,18 @@ def AltitudeFilter_ComponentAndOverrides_InstancesPlantAtSpecifiedAltitude(): import os - import azlmbr.asset as asset import azlmbr.editor as editor import azlmbr.legacy.general as general import azlmbr.bus as bus import azlmbr.math as math - import azlmbr.prefab as prefab import editor_python_test_tools.hydra_editor_utils as hydra - from editor_python_test_tools.prefab_utils import Prefab from largeworlds.large_worlds_utils import editor_dynveg_test_helper as dynveg from editor_python_test_tools.utils import Report from editor_python_test_tools.utils import TestHelper as helper # 1) Open an existing simple level - helper.init_idle() - helper.open_level("", "Base") + hydra.open_base_level() # Set view of planting area for visual debugging general.set_current_view_position(512.0, 500.0, 38.0) @@ -76,9 +72,9 @@ def AltitudeFilter_ComponentAndOverrides_InstancesPlantAtSpecifiedAltitude(): center_point = math.Vector3(512.0, 512.0, 32.0) flower_asset_path = os.path.join("assets", "objects", "foliage", "grass_flower_pink.azmodel") - flower_prefab = dynveg.create_temp_mesh_prefab(flower_asset_path, "PinkFlower")[0] + flower_prefab = dynveg.create_temp_mesh_prefab(flower_asset_path, "AltFilter_PinkFlower")[0] - spawner_entity = dynveg.create_prefab_vegetation_area("Instance Spawner", center_point, 32.0, 32.0, 32.0, flower_prefab) + spawner_entity = dynveg.create_temp_prefab_vegetation_area("Instance Spawner", center_point, 32.0, 32.0, 32.0, flower_prefab) # Add a Vegetation Altitude Filter spawner_entity.add_component("Vegetation Altitude Filter") diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/AltitudeFilter_FilterStageToggle.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/AltitudeFilter_FilterStageToggle.py index 06f6c2a7b4..be2c5e4d8c 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/AltitudeFilter_FilterStageToggle.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/AltitudeFilter_FilterStageToggle.py @@ -32,9 +32,7 @@ def AltitudeFilter_FilterStageToggle(): import os import azlmbr.legacy.general as general - import azlmbr.bus as bus import azlmbr.math as math - import azlmbr.prefab as prefab import editor_python_test_tools.hydra_editor_utils as hydra from largeworlds.large_worlds_utils import editor_dynveg_test_helper as dynveg @@ -45,17 +43,16 @@ def AltitudeFilter_FilterStageToggle(): POSTPROCESS_INSTANCE_COUNT = 34 # Open an existing simple level - helper.init_idle() - helper.open_level("", "Base") + hydra.open_base_level() general.set_current_view_position(512.0, 480.0, 38.0) # Create basic vegetation entity position = math.Vector3(512.0, 512.0, 32.0) flower_asset_path = os.path.join("assets", "objects", "foliage", "grass_flower_pink.azmodel") - flower_prefab = dynveg.create_temp_mesh_prefab(flower_asset_path, "PinkFlower")[0] + flower_prefab = dynveg.create_temp_mesh_prefab(flower_asset_path, "AltFilter_PinkFlower2")[0] - vegetation = dynveg.create_prefab_vegetation_area("vegetation", position, 16.0, 16.0, 16.0, flower_prefab) + vegetation = dynveg.create_temp_prefab_vegetation_area("vegetation", position, 16.0, 16.0, 16.0, flower_prefab) # Add a Vegetation Altitude Filter to the vegetation area entity vegetation.add_component("Vegetation Altitude Filter") diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/AltitudeFilter_ShapeSample_InstancesPlantAtSpecifiedAltitude.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/AltitudeFilter_ShapeSample_InstancesPlantAtSpecifiedAltitude.py index 544a58e242..1e9762d7d8 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/AltitudeFilter_ShapeSample_InstancesPlantAtSpecifiedAltitude.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/AltitudeFilter_ShapeSample_InstancesPlantAtSpecifiedAltitude.py @@ -56,8 +56,7 @@ def AltitudeFilter_ShapeSample_InstancesPlantAtSpecifiedAltitude(): from editor_python_test_tools.utils import TestHelper as helper # 1) Open an existing simple level - helper.init_idle() - helper.open_level("", "Base") + hydra.open_base_level() # Set view of planting area for visual debugging general.set_current_view_position(512.0, 500.0, 38.0) @@ -67,9 +66,9 @@ def AltitudeFilter_ShapeSample_InstancesPlantAtSpecifiedAltitude(): center_point = math.Vector3(512.0, 512.0, 32.0) flower_asset_path = os.path.join("assets", "objects", "foliage", "grass_flower_pink.azmodel") - flower_prefab = dynveg.create_temp_mesh_prefab(flower_asset_path, "PinkFlower")[0] + flower_prefab = dynveg.create_temp_mesh_prefab(flower_asset_path, "AltFilter_PinkFlower3")[0] - spawner_entity = dynveg.create_prefab_vegetation_area("Instance Spawner", center_point, 16.0, 16.0, 16.0, flower_prefab) + spawner_entity = dynveg.create_temp_prefab_vegetation_area("Instance Spawner", center_point, 16.0, 16.0, 16.0, flower_prefab) # Add a Vegetation Altitude Filter spawner_entity.add_component("Vegetation Altitude Filter") diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/AssetListCombiner_CombinedDescriptorsExpressInConfiguredArea.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/AssetListCombiner_CombinedDescriptorsExpressInConfiguredArea.py index a856256929..7242b0b629 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/AssetListCombiner_CombinedDescriptorsExpressInConfiguredArea.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/AssetListCombiner_CombinedDescriptorsExpressInConfiguredArea.py @@ -56,19 +56,21 @@ def AssetListCombiner_CombinedDescriptorsExpressInConfiguredArea(): """ import os + from pathlib import Path import azlmbr.bus as bus import azlmbr.editor as editor import azlmbr.legacy.general as general import azlmbr.math as math import azlmbr.vegetation as vegetation + import azlmbr.prefab as prefab import editor_python_test_tools.hydra_editor_utils as hydra from largeworlds.large_worlds_utils import editor_dynveg_test_helper as dynveg from editor_python_test_tools.utils import Report from editor_python_test_tools.utils import TestHelper as helper - def create_asset_list_entity(name, center, dynamic_slice_asset_path): + def create_asset_list_entity(name, center, target_prefab): asset_list_entity = hydra.Entity(name) asset_list_entity.create_entity( center, @@ -77,18 +79,34 @@ def AssetListCombiner_CombinedDescriptorsExpressInConfiguredArea(): if asset_list_entity.id.IsValid(): print(f"'{asset_list_entity.name}' created") - # Set the Asset List to a Dynamic Slice spawner with a specific slice asset selected - dynamic_slice_spawner = vegetation.DynamicSliceInstanceSpawner() - dynamic_slice_spawner.SetSliceAssetPath(dynamic_slice_asset_path) + if target_prefab: + # Get the in-memory spawnable asset id if exists + spawnable_name = Path(target_prefab.file_path).stem + spawnable_asset_id = prefab.PrefabPublicRequestBus(bus.Broadcast, 'GetInMemorySpawnableAssetId', + spawnable_name) + + # Create the in-memory spawnable asset from given prefab if the spawnable does not exist + if not spawnable_asset_id.is_valid(): + create_spawnable_result = prefab.PrefabPublicRequestBus(bus.Broadcast, 'CreateInMemorySpawnableAsset', + target_prefab.file_path, + spawnable_name) + assert create_spawnable_result.IsSuccess(), \ + f"Prefab operation 'CreateInMemorySpawnableAssets' failed. Error: {create_spawnable_result.GetError()}" + spawnable_asset_id = create_spawnable_result.GetValue() + else: + spawnable_asset_id = None + + # Set the vegetation area to a prefab instance spawner with a specific prefab asset selected descriptor = hydra.get_component_property_value(asset_list_entity.components[0], - "Configuration|Embedded Assets|[0]") - descriptor.spawner = dynamic_slice_spawner + 'Configuration|Embedded Assets|[0]') + prefab_spawner = vegetation.PrefabInstanceSpawner() + prefab_spawner.SetPrefabAssetId(spawnable_asset_id) + descriptor.spawner = prefab_spawner asset_list_entity.get_set_test(0, "Configuration|Embedded Assets|[0]", descriptor) return asset_list_entity # 1) Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # Set view of planting area for visual debugging general.set_current_view_position(512.0, 500.0, 38.0) @@ -96,11 +114,13 @@ def AssetListCombiner_CombinedDescriptorsExpressInConfiguredArea(): # 2) Create 3 entities with Vegetation Asset List components set to spawn different descriptors center_point = math.Vector3(512.0, 512.0, 32.0) - asset_path = os.path.join("Slices", "PinkFlower.dynamicslice") - asset_path2 = os.path.join("Slices", "PurpleFlower.dynamicslice") - asset_list_entity = create_asset_list_entity("Asset List 1", center_point, asset_path) + pink_flower_asset_path = os.path.join("assets", "objects", "foliage", "grass_flower_pink.azmodel") + pink_flower_prefab = dynveg.create_temp_mesh_prefab(pink_flower_asset_path, "AssetList_PinkFlower")[0] + purple_flower_asset_path = os.path.join("assets", "objects", "foliage", "grass_flower_pink.azmodel") + purple_flower_prefab = dynveg.create_temp_mesh_prefab(purple_flower_asset_path, "AssetList_PurpleFlower")[0] + asset_list_entity = create_asset_list_entity("Asset List 1", center_point, pink_flower_prefab) asset_list_entity2 = create_asset_list_entity("Asset List 2", center_point, None) - asset_list_entity3 = create_asset_list_entity("Asset List 3", center_point, asset_path2) + asset_list_entity3 = create_asset_list_entity("Asset List 3", center_point, purple_flower_prefab) # 3) Create a planting surface and add a Vegetation System Settings level component with instances set to spawn # on center instead of corner diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/AssetWeightSelector_InstancesExpressBasedOnWeight.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/AssetWeightSelector_InstancesExpressBasedOnWeight.py index b8b50f8110..8ea0b6b23d 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/AssetWeightSelector_InstancesExpressBasedOnWeight.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/AssetWeightSelector_InstancesExpressBasedOnWeight.py @@ -56,8 +56,7 @@ def AssetWeightSelector_InstancesExpressBasedOnWeight(): from editor_python_test_tools.utils import TestHelper as helper # 1) Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # Set view of planting area for visual debugging general.set_current_view_position(512.0, 500.0, 38.0) @@ -66,14 +65,15 @@ def AssetWeightSelector_InstancesExpressBasedOnWeight(): # 2) Create a new instance spawner entity with multiple Dynamic Slice Instance Spawner descriptors, one set to a # valid slice entity, and one set to None spawner_center_point = math.Vector3(512.0, 512.0, 32.0) - asset_path = os.path.join("Slices", "PinkFlower.dynamicslice") - spawner_entity = dynveg.create_dynamic_slice_vegetation_area("Instance Spawner", spawner_center_point, 16.0, 16.0, 16.0, - asset_path) + pink_flower_asset_path = os.path.join("assets", "objects", "foliage", "grass_flower_pink.azmodel") + pink_flower_prefab = dynveg.create_temp_mesh_prefab(pink_flower_asset_path, "AssetWeight_PinkFlower")[0] + spawner_entity = dynveg.create_temp_prefab_vegetation_area("Instance Spawner", spawner_center_point, 16.0, 16.0, 16.0, + pink_flower_prefab) desc_asset = hydra.get_component_property_value(spawner_entity.components[2], "Configuration|Embedded Assets")[0] desc_list = [desc_asset, desc_asset] spawner_entity.get_set_test(2, "Configuration|Embedded Assets", desc_list) - spawner_entity.get_set_test(2, "Configuration|Embedded Assets|[1]|Instance|Slice Asset", None) + spawner_entity.get_set_test(2, "Configuration|Embedded Assets|[1]|Instance|Prefab Asset", None) # Add an Asset Weight Selector component to the spawner entity spawner_entity.add_component("Vegetation Asset Weight Selector") diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/DistanceBetweenFilterOverrides_InstancesPlantAtSpecifiedRadius.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/DistanceBetweenFilterOverrides_InstancesPlantAtSpecifiedRadius.py index ed5501d719..be0fe8dba7 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/DistanceBetweenFilterOverrides_InstancesPlantAtSpecifiedRadius.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/DistanceBetweenFilterOverrides_InstancesPlantAtSpecifiedRadius.py @@ -64,16 +64,15 @@ def DistanceBetweenFilterOverrides_InstancesPlantAtSpecifiedRadius(): instance_query_point_c = math.Vector3(515.0, 512.5, 32.0) # 1) Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") - + hydra.open_base_level() general.set_current_view_position(512.0, 480.0, 38.0) # 2) Create a new entity with required vegetation area components spawner_center_point = math.Vector3(520.0, 520.0, 32.0) - asset_path = os.path.join("Slices", "1m_cube.dynamicslice") - spawner_entity = dynveg.create_dynamic_slice_vegetation_area("Instance Spawner", spawner_center_point, 16.0, 16.0, 16.0, - asset_path) + cube_asset_path = os.path.join("testdata", "multi-mat_fbx", "multi-mat_1m_cube.azmodel") + cube_prefab = dynveg.create_temp_mesh_prefab(cube_asset_path, "DistanceBetween_1m_cube2")[0] + spawner_entity = dynveg.create_temp_prefab_vegetation_area("Instance Spawner", spawner_center_point, 16.0, 16.0, 16.0, + cube_prefab) # 3) Create a surface to plant on surface_center_point = math.Vector3(512.0, 512.0, 32.0) diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/DistanceBetweenFilter_InstancesPlantAtSpecifiedRadius.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/DistanceBetweenFilter_InstancesPlantAtSpecifiedRadius.py index c24ec3c314..b2244fdfa7 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/DistanceBetweenFilter_InstancesPlantAtSpecifiedRadius.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/DistanceBetweenFilter_InstancesPlantAtSpecifiedRadius.py @@ -62,16 +62,15 @@ def DistanceBetweenFilter_InstancesPlantAtSpecifiedRadius(): instance_query_point_c = math.Vector3(515.0, 512.5, 32.0) # 1) Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") - + hydra.open_base_level() general.set_current_view_position(512.0, 480.0, 38.0) # 2) Create a new entity with required vegetation area components spawner_center_point = math.Vector3(520.0, 520.0, 32.0) - asset_path = os.path.join("Slices", "1m_cube.dynamicslice") - spawner_entity = dynveg.create_dynamic_slice_vegetation_area("Instance Spawner", spawner_center_point, 16.0, 16.0, 16.0, - asset_path) + cube_asset_path = os.path.join("testdata", "multi-mat_fbx", "multi-mat_1m_cube.azmodel") + cube_prefab = dynveg.create_temp_mesh_prefab(cube_asset_path, "DistanceBetween_1m_cube")[0] + spawner_entity = dynveg.create_temp_prefab_vegetation_area("Instance Spawner", spawner_center_point, + 16.0, 16.0, 16.0, cube_prefab) # 3) Create a surface to plant on surface_center_point = math.Vector3(512.0, 512.0, 32.0) diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/DynVegUtils_TempPrefabCreationWorks.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/DynVegUtils_TempPrefabCreationWorks.py index d016473d5e..c1ca3cbfc6 100644 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/DynVegUtils_TempPrefabCreationWorks.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/DynVegUtils_TempPrefabCreationWorks.py @@ -39,11 +39,11 @@ def DynVegUtils_TempPrefabCreationWorks(): with Tracer() as error_tracer: # Create dictionary for prefab filenames and paths to create using helper function mesh_prefabs = { - "PinkFlower": os.path.join("assets", "objects", "foliage", "grass_flower_pink.azmodel"), - "PurpleFlower": os.path.join("assets", "objects", "foliage", "grass_flower_purple.azmodel"), - "1m_Cube": os.path.join("objects", "_primitives", "_box_1x1.azmodel"), - "CedarTree": os.path.join("assets", "objects", "foliage", "cedar.azmodel"), - "Bush": os.path.join("assets", "objects", "foliage", "bush_privet_01.azmodel"), + "UtilsTest_PinkFlower": os.path.join("assets", "objects", "foliage", "grass_flower_pink.azmodel"), + "UtilsTest_PurpleFlower": os.path.join("assets", "objects", "foliage", "grass_flower_purple.azmodel"), + "UtilsTest_1m_Cube": os.path.join("objects", "_primitives", "_box_1x1.azmodel"), + "UtilsTest_CedarTree": os.path.join("assets", "objects", "foliage", "cedar.azmodel"), + "UtilsTest_Bush": os.path.join("assets", "objects", "foliage", "bush_privet_01.azmodel"), } # 1) Open an existing simple level diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/DynamicSliceInstanceSpawner_DynamicSliceSpawnerWorks.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/DynamicSliceInstanceSpawner_DynamicSliceSpawnerWorks.py index fcbf85c59d..c8581ad275 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/DynamicSliceInstanceSpawner_DynamicSliceSpawnerWorks.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/DynamicSliceInstanceSpawner_DynamicSliceSpawnerWorks.py @@ -71,8 +71,7 @@ def DynamicSliceInstanceSpawner_DynamicSliceSpawnerWorks(): from editor_python_test_tools.utils import TestHelper as helper # 1) Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() general.set_current_view_position(512.0, 480.0, 38.0) # Grab the UUID that we need for creating an Dynamic Slice Instance Spawner diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/EmptyInstanceSpawner_EmptySpawnerWorks.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/EmptyInstanceSpawner_EmptySpawnerWorks.py index d0a51809b4..91315a6971 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/EmptyInstanceSpawner_EmptySpawnerWorks.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/EmptyInstanceSpawner_EmptySpawnerWorks.py @@ -57,8 +57,7 @@ def EmptyInstanceSpawner_EmptySpawnerWorks(): from editor_python_test_tools.utils import TestHelper as helper # 1) Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() general.set_current_view_position(512.0, 480.0, 38.0) # Grab the UUID that we need for creating an Empty Spawner diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/InstanceSpawnerPriority_LayerAndSubPriority.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/InstanceSpawnerPriority_LayerAndSubPriority.py index 471c8862fd..f83807a62b 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/InstanceSpawnerPriority_LayerAndSubPriority.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/InstanceSpawnerPriority_LayerAndSubPriority.py @@ -60,8 +60,7 @@ def InstanceSpawnerPriority_LayerAndSubPriority(): from editor_python_test_tools.utils import TestHelper as helper # 1) Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # Set view of planting area for visual debugging general.set_current_view_position(512.0, 500.0, 38.0) @@ -69,9 +68,10 @@ def InstanceSpawnerPriority_LayerAndSubPriority(): # 2) Create overlapping areas: 1 instance spawner area, and 1 blocker area spawner_center_point = math.Vector3(508.0, 508.0, 32.0) - asset_path = os.path.join("Slices", "PinkFlower.dynamicslice") - spawner_entity = dynveg.create_dynamic_slice_vegetation_area("Instance Spawner", spawner_center_point, 16.0, 16.0, 1.0, - asset_path) + pink_flower_asset_path = os.path.join("assets", "objects", "foliage", "grass_flower_pink.azmodel") + pink_flower_prefab = dynveg.create_temp_mesh_prefab(pink_flower_asset_path, "Priority_PinkFlower")[0] + spawner_entity = dynveg.create_temp_prefab_vegetation_area("Instance Spawner", spawner_center_point, 16.0, 16.0, 1.0, + pink_flower_prefab) blocker_center_point = math.Vector3(516.0, 516.0, 32.0) blocker_entity = dynveg.create_blocker_area("Instance Blocker", blocker_center_point, 16.0, 16.0, 1.0) diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/LayerBlender_E2E_Editor.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/LayerBlender_E2E_Editor.py index 6b5a80ee8e..79f2e4169b 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/LayerBlender_E2E_Editor.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/LayerBlender_E2E_Editor.py @@ -85,18 +85,14 @@ def LayerBlender_E2E_Editor(): # 2) Create 2 vegetation areas with different meshes purple_position = math.Vector3(504.0, 512.0, 32.0) - purple_asset_path = os.path.join("Slices", "PurpleFlower.dynamicslice") - spawner_entity_1 = dynveg.create_dynamic_slice_vegetation_area("Purple Spawner", - purple_position, - 16.0, 16.0, 1.0, - purple_asset_path) + purple_flower_prefab_path = os.path.join("assets", "prefabs", "PurpleFlower.spawnable") + spawner_entity_1 = dynveg.create_prefab_vegetation_area("Purple Spawner", purple_position, 16.0, 16.0, 1.0, + purple_flower_prefab_path) pink_position = math.Vector3(520.0, 512.0, 32.0) - pink_asset_path = os.path.join("Slices", "PinkFlower.dynamicslice") - spawner_entity_2 = dynveg.create_dynamic_slice_vegetation_area("Pink Spawner", - pink_position, - 16.0, 16.0, 1.0, - pink_asset_path) + pink_flower_prefab_path = os.path.join("assets", "prefabs", "PinkFlower.spawnable") + spawner_entity_2 = dynveg.create_prefab_vegetation_area("Pink Spawner", pink_position, 16.0, 16.0, 1.0, + pink_flower_prefab_path) base_position = math.Vector3(512.0, 512.0, 32.0) dynveg.create_surface_entity("Surface Entity", @@ -135,11 +131,11 @@ def LayerBlender_E2E_Editor(): pink_count = 0 purple_count = 0 for instance in instances: - purple_asset_path = purple_asset_path.replace("\\", "/").lower() - pink_asset_path = pink_asset_path.replace("\\", "/").lower() - if instance.descriptor.spawner.GetSliceAssetPath() == pink_asset_path: + purple_flower_prefab_path = purple_flower_prefab_path.replace("\\", "/").lower() + pink_flower_prefab_path = pink_flower_prefab_path.replace("\\", "/").lower() + if instance.descriptor.spawner.GetPrefabAssetPath() == pink_flower_prefab_path: pink_count += 1 - elif instance.descriptor.spawner.GetSliceAssetPath() == purple_asset_path: + elif instance.descriptor.spawner.GetPrefabAssetPath() == purple_flower_prefab_path: purple_count += 1 Report.result(Tests.instances_blended, pink_count == purple_count and (pink_count + purple_count == num_expected)) @@ -152,11 +148,10 @@ def LayerBlender_E2E_Editor(): components.TransformBus(bus.Event, "MoveEntity", search_entity_ids[0], cam_position) azlmbr.components.TransformBus(bus.Event, "SetLocalRotation", search_entity_ids[0], cam_rot_degrees_vector) - # 6) Save and export to engine + # 6) Save the created level general.save_level() - general.export_to_engine() - pak_path = os.path.join(paths.products, "levels", lvl_name, "level.pak") - success = helper.wait_for_condition(lambda: os.path.exists(pak_path), 10.0) + level_prefab_path = os.path.join(paths.products, "levels", lvl_name, f"{lvl_name}.spawnable") + success = helper.wait_for_condition(lambda: os.path.exists(level_prefab_path), 5.0) Report.result(Tests.saved_and_exported, success) diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/LayerBlocker_InstancesBlockedInConfiguredArea.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/LayerBlocker_InstancesBlockedInConfiguredArea.py index b89edcdeb7..5c3083ee3d 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/LayerBlocker_InstancesBlockedInConfiguredArea.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/LayerBlocker_InstancesBlockedInConfiguredArea.py @@ -17,7 +17,6 @@ class Tests: ) - def LayerBlocker_InstancesBlockedInConfiguredArea(): """ Summary: @@ -58,8 +57,7 @@ def LayerBlocker_InstancesBlockedInConfiguredArea(): from editor_python_test_tools.utils import TestHelper as helper # 1) Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # Set view of planting area for visual debugging general.set_current_view_position(512.0, 500.0, 38.0) @@ -67,9 +65,10 @@ def LayerBlocker_InstancesBlockedInConfiguredArea(): # 2) Create a new instance spawner entity spawner_center_point = math.Vector3(512.0, 512.0, 32.0) - asset_path = os.path.join("Slices", "PinkFlower.dynamicslice") - spawner_entity = dynveg.create_dynamic_slice_vegetation_area("Instance Spawner", spawner_center_point, 16.0, 16.0, 16.0, - asset_path) + pink_flower_asset_path = os.path.join("assets", "objects", "foliage", "grass_flower_pink.azmodel") + pink_flower_prefab = dynveg.create_temp_mesh_prefab(pink_flower_asset_path, "Blocker_PinkFlower")[0] + spawner_entity = dynveg.create_temp_prefab_vegetation_area("Instance Spawner", spawner_center_point, + 16.0, 16.0, 16.0, pink_flower_prefab) # 3) Create surface for planting on dynveg.create_surface_entity("Surface Entity", spawner_center_point, 32.0, 32.0, 1.0) diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/LayerSpawner_FilterStageToggle.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/LayerSpawner_FilterStageToggle.py index 6796f56b11..a277f14a41 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/LayerSpawner_FilterStageToggle.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/LayerSpawner_FilterStageToggle.py @@ -42,16 +42,17 @@ def LayerSpawner_FilterStageToggle(): POSTPROCESS_INSTANCE_COUNT = 19 # Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() general.set_current_view_position(500.49, 498.69, 46.66) general.set_current_view_rotation(-42.05, 0.00, -36.33) # Create a vegetation area with all needed components position = math.Vector3(512.0, 512.0, 32.0) - asset_path = os.path.join("Slices", "PinkFlower.dynamicslice") - vegetation_entity = dynveg.create_dynamic_slice_vegetation_area("vegetation", position, 16.0, 16.0, 16.0, asset_path) + pink_flower_asset_path = os.path.join("assets", "objects", "foliage", "grass_flower_pink.azmodel") + pink_flower_prefab = dynveg.create_temp_mesh_prefab(pink_flower_asset_path, "SpawnerFilter_PinkFlower")[0] + vegetation_entity = dynveg.create_temp_prefab_vegetation_area("vegetation", position, 16.0, 16.0, 16.0, + pink_flower_prefab) vegetation_entity.add_component("Vegetation Altitude Filter") vegetation_entity.add_component("Vegetation Position Modifier") diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/LayerSpawner_InheritBehaviorFlag.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/LayerSpawner_InheritBehaviorFlag.py index 1153ae2657..dc06c298d1 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/LayerSpawner_InheritBehaviorFlag.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/LayerSpawner_InheritBehaviorFlag.py @@ -42,19 +42,16 @@ def LayerSpawner_InheritBehaviorFlag(): SURFACE_TAG = "test_tag" - def set_dynamic_slice_asset(entity_obj, component_index, dynamic_slice_asset_path): - dynamic_slice_spawner = vegetation.DynamicSliceInstanceSpawner() - dynamic_slice_spawner.SetSliceAssetPath(dynamic_slice_asset_path) - descriptor = hydra.get_component_property_value( - entity_obj.components[component_index], "Configuration|Embedded Assets|[0]" - ) - descriptor.spawner = dynamic_slice_spawner + def set_prefab_asset(entity_obj, component_index, spawnable_prefab): + descriptor = hydra.get_component_property_value(entity_obj.components[component_index], + "Configuration|Embedded Assets|[0]") + prefab_spawner = vegetation.PrefabInstanceSpawner() + prefab_spawner.SetPrefabAssetId(spawnable_prefab) + descriptor.spawner = prefab_spawner entity_obj.get_set_test(2, "Configuration|Embedded Assets|[0]", descriptor) # Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") - + hydra.open_base_level() general.set_current_view_position(512.0, 480.0, 38.0) # Create Emitter entity and add the required components @@ -80,7 +77,9 @@ def LayerSpawner_InheritBehaviorFlag(): veg_1.create_entity( position, ["Vegetation Layer Spawner", "Shape Reference", "Vegetation Asset List"] ) - set_dynamic_slice_asset(veg_1, 2, os.path.join("Slices", "PinkFlower.dynamicslice")) + pink_flower_asset_path = os.path.join("assets", "objects", "foliage", "grass_flower_pink.azmodel") + pink_flower_prefab = dynveg.create_temp_mesh_prefab(pink_flower_asset_path, "SpawnerInheritBehavior_PinkFlower")[0] + set_prefab_asset(veg_1, 2, pink_flower_prefab) veg_1.get_set_test(1, "Configuration|Shape Entity Id", blender_entity.id) # Create second vegetation area and assign a valid asset @@ -88,7 +87,9 @@ def LayerSpawner_InheritBehaviorFlag(): veg_2.create_entity( position, ["Vegetation Layer Spawner", "Shape Reference", "Vegetation Asset List"] ) - set_dynamic_slice_asset(veg_2, 2, os.path.join("Slices", "PurpleFlower.dynamicslice")) + purple_flower_asset_path = os.path.join("assets", "objects", "foliage", "grass_flower_pink.azmodel") + purple_flower_prefab = dynveg.create_temp_mesh_prefab(purple_flower_asset_path, "temp_PurpleFlower")[0] + set_prefab_asset(veg_2, 2, purple_flower_prefab) veg_2.get_set_test(1, "Configuration|Shape Entity Id", blender_entity.id) # Assign the vegetation areas to the Blender entity diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/LayerSpawner_InstancesPlantInAllSupportedShapes.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/LayerSpawner_InstancesPlantInAllSupportedShapes.py index beec54b4eb..662ac63714 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/LayerSpawner_InstancesPlantInAllSupportedShapes.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/LayerSpawner_InstancesPlantInAllSupportedShapes.py @@ -56,16 +56,14 @@ def LayerSpawner_InstancesPlantInAllSupportedShapes(): Report.result(success, result) # 1) Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # 2) Create basic vegetation area entity and set the properties entity_position = math.Vector3(125.0, 136.0, 32.0) - asset_path = os.path.join("Slices", "PurpleFlower.dynamicslice") - vegetation = dynveg.create_dynamic_slice_vegetation_area("Instance Spawner", - entity_position, - 10.0, 10.0, 10.0, - asset_path) + pink_flower_asset_path = os.path.join("assets", "objects", "foliage", "grass_flower_pink.azmodel") + pink_flower_prefab = dynveg.create_temp_mesh_prefab(pink_flower_asset_path, "SpawnerShapePlant_PinkFlower")[0] + vegetation = dynveg.create_temp_prefab_vegetation_area("Instance Spawner", entity_position, 10.0, 10.0, 10.0, + pink_flower_prefab) vegetation.remove_component("Box Shape") vegetation.add_component("Shape Reference") diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/LayerSpawner_InstancesRefreshUsingCorrectViewportCamera.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/LayerSpawner_InstancesRefreshUsingCorrectViewportCamera.py index fe8863c625..deb0376c9b 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/LayerSpawner_InstancesRefreshUsingCorrectViewportCamera.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/LayerSpawner_InstancesRefreshUsingCorrectViewportCamera.py @@ -43,13 +43,13 @@ def LayerSpawner_InstancesRefreshUsingCorrectViewportCamera(): import azlmbr.legacy.general as general import azlmbr.math as math + import editor_python_test_tools.hydra_editor_utils as hydra from largeworlds.large_worlds_utils import editor_dynveg_test_helper as dynveg from editor_python_test_tools.utils import Report from editor_python_test_tools.utils import TestHelper as helper # Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # Set up a test environment to validate that switching viewports correctly changes which camera # the vegetation system uses. @@ -100,11 +100,12 @@ def LayerSpawner_InstancesRefreshUsingCorrectViewportCamera(): surface_height) # Create the two vegetation areas - test_slice_asset_path = os.path.join("Slices", "PurpleFlower.dynamicslice") - first_veg_entity = dynveg.create_dynamic_slice_vegetation_area("Veg Area 1", first_entity_center_point, box_size, box_size, - box_size, test_slice_asset_path) - second_veg_entity = dynveg.create_dynamic_slice_vegetation_area("Veg Area 2", second_entity_center_point, box_size, box_size, - box_size, test_slice_asset_path) + pink_flower_asset_path = os.path.join("assets", "objects", "foliage", "grass_flower_pink.azmodel") + pink_flower_prefab = dynveg.create_temp_mesh_prefab(pink_flower_asset_path, "SpawnerViewportRefresh_PinkFlower")[0] + first_veg_entity = dynveg.create_temp_prefab_vegetation_area("Veg Area 1", first_entity_center_point, box_size, box_size, + box_size, pink_flower_prefab) + second_veg_entity = dynveg.create_temp_prefab_vegetation_area("Veg Area 2", second_entity_center_point, box_size, box_size, + box_size, pink_flower_prefab) # When the first viewport is active, the first area should be full of instances, and the second should be empty general.set_active_viewport(0) diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/MeshBlocker_InstancesBlockedByMesh.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/MeshBlocker_InstancesBlockedByMesh.py index 9777a52c82..7c365d0ee5 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/MeshBlocker_InstancesBlockedByMesh.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/MeshBlocker_InstancesBlockedByMesh.py @@ -50,19 +50,17 @@ def MeshBlocker_InstancesBlockedByMesh(): from editor_python_test_tools.utils import TestHelper as helper # Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() general.set_current_view_position(500.49, 498.69, 46.66) general.set_current_view_rotation(-42.05, 0.00, -36.33) # Create entity with components "Vegetation Layer Spawner", "Vegetation Asset List", "Box Shape" entity_position = math.Vector3(512.0, 512.0, 32.0) - asset_path = os.path.join("Slices", "PurpleFlower.dynamicslice") - spawner_entity = dynveg.create_dynamic_slice_vegetation_area("Instance Spawner", - entity_position, - 10.0, 10.0, 10.0, - asset_path) + pink_flower_asset_path = os.path.join("assets", "objects", "foliage", "grass_flower_pink.azmodel") + pink_flower_prefab = dynveg.create_temp_mesh_prefab(pink_flower_asset_path, "MeshBlocker_PinkFlower")[0] + spawner_entity = dynveg.create_temp_prefab_vegetation_area("Instance Spawner", entity_position, 10.0, 10.0, 10.0, + pink_flower_prefab) # Create surface entity to plant on dynveg.create_surface_entity("Surface Entity", entity_position, 10.0, 10.0, 1.0) diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/MeshBlocker_InstancesBlockedByMeshHeightTuning.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/MeshBlocker_InstancesBlockedByMeshHeightTuning.py index 3c47edeb91..a54a8653f0 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/MeshBlocker_InstancesBlockedByMeshHeightTuning.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/MeshBlocker_InstancesBlockedByMeshHeightTuning.py @@ -53,19 +53,17 @@ def MeshBlocker_InstancesBlockedByMeshHeightTuning(): from editor_python_test_tools.utils import TestHelper as helper # 1) Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() general.set_current_view_position(500.49, 498.69, 46.66) general.set_current_view_rotation(-42.05, 0.00, -36.33) # 2) Create entity with components "Vegetation Layer Spawner", "Vegetation Asset List", "Box Shape" entity_position = math.Vector3(512.0, 512.0, 32.0) - asset_path = os.path.join("Slices", "PurpleFlower.dynamicslice") - spawner_entity = dynveg.create_dynamic_slice_vegetation_area("Instance Spawner", - entity_position, - 10.0, 10.0, 10.0, - asset_path) + pink_flower_asset_path = os.path.join("assets", "objects", "foliage", "grass_flower_pink.azmodel") + pink_flower_prefab = dynveg.create_temp_mesh_prefab(pink_flower_asset_path, "MeshBlocker_PinkFlower2")[0] + spawner_entity = dynveg.create_temp_prefab_vegetation_area("Instance Spawner", entity_position, 10.0, 10.0, 10.0, + pink_flower_prefab) # 3) Create surface entity to plant on dynveg.create_surface_entity("Surface Entity", entity_position, 10.0, 10.0, 1.0) diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/MeshSurfaceTagEmitter_DependentOnMeshComponent.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/MeshSurfaceTagEmitter_DependentOnMeshComponent.py index cee8ebe5b6..9af17b0cd5 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/MeshSurfaceTagEmitter_DependentOnMeshComponent.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/MeshSurfaceTagEmitter_DependentOnMeshComponent.py @@ -58,8 +58,7 @@ def MeshSurfaceTagEmitter_DependentOnMeshComponent(): return editor.EditorComponentAPIBus(bus.Broadcast, "IsComponentEnabled", EntityComponentIdPair) # 1) Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # 2) Create a new entity with component "Mesh Surface Tag Emitter" entity_position = math.Vector3(125.0, 136.0, 32.0) diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/MeshSurfaceTagEmitter_SurfaceTagsAddRemoveSuccessfully.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/MeshSurfaceTagEmitter_SurfaceTagsAddRemoveSuccessfully.py index d7abc66106..cd9963e844 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/MeshSurfaceTagEmitter_SurfaceTagsAddRemoveSuccessfully.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/MeshSurfaceTagEmitter_SurfaceTagsAddRemoveSuccessfully.py @@ -47,8 +47,7 @@ def MeshSurfaceTagEmitter_SurfaceTagsAddRemoveSuccessfully(): from editor_python_test_tools.utils import TestHelper as helper # 1) Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # 2) Create a new entity with components "Mesh Surface Tag Emitter", "Mesh" entity_position = math.Vector3(125.0, 136.0, 32.0) diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/PhysXColliderSurfaceTagEmitter_E2E_Editor.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/PhysXColliderSurfaceTagEmitter_E2E_Editor.py index 6232cd374d..cdb2fac80b 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/PhysXColliderSurfaceTagEmitter_E2E_Editor.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/PhysXColliderSurfaceTagEmitter_E2E_Editor.py @@ -55,8 +55,7 @@ def PhysXColliderSurfaceTagEmitter_E2E_Editor(): return behavior_context_test_success # Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # Verify all of the BehaviorContext API: behavior_context = ( @@ -90,8 +89,10 @@ def PhysXColliderSurfaceTagEmitter_E2E_Editor(): dynveg.create_surface_entity("Baseline Surface", entity_center_point, 32.0, 32.0, 1.0) # Create a new entity with required vegetation area components - asset_path = os.path.join("Slices", "PinkFlower.dynamicslice") - spawner_entity = dynveg.create_dynamic_slice_vegetation_area("Veg Area", entity_center_point, 32.0, 32.0, 32.0, asset_path) + pink_flower_asset_path = os.path.join("assets", "objects", "foliage", "grass_flower_pink.azmodel") + pink_flower_prefab = dynveg.create_temp_mesh_prefab(pink_flower_asset_path, "PhysXCollider_PinkFlower")[0] + spawner_entity = dynveg.create_temp_prefab_vegetation_area("Instance Spawner", entity_center_point, test_box_size, + test_box_size, test_box_size, pink_flower_prefab) # Add a Vegetation Surface Mask Filter component to the spawner entity and set it to include the "test" tag spawner_entity.add_component("Vegetation Surface Mask Filter") diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/PositionModifier_AutoSnapToSurfaceWorks.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/PositionModifier_AutoSnapToSurfaceWorks.py index be7e8ad754..85a1cddb95 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/PositionModifier_AutoSnapToSurfaceWorks.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/PositionModifier_AutoSnapToSurfaceWorks.py @@ -64,8 +64,7 @@ def PositionModifier_AutoSnapToSurfaceWorks(): 'Configuration|Position Z|Range Min', 'Configuration|Position Z|Range Max'] # 1) Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # Set view of planting area for visual debugging general.set_current_view_position(512.0, 500.0, 38.0) @@ -73,9 +72,10 @@ def PositionModifier_AutoSnapToSurfaceWorks(): # 2) Create a new entity with required vegetation area components and a Position Modifier spawner_center_point = math.Vector3(512.0, 512.0, 32.0) - asset_path = os.path.join("Slices", "PinkFlower.dynamicslice") - spawner_entity = dynveg.create_dynamic_slice_vegetation_area("Instance Spawner", spawner_center_point, 16.0, 16.0, 16.0, - asset_path) + pink_flower_asset_path = os.path.join("assets", "objects", "foliage", "grass_flower_pink.azmodel") + pink_flower_prefab = dynveg.create_temp_mesh_prefab(pink_flower_asset_path, "PosMod_PinkFlower")[0] + spawner_entity = dynveg.create_temp_prefab_vegetation_area("Instance Spawner", spawner_center_point, 16.0, 16.0, + 16.0, pink_flower_prefab) # Add a Vegetation Position Modifier and set offset values to 0 spawner_entity.add_component("Vegetation Position Modifier") diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/PositionModifier_ComponentAndOverrides_InstancesPlantAtSpecifiedOffsets.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/PositionModifier_ComponentAndOverrides_InstancesPlantAtSpecifiedOffsets.py index 07d4fbd067..6be3dc31f7 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/PositionModifier_ComponentAndOverrides_InstancesPlantAtSpecifiedOffsets.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/PositionModifier_ComponentAndOverrides_InstancesPlantAtSpecifiedOffsets.py @@ -102,16 +102,17 @@ def PositionModifier_ComponentAndOverrides_InstancesPlantAtSpecifiedOffsets(): return offset_success and offset_success2 # 1) Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # Set view of planting area for visual debugging general.set_current_view_position(16.0, -5.0, 32.0) # 2) Create a new entity with required vegetation area components spawner_center_point = math.Vector3(16.0, 16.0, 32.0) - asset_path = os.path.join("Slices", "PinkFlower.dynamicslice") - spawner_entity = dynveg.create_dynamic_slice_vegetation_area("Instance Spawner", spawner_center_point, 1.0, 1.0, 1.0, asset_path) + pink_flower_asset_path = os.path.join("assets", "objects", "foliage", "grass_flower_pink.azmodel") + pink_flower_prefab = dynveg.create_temp_mesh_prefab(pink_flower_asset_path, "PosMod_PinkFlower2")[0] + spawner_entity = dynveg.create_temp_prefab_vegetation_area("Instance Spawner", spawner_center_point, 1.0, 1.0, + 1.0, pink_flower_prefab) # Add a Vegetation Position Modifier and set offset values to 0 spawner_entity.add_component("Vegetation Position Modifier") diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/DynamicSliceInstanceSpawner_Embedded_E2E.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/PrefabInstanceSpawner_Embedded_E2E.py similarity index 87% rename from AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/DynamicSliceInstanceSpawner_Embedded_E2E.py rename to AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/PrefabInstanceSpawner_Embedded_E2E.py index b4650c782e..8ce865b5d2 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/DynamicSliceInstanceSpawner_Embedded_E2E.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/PrefabInstanceSpawner_Embedded_E2E.py @@ -63,12 +63,14 @@ def DynamicSliceInstanceSpawner_Embedded_E2E(): import azlmbr.entity as entity import azlmbr.math as math import azlmbr.paths as paths + import azlmbr.vegetation as vegetation import editor_python_test_tools.hydra_editor_utils as hydra from largeworlds.large_worlds_utils import editor_dynveg_test_helper as dynveg from editor_python_test_tools.utils import Report from editor_python_test_tools.utils import TestHelper as helper + # 1) Create a new, temporary level lvl_name = "tmp_level" helper.init_idle() @@ -79,13 +81,14 @@ def DynamicSliceInstanceSpawner_Embedded_E2E(): # 2) Create a new entity with required vegetation area components and Script Canvas component for launcher test center_point = math.Vector3(512.0, 512.0, 32.0) - asset_path = os.path.join("Slices", "PinkFlower.dynamicslice") - spawner_entity = dynveg.create_dynamic_slice_vegetation_area("Instance Spawner", center_point, 16.0, 16.0, 1.0, asset_path) + pink_flower_prefab_path = os.path.join("assets", "prefabs", "PinkFlower.spawnable") + spawner_entity = dynveg.create_prefab_vegetation_area("Instance Spawner", center_point, 16.0, 16.0, 1.0, + pink_flower_prefab_path) spawner_entity.add_component("Script Canvas") instance_counter_path = os.path.join("scriptcanvas", "instance_counter.scriptcanvas") instance_counter_script = asset.AssetCatalogRequestBus(bus.Broadcast, "GetAssetIdByPath", instance_counter_path, math.Uuid(), False) - spawner_entity.get_set_test(3, "Script Canvas Asset|Script Canvas Asset", instance_counter_script) + spawner_entity.get_set_test(3, "Properties", instance_counter_script) Report.result(Tests.spawner_entity_created, spawner_entity.id.IsValid() and hydra.has_components(spawner_entity.id, ["Script Canvas"])) @@ -106,11 +109,10 @@ def DynamicSliceInstanceSpawner_Embedded_E2E(): search_entity_ids = entity.SearchBus(bus.Broadcast, 'SearchEntities', search_filter) components.TransformBus(bus.Event, "MoveEntity", search_entity_ids[0], cam_position) - # 6) Save and export to engine + # 6) Save the created level general.save_level() - general.export_to_engine() - pak_path = os.path.join(paths.products, "levels", lvl_name, "level.pak") - success = helper.wait_for_condition(lambda: os.path.exists(pak_path), 10.0) + level_prefab_path = os.path.join(paths.products, "levels", lvl_name, f"{lvl_name}.spawnable") + success = helper.wait_for_condition(lambda: os.path.exists(level_prefab_path), 5.0) Report.result(Tests.saved_and_exported, success) diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/DynamicSliceInstanceSpawner_External_E2E.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/PrefabInstanceSpawner_External_E2E.py similarity index 96% rename from AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/DynamicSliceInstanceSpawner_External_E2E.py rename to AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/PrefabInstanceSpawner_External_E2E.py index a5e7e90ce2..a3e60f6337 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/DynamicSliceInstanceSpawner_External_E2E.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/PrefabInstanceSpawner_External_E2E.py @@ -128,11 +128,10 @@ def DynamicSliceInstanceSpawner_External_E2E(): search_entity_ids = entity.SearchBus(bus.Broadcast, 'SearchEntities', search_filter) components.TransformBus(bus.Event, "MoveEntity", search_entity_ids[0], cam_position) - # 6) Save and export to engine + # 6) Save the created level general.save_level() - general.export_to_engine() - pak_path = os.path.join(paths.products, "levels", lvl_name, "level.pak") - success = helper.wait_for_condition(lambda: os.path.exists(pak_path), 10.0) + level_prefab_path = os.path.join(paths.products, "levels", lvl_name, f"{lvl_name}.spawnable") + success = helper.wait_for_condition(lambda: os.path.exists(level_prefab_path), 5.0) Report.result(Tests.saved_and_exported, success) diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/RotationModifierOverrides_InstancesRotateWithinRange.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/RotationModifierOverrides_InstancesRotateWithinRange.py index c1ea8e03d1..877a38c231 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/RotationModifierOverrides_InstancesRotateWithinRange.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/RotationModifierOverrides_InstancesRotateWithinRange.py @@ -81,14 +81,15 @@ def RotationModifierOverrides_InstancesRotateWithinRange(): return result # 1) Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() general.set_current_view_position(512.0, 480.0, 38.0) # 2) Create vegetation entity and add components entity_position = math.Vector3(512.0, 512.0, 32.0) - asset_path = os.path.join("Slices", "PurpleFlower.dynamicslice") - spawner_entity = dynveg.create_dynamic_slice_vegetation_area("Spawner Entity", entity_position, 16.0, 16.0, 16.0, asset_path) + pink_flower_asset_path = os.path.join("assets", "objects", "foliage", "grass_flower_pink.azmodel") + pink_flower_prefab = dynveg.create_temp_mesh_prefab(pink_flower_asset_path, "RotMod_PinkFlower2")[0] + spawner_entity = dynveg.create_temp_prefab_vegetation_area("Instance Spawner", entity_position, 16.0, 16.0, 16.0, + pink_flower_prefab) spawner_entity.add_component("Vegetation Rotation Modifier") # Our default vegetation settings places 20 instances per 16 meters, so we expect 20 * 20 total instances. num_expected = 20 * 20 diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/RotationModifier_InstancesRotateWithinRange.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/RotationModifier_InstancesRotateWithinRange.py index 518c11a0cf..b0999f3195 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/RotationModifier_InstancesRotateWithinRange.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/RotationModifier_InstancesRotateWithinRange.py @@ -120,13 +120,14 @@ def RotationModifier_InstancesRotateWithinRange(): # Main Script # 1) Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() general.set_current_view_position(512.0, 480.0, 38.0) # 2) Set up vegetation entities - asset_path = os.path.join("Slices", "PurpleFlower.dynamicslice") - spawner_entity = dynveg.create_dynamic_slice_vegetation_area("Spawner Entity", LEVEL_CENTER, 2.0, 2.0, 2.0, asset_path) + pink_flower_asset_path = os.path.join("assets", "objects", "foliage", "grass_flower_pink.azmodel") + pink_flower_prefab = dynveg.create_temp_mesh_prefab(pink_flower_asset_path, "RotMod_PinkFlower")[0] + spawner_entity = dynveg.create_temp_prefab_vegetation_area("Instance Spawner", LEVEL_CENTER, 2.0, 2.0, 2.0, + pink_flower_prefab) additional_components = [ "Vegetation Rotation Modifier" diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/ScaleModifierOverrides_InstancesProperlyScale.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/ScaleModifierOverrides_InstancesProperlyScale.py index b2ce6d8afa..42b042e26e 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/ScaleModifierOverrides_InstancesProperlyScale.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/ScaleModifierOverrides_InstancesProperlyScale.py @@ -91,16 +91,17 @@ def ScaleModifierOverrides_InstancesProperlyScale(): return False # 1) Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() general.set_current_view_position(500.49, 498.69, 46.66) general.set_current_view_rotation(-42.05, 0.00, -36.33) # 2) Create a new entity with components "Vegetation Layer Spawner", "Vegetation Asset List", "Box Shape" entity_position = math.Vector3(512.0, 512.0, 32.0) - asset_path = os.path.join("Slices", "PurpleFlower.dynamicslice") - spawner_entity = dynveg.create_dynamic_slice_vegetation_area("Spawner Entity", entity_position, 16.0, 16.0, 10.0, asset_path) + pink_flower_asset_path = os.path.join("assets", "objects", "foliage", "grass_flower_pink.azmodel") + pink_flower_prefab = dynveg.create_temp_mesh_prefab(pink_flower_asset_path, "ScaleMod_PinkFlower2")[0] + spawner_entity = dynveg.create_temp_prefab_vegetation_area("Instance Spawner", entity_position, 16.0, 16.0, 16.0, + pink_flower_prefab) # Create a surface to plant on and add a Vegetation Debugger Level component to allow refreshes dynveg.create_surface_entity("Surface Entity", entity_position, 20.0, 20.0, 1.0) diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/ScaleModifier_InstancesProperlyScale.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/ScaleModifier_InstancesProperlyScale.py index fd0df1c83d..8008224e3e 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/ScaleModifier_InstancesProperlyScale.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/ScaleModifier_InstancesProperlyScale.py @@ -84,8 +84,7 @@ def ScaleModifier_InstancesProperlyScale(): return False # 1) Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() general.set_current_view_position(500.49, 498.69, 46.66) general.set_current_view_rotation(-42.05, 0.00, -36.33) @@ -93,9 +92,10 @@ def ScaleModifier_InstancesProperlyScale(): # 2) Create a new entity with components Vegetation Layer Spawner, Vegetation Asset List, Box Shape and # Vegetation Scale Modifier entity_position = math.Vector3(512.0, 512.0, 32.0) - asset_path = os.path.join("Slices", "PurpleFlower.dynamicslice") - spawner_entity = dynveg.create_dynamic_slice_vegetation_area("Spawner Entity", entity_position, 16.0, 16.0, 16.0, - asset_path) + pink_flower_asset_path = os.path.join("assets", "objects", "foliage", "grass_flower_pink.azmodel") + pink_flower_prefab = dynveg.create_temp_mesh_prefab(pink_flower_asset_path, "ScaleMod_PinkFlower")[0] + spawner_entity = dynveg.create_temp_prefab_vegetation_area("Instance Spawner", entity_position, 16.0, 16.0, 16.0, + pink_flower_prefab) spawner_entity.add_component("Vegetation Scale Modifier") # Create a surface to plant on and add a Vegetation Debugger Level component to allow refreshes 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 b5c00a53b7..5436855433 100644 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/ShapeIntersectionFilter_FilterStageToggle.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/ShapeIntersectionFilter_FilterStageToggle.py @@ -49,15 +49,16 @@ def ShapeIntersectionFilter_FilterStageToggle(): from editor_python_test_tools.utils import TestHelper as helper # Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() general.set_current_view_position(512.0, 480.0, 38.0) # Create basic vegetation entity position = math.Vector3(512.0, 512.0, 32.0) - asset_path = os.path.join("Slices", "PinkFlower.dynamicslice") - vegetation = dynveg.create_dynamic_slice_vegetation_area("vegetation", position, 16.0, 16.0, 16.0, asset_path) + pink_flower_asset_path = os.path.join("assets", "objects", "foliage", "grass_flower_pink.azmodel") + pink_flower_prefab = dynveg.create_temp_mesh_prefab(pink_flower_asset_path, "ShapeIntersection_PinkFlower")[0] + vegetation = dynveg.create_temp_prefab_vegetation_area("Instance Spawner", position, 16.0, 16.0, 16.0, + pink_flower_prefab) # Create Surface for instances to plant on dynveg.create_surface_entity("Surface_Entity_Parent", position, 16.0, 16.0, 1.0) diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/ShapeIntersectionFilter_InstancesPlantInAssignedShape.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/ShapeIntersectionFilter_InstancesPlantInAssignedShape.py index 6678a620af..e9e4c722f1 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/ShapeIntersectionFilter_InstancesPlantInAssignedShape.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/ShapeIntersectionFilter_InstancesPlantInAssignedShape.py @@ -60,8 +60,7 @@ def ShapeIntersectionFilter_InstancesPlantInAssignedShape(): from editor_python_test_tools.utils import TestHelper as helper # 1) Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # Set view of planting area for visual debugging general.set_current_view_position(512.0, 500.0, 38.0) @@ -69,9 +68,10 @@ def ShapeIntersectionFilter_InstancesPlantInAssignedShape(): # 2) Create a new entity with required vegetation area components and Vegetation Shape Intersection Filter center_point = math.Vector3(512.0, 512.0, 32.0) - asset_path = os.path.join("Slices", "PinkFlower.dynamicslice") - spawner_entity = dynveg.create_dynamic_slice_vegetation_area("Instance Spawner", center_point, 16.0, 16.0, 1.0, - asset_path) + pink_flower_asset_path = os.path.join("assets", "objects", "foliage", "grass_flower_pink.azmodel") + pink_flower_prefab = dynveg.create_temp_mesh_prefab(pink_flower_asset_path, "ShapeIntersection_PinkFlower2")[0] + spawner_entity = dynveg.create_temp_prefab_vegetation_area("Instance Spawner", center_point, 16.0, 16.0, 1.0, + pink_flower_prefab) spawner_entity.add_component("Vegetation Shape Intersection Filter") # Create a planting surface diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SlopeAlignmentModifierOverrides_InstanceSurfaceAlignment.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SlopeAlignmentModifierOverrides_InstanceSurfaceAlignment.py index c9233d15ea..07dbb3f977 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SlopeAlignmentModifierOverrides_InstanceSurfaceAlignment.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SlopeAlignmentModifierOverrides_InstanceSurfaceAlignment.py @@ -58,15 +58,16 @@ def SlopeAlignmentModifierOverrides_InstanceSurfaceAlignment(): return False # Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() general.set_current_view_position(512.0, 480.0, 38.0) # Create a spawner entity setup with all needed components center_point = math.Vector3(512.0, 512.0, 32.0) - asset_path = os.path.join("Slices", "PinkFlower.dynamicslice") - spawner_entity = dynveg.create_dynamic_slice_vegetation_area("Instance Spawner", center_point, 16.0, 16.0, 32.0, asset_path) + pink_flower_asset_path = os.path.join("assets", "objects", "foliage", "grass_flower_pink.azmodel") + pink_flower_prefab = dynveg.create_temp_mesh_prefab(pink_flower_asset_path, "SlopeAlign_PinkFlower2")[0] + spawner_entity = dynveg.create_temp_prefab_vegetation_area("Instance Spawner", center_point, 16.0, 16.0, 32.0, + pink_flower_prefab) # Create a sloped mesh surface for the instances to plant on center_point = math.Vector3(502.0, 512.0, 24.0) diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SlopeAlignmentModifier_InstanceSurfaceAlignment.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SlopeAlignmentModifier_InstanceSurfaceAlignment.py index d92babffa4..088728480b 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SlopeAlignmentModifier_InstanceSurfaceAlignment.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SlopeAlignmentModifier_InstanceSurfaceAlignment.py @@ -59,15 +59,16 @@ def SlopeAlignmentModifier_InstanceSurfaceAlignment(): return False # Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() general.set_current_view_position(512.0, 480.0, 38.0) # Create a spawner entity setup with all needed components center_point = math.Vector3(512.0, 512.0, 32.0) - asset_path = os.path.join("Slices", "PinkFlower.dynamicslice") - spawner_entity = dynveg.create_dynamic_slice_vegetation_area("Instance Spawner", center_point, 16.0, 16.0, 32.0, asset_path) + pink_flower_asset_path = os.path.join("assets", "objects", "foliage", "grass_flower_pink.azmodel") + pink_flower_prefab = dynveg.create_temp_mesh_prefab(pink_flower_asset_path, "SlopeAlign_PinkFlower")[0] + spawner_entity = dynveg.create_temp_prefab_vegetation_area("Instance Spawner", center_point, 16.0, 16.0, 32.0, + pink_flower_prefab) # Create a sloped mesh surface for the instances to plant on center_point = math.Vector3(502.0, 512.0, 24.0) diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SlopeFilter_ComponentAndOverrides_InstancesPlantOnValidSlope.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SlopeFilter_ComponentAndOverrides_InstancesPlantOnValidSlope.py index 0f95853156..cc04dc4cb1 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SlopeFilter_ComponentAndOverrides_InstancesPlantOnValidSlope.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SlopeFilter_ComponentAndOverrides_InstancesPlantOnValidSlope.py @@ -63,16 +63,17 @@ def SlopeFilter_ComponentAndOverrides_InstancesPlantOnValidSlopes(): from editor_python_test_tools.utils import TestHelper as helper # 1) Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # Set view of planting area for visual debugging general.set_current_view_position(512.0, 475.0, 38.0) # 2) Create a new entity with required vegetation area components center_point = math.Vector3(512.0, 512.0, 32.0) - asset_path = os.path.join("Slices", "PinkFlower.dynamicslice") - spawner_entity = dynveg.create_dynamic_slice_vegetation_area("Instance Spawner", center_point, 32.0, 32.0, 32.0, asset_path) + pink_flower_asset_path = os.path.join("assets", "objects", "foliage", "grass_flower_pink.azmodel") + pink_flower_prefab = dynveg.create_temp_mesh_prefab(pink_flower_asset_path, "Slope_PinkFlower")[0] + spawner_entity = dynveg.create_temp_prefab_vegetation_area("Instance Spawner", center_point, 32.0, 32.0, 32.0, + pink_flower_prefab) # Add a Vegetation Slope Filter spawner_entity.add_component("Vegetation Slope Filter") diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SpawnerSlices_SliceCreationAndVisibilityToggleWorks.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SpawnerPrefabs_PrefabCreationAndVisibilityToggleWorks.py similarity index 52% rename from AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SpawnerSlices_SliceCreationAndVisibilityToggleWorks.py rename to AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SpawnerPrefabs_PrefabCreationAndVisibilityToggleWorks.py index fc55080cec..182bd5510a 100644 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SpawnerSlices_SliceCreationAndVisibilityToggleWorks.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SpawnerPrefabs_PrefabCreationAndVisibilityToggleWorks.py @@ -7,21 +7,21 @@ SPDX-License-Identifier: Apache-2.0 OR MIT class Tests: - spawner_slice_created = ( - "Spawner slice created successfully", - "Failed to create Spawner slice" + spawner_prefab_created = ( + "Spawner prefab created successfully", + "Failed to create Spawner prefab" ) instance_count_unhidden = ( "Initial instance counts are as expected", "Found an unexpected number of initial instances" ) instance_count_hidden = ( - "Instance counts upon hiding the Spawner slice are as expected", - "Unexpectedly found instances with the Spawner slice hidden" + "Instance counts upon hiding the Spawner prefab are as expected", + "Unexpectedly found instances with the Spawner prefab hidden" ) - blender_slice_created = ( - "Blender slice created successfully", - "Failed to create Blender slice" + blender_prefab_created = ( + "Blender prefab created successfully", + "Failed to create Blender prefab" ) @@ -43,81 +43,76 @@ def SpawnerSlices_SliceCreationAndVisibilityToggleWorks(): import azlmbr.math as math import azlmbr.legacy.general as general - import azlmbr.slice as slice import azlmbr.bus as bus import azlmbr.editor as editor - import azlmbr.asset as asset import editor_python_test_tools.hydra_editor_utils as hydra from largeworlds.large_worlds_utils import editor_dynveg_test_helper as dynveg + from editor_python_test_tools.editor_entity_utils import EditorEntity from editor_python_test_tools.utils import Report from editor_python_test_tools.utils import TestHelper as helper - - def path_is_valid_asset(asset_path): - asset_id = asset.AssetCatalogRequestBus(bus.Broadcast, "GetAssetIdByPath", asset_path, math.Uuid(), False) - return asset_id.invoke("IsValid") + from editor_python_test_tools.prefab_utils import Prefab # 1) Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() general.set_current_view_position(512.0, 480.0, 38.0) - # 2) C2627900 Verifies if a slice containing the Vegetation Layer Spawner component can be created. + # 2) Verifies if a prefab containing the Vegetation Layer Spawner component can be created. # 2.1) Create basic vegetation entity position = math.Vector3(512.0, 512.0, 32.0) - asset_path = os.path.join("Slices", "PinkFlower.dynamicslice") - veg_1 = dynveg.create_dynamic_slice_vegetation_area("vegetation_1", position, 16.0, 16.0, 16.0, asset_path) + pink_flower_asset_path = os.path.join("assets", "objects", "foliage", "grass_flower_pink.azmodel") + pink_flower_prefab = dynveg.create_temp_mesh_prefab(pink_flower_asset_path, "SpawnerPrefab_PinkFlower")[0] + veg_1 = dynveg.create_temp_prefab_vegetation_area("vegetation_1", position, 16.0, 16.0, 16.0, + pink_flower_prefab) - # 2.2) Create slice from the entity - slice_path = os.path.join("slices", "TestSlice_1.slice") - slice.SliceRequestBus(bus.Broadcast, "CreateNewSlice", veg_1.id, slice_path) + # 2.2) Create prefab from the entity + spawner_prefab_filename = "TestPrefab_1" + spawner_prefab, spawner_prefab_instance = Prefab.create_prefab([veg_1], spawner_prefab_filename) - # 2.3) Verify if the slice has been created successfully - spawner_slice_success = helper.wait_for_condition(lambda: path_is_valid_asset(slice_path), 10.0) - Report.result(Tests.spawner_slice_created, spawner_slice_success) + # Verify if prefab is created + Report.result(Tests.spawner_prefab_created, spawner_prefab.is_prefab_loaded(spawner_prefab_filename)) - # 3) C2627904: Hiding a slice containing the component clears any visuals from the Viewport + # 3) Hiding a prefab containing the component clears any visuals from the Viewport # 3.1) Create Surface for instances to plant on dynveg.create_surface_entity("Surface_Entity", position, 16.0, 16.0, 1.0) - # 3.2) Initially verify instance count before hiding slice + # 3.2) Initially verify instance count before hiding prefab initial_count_success = helper.wait_for_condition(lambda: dynveg.validate_instance_count(position, 16.0, 400), 5.0) Report.result(Tests.instance_count_unhidden, initial_count_success) - # 3.3) Hide the slice and verify instance count - editor.EditorEntityAPIBus(bus.Event, "SetVisibilityState", veg_1.id, False) + # 3.3) Hide the prefab and verify instance count + editor.EditorEntityAPIBus(bus.Event, "SetVisibilityState", spawner_prefab_instance.container_entity.id, False) hidden_instance_count = helper.wait_for_condition(lambda: dynveg.validate_instance_count(position, 16.0, 0), 5.0) Report.result(Tests.instance_count_hidden, hidden_instance_count) # 3.4) Unhide the slice - editor.EditorEntityAPIBus(bus.Event, "SetVisibilityState", veg_1.id, True) + editor.EditorEntityAPIBus(bus.Event, "SetVisibilityState", spawner_prefab_instance.container_entity.id, True) - # 4) C2627905 A slice containing the Vegetation Layer Blender component can be created. + # 4) A slice containing the Vegetation Layer Blender component can be created. # 4.1) Create another vegetation entity to add to blender component - veg_2 = dynveg.create_dynamic_slice_vegetation_area("vegetation_2", position, 1.0, 1.0, 1.0, "") + veg_2 = dynveg.create_empty_vegetation_area("vegetation_2", position, 1.0, 1.0, 1.0) # 4.2) Create entity with Vegetation Layer Blender components_to_add = ["Box Shape", "Vegetation Layer Blender"] - blender_entity = hydra.Entity("blender_entity") - blender_entity.create_entity(position, components_to_add) + blender_entity = EditorEntity.create_editor_entity("blender_entity") + blender_entity.add_components(components_to_add) # 4.3) Pin both the vegetation areas to the blender entity - pte = hydra.get_property_tree(blender_entity.components[1]) + pte = blender_entity.components[1].get_property_tree() path = "Configuration|Vegetation Areas" pte.update_container_item(path, 0, veg_1.id) pte.add_container_item(path, 1, veg_2.id) # 4.4) Drag the simple vegetation areas under the Vegetation Layer Blender entity to create an entity hierarchy. veg_1.set_test_parent_entity(blender_entity) - veg_2.set_test_parent_entity(blender_entity) + veg_2.set_parent_entity(blender_entity.id) - # 4.5) Create slice from blender entity - slice_path = os.path.join("slices", "TestSlice_2.slice") - slice.SliceRequestBus(bus.Broadcast, "CreateNewSlice", blender_entity.id, slice_path) + # 4.5) Create prefab from blender entity + blender_prefab_filename = "TestPrefab_2" + blender_prefab, blender_prefab_instance = Prefab.create_prefab([veg_2], blender_prefab_filename) - # 4.6) Verify if the slice has been created successfully - blender_slice_success = helper.wait_for_condition(lambda: path_is_valid_asset(slice_path), 5.0) - Report.result(Tests.blender_slice_created, blender_slice_success) + # 4.6) Verify if the prefab has been created successfully + Report.result(Tests.blender_prefab_created, blender_prefab.is_prefab_loaded(blender_prefab_filename)) if __name__ == "__main__": diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SurfaceDataRefreshes_RemainsStable.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SurfaceDataRefreshes_RemainsStable.py index 1ad4f305c3..3612e03bcc 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SurfaceDataRefreshes_RemainsStable.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SurfaceDataRefreshes_RemainsStable.py @@ -34,13 +34,12 @@ def SurfaceDataRefreshes_RemainsStable(): import azlmbr.legacy.general as general import azlmbr.math as math + import editor_python_test_tools.hydra_editor_utils as hydra from largeworlds.large_worlds_utils import editor_dynveg_test_helper as dynveg from editor_python_test_tools.utils import Report - from editor_python_test_tools.utils import TestHelper as helper # 1) Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() world_center = math.Vector3(512.0, 512.0, 32.0) diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SurfaceMaskFilterOverrides_MultipleDescriptorOverridesPlantAsExpected.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SurfaceMaskFilterOverrides_MultipleDescriptorOverridesPlantAsExpected.py index 3e76a03c53..b98b0f0546 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SurfaceMaskFilterOverrides_MultipleDescriptorOverridesPlantAsExpected.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SurfaceMaskFilterOverrides_MultipleDescriptorOverridesPlantAsExpected.py @@ -67,8 +67,7 @@ def SurfaceMaskFilterOverrides_MultipleDescriptorOverridesPlantAsExpected(): surface_data.SurfaceTag("test_tag3")] # 1) Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # Set view of planting area for visual debugging general.set_current_view_position(512.0, 500.0, 38.0) @@ -76,9 +75,10 @@ def SurfaceMaskFilterOverrides_MultipleDescriptorOverridesPlantAsExpected(): # 2) Create a new instance spawner entity with multiple Dynamic Slice Instance Spawner descriptors spawner_center_point = math.Vector3(512.0, 512.0, 32.0) - asset_path = os.path.join("Slices", "PinkFlower.dynamicslice") - spawner_entity = dynveg.create_dynamic_slice_vegetation_area("Instance Spawner", spawner_center_point, 16.0, 16.0, 16.0, - asset_path) + pink_flower_asset_path = os.path.join("assets", "objects", "foliage", "grass_flower_pink.azmodel") + pink_flower_prefab = dynveg.create_temp_mesh_prefab(pink_flower_asset_path, "SurfaceMaskOverrides_PinkFlower")[0] + spawner_entity = dynveg.create_temp_prefab_vegetation_area("Instance Spawner", spawner_center_point, 16.0, 16.0, + 16.0, pink_flower_prefab) asset_list_component = spawner_entity.components[2] desc_asset = hydra.get_component_property_value(asset_list_component, "Configuration|Embedded Assets")[0] diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SurfaceMaskFilter_BasicSurfaceTagCreation.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SurfaceMaskFilter_BasicSurfaceTagCreation.py index fee62c04d1..fe17b03c6f 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SurfaceMaskFilter_BasicSurfaceTagCreation.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SurfaceMaskFilter_BasicSurfaceTagCreation.py @@ -39,12 +39,12 @@ def SurfaceMaskFilter_BasicSurfaceTagCreation(): """ import azlmbr.surface_data as surface_data + + import editor_python_test_tools.hydra_editor_utils as hydra from editor_python_test_tools.utils import Report - from editor_python_test_tools.utils import TestHelper as helper # Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() tag1 = surface_data.SurfaceTag() tag2 = surface_data.SurfaceTag() diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SurfaceMaskFilter_ExclusionList.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SurfaceMaskFilter_ExclusionList.py index 3f298e793e..f5174af3bb 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SurfaceMaskFilter_ExclusionList.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SurfaceMaskFilter_ExclusionList.py @@ -91,18 +91,16 @@ def SurfaceMaskFilter_ExclusionList(): Report.info(f"Failed to add Generated surface tag of {surface_tag}") # 1) Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() general.set_current_view_position(512.0, 480.0, 38.0) # 2) Create entity with components "Vegetation Layer Spawner", "Vegetation Asset List", "Box Shape" entity_position = math.Vector3(512.0, 512.0, 32.0) - asset_path = os.path.join("Slices", "PurpleFlower.dynamicslice") - spawner_entity = dynveg.create_dynamic_slice_vegetation_area("Instance Spawner", - entity_position, - 10.0, 10.0, 10.0, - asset_path) + pink_flower_asset_path = os.path.join("assets", "objects", "foliage", "grass_flower_pink.azmodel") + pink_flower_prefab = dynveg.create_temp_mesh_prefab(pink_flower_asset_path, "SurfaceMaskTagExclusion_PinkFlower")[0] + spawner_entity = dynveg.create_temp_prefab_vegetation_area("Instance Spawner", entity_position, 10.0, 10.0, 10.0, + pink_flower_prefab) # 3) Add a Vegetation Surface Mask Filter component to the entity. spawner_entity.add_component("Vegetation Surface Mask Filter") diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SurfaceMaskFilter_InclusionList.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SurfaceMaskFilter_InclusionList.py index 39b72ff4a9..34d22d3d9b 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SurfaceMaskFilter_InclusionList.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SurfaceMaskFilter_InclusionList.py @@ -92,18 +92,16 @@ def SurfaceMaskFilter_InclusionList(): Report.info(f"Failed to add Generated surface tag of {surface_tag}") # 1) Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() general.set_current_view_position(512.0, 480.0, 38.0) # 2) Create entity with components "Vegetation Layer Spawner", "Vegetation Asset List", "Box Shape" entity_position = math.Vector3(512.0, 512.0, 32.0) - asset_path = os.path.join("Slices", "PurpleFlower.dynamicslice") - spawner_entity = dynveg.create_dynamic_slice_vegetation_area("Instance Spawner", - entity_position, - 10.0, 10.0, 10.0, - asset_path) + pink_flower_asset_path = os.path.join("assets", "objects", "foliage", "grass_flower_pink.azmodel") + pink_flower_prefab = dynveg.create_temp_mesh_prefab(pink_flower_asset_path, "SurfaceMaskTagInclusion_PinkFlower")[0] + spawner_entity = dynveg.create_temp_prefab_vegetation_area("Instance Spawner", entity_position, 10.0, 10.0, 10.0, + pink_flower_prefab) # 3) Add a Vegetation Surface Mask Filter component to the entity. spawner_entity.add_component("Vegetation Surface Mask Filter") diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SystemSettings_SectorPointDensity.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SystemSettings_SectorPointDensity.py index 167fb8901c..7516bfb31d 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SystemSettings_SectorPointDensity.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SystemSettings_SectorPointDensity.py @@ -47,15 +47,16 @@ def SystemSettings_SectorPointDensity(): INSTANCE_COUNT_AFTER_DENSITY_CHANGE = 100 # Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() general.set_current_view_position(512.0, 480.0, 38.0) # Create basic vegetation entity position = math.Vector3(512.0, 512.0, 32.0) - asset_path = os.path.join("Slices", "PinkFlower.dynamicslice") - dynveg.create_dynamic_slice_vegetation_area("vegetation", position, 16.0, 16.0, 1.0, asset_path) + pink_flower_asset_path = os.path.join("assets", "objects", "foliage", "grass_flower_pink.azmodel") + pink_flower_prefab = dynveg.create_temp_mesh_prefab(pink_flower_asset_path, "SectorPoint_PinkFlower")[0] + spawner_entity = dynveg.create_temp_prefab_vegetation_area("Instance Spawner", position, 16.0, 16.0, 1.0, + pink_flower_prefab) dynveg.create_surface_entity("Surface_Entity", position, 16.0, 16.0, 1.0) # Count the number of vegetation instances in the vegetation area diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SystemSettings_SectorSize.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SystemSettings_SectorSize.py index 7bb78ac3e0..ef7959a3e7 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SystemSettings_SectorSize.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/SystemSettings_SectorSize.py @@ -43,15 +43,16 @@ def SystemSettings_SectorSize(): VEGETATION_INSTANCE_COUNT = 400 # Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() general.set_current_view_position(512.0, 480.0, 38.0) # Create basic vegetation entity position = math.Vector3(512.0, 512.0, 32.0) - asset_path = os.path.join("Slices", "PinkFlower.dynamicslice") - vegetation = dynveg.create_dynamic_slice_vegetation_area("vegetation", position, 16.0, 16.0, 1.0, asset_path) + pink_flower_asset_path = os.path.join("assets", "objects", "foliage", "grass_flower_pink.azmodel") + pink_flower_prefab = dynveg.create_temp_mesh_prefab(pink_flower_asset_path, "SectorSize_PinkFlower")[0] + vegetation = dynveg.create_temp_prefab_vegetation_area("Instance Spawner", position, 16.0, 16.0, 1.0, + pink_flower_prefab) dynveg.create_surface_entity("Surface_Entity", position, 16.0, 16.0, 1.0) # Add the Vegetation Debugger component to the Level Inspector diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/VegetationInstances_DespawnWhenOutOfRange.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/VegetationInstances_DespawnWhenOutOfRange.py index 8a6c4d9a17..b6069d1ef5 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/VegetationInstances_DespawnWhenOutOfRange.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/EditorScripts/VegetationInstances_DespawnWhenOutOfRange.py @@ -43,18 +43,20 @@ def VegetationInstances_DespawnWhenOutOfRange(): import azlmbr.legacy.general as general import azlmbr.math as math + import editor_python_test_tools.hydra_editor_utils as hydra from largeworlds.large_worlds_utils import editor_dynveg_test_helper as dynveg from editor_python_test_tools.utils import Report from editor_python_test_tools.utils import TestHelper as helper # Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # Create vegetation layer spawner world_center = math.Vector3(512.0, 512.0, 32.0) - asset_path = os.path.join("Slices", "PurpleFlower.dynamicslice") - spawner_entity = dynveg.create_dynamic_slice_vegetation_area("Spawner Instance", world_center, 16.0, 16.0, 16.0, asset_path) + pink_flower_asset_path = os.path.join("assets", "objects", "foliage", "grass_flower_pink.azmodel") + pink_flower_prefab = dynveg.create_temp_mesh_prefab(pink_flower_asset_path, "RangeDespawn_PinkFlower")[0] + spawner_entity = dynveg.create_temp_prefab_vegetation_area("Instance Spawner", world_center, 16.0, 16.0, 16.0, + pink_flower_prefab) # Create a surface to spawn on dynveg.create_surface_entity("Spawner Entity", world_center, 16.0, 16.0, 1.0) diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/TestSuite_Main.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/TestSuite_Main.py index 06c9c5f615..d508e390cb 100644 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/TestSuite_Main.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/TestSuite_Main.py @@ -7,21 +7,171 @@ SPDX-License-Identifier: Apache-2.0 OR MIT import os import pytest -import sys -sys.path.append(os.path.dirname(os.path.abspath(__file__)) + '/../../automatedtesting_shared') -from base import TestAutomationBase +import ly_test_tools.environment.file_system as file_system +from ly_test_tools.o3de.editor_test import EditorSingleTest, EditorSharedTest, EditorParallelTest, EditorTestSuite @pytest.mark.SUITE_main @pytest.mark.parametrize("launcher_platform", ['windows_editor']) @pytest.mark.parametrize("project", ["AutomatedTesting"]) -class TestAutomation(TestAutomationBase): +class TestAutomation(EditorTestSuite): - def test_DynamicSliceInstanceSpawner_DynamicSliceSpawnerWorks(self, request, workspace, editor, launcher_platform): + # Helpers for test asset cleanup + def cleanup_test_level(self, workspace): + file_system.delete([os.path.join(workspace.paths.engine_root(), "AutomatedTesting", "Levels", "tmp_level")], + True, True) + + class test_AltitudeFilter_ComponentAndOverrides_InstancesPlantAtSpecifiedAltitude(EditorSharedTest): + from .EditorScripts import AltitudeFilter_ComponentAndOverrides_InstancesPlantAtSpecifiedAltitude as test_module + + class test_AltitudeFilter_FilterStageToggle(EditorSharedTest): + from .EditorScripts import AltitudeFilter_FilterStageToggle as test_module + + class test_AltitudeFilter_ShapeSample_InstancesPlantAtSpecifiedAltitude(EditorSharedTest): + from .EditorScripts import AltitudeFilter_ShapeSample_InstancesPlantAtSpecifiedAltitude as test_module + + class test_AssetListCombiner_CombinedDescriptorsExpressInConfiguredArea(EditorSharedTest): + from .EditorScripts import AssetListCombiner_CombinedDescriptorsExpressInConfiguredArea as test_module + + class test_AssetWeightSelector_InstancesExpressBasedOnWeight(EditorSharedTest): + from .EditorScripts import AssetWeightSelector_InstancesExpressBasedOnWeight as test_module + + @pytest.mark.xfail(reason="https://github.com/o3de/o3de/issues/4155") + class test_DistanceBetweenFilter_InstancesPlantAtSpecifiedRadius(EditorSharedTest): + from .EditorScripts import DistanceBetweenFilter_InstancesPlantAtSpecifiedRadius as test_module + + @pytest.mark.xfail(reason="https://github.com/o3de/o3de/issues/4155") + class test_DistanceBetweenFilterOverrides_InstancesPlantAtSpecifiedRadius(EditorSharedTest): + from .EditorScripts import DistanceBetweenFilterOverrides_InstancesPlantAtSpecifiedRadius as test_module + + class test_DynamicSliceInstanceSpawner_DynamicSliceSpawnerWorks(EditorSharedTest): from .EditorScripts import DynamicSliceInstanceSpawner_DynamicSliceSpawnerWorks as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - def test_EmptyInstanceSpawner_EmptySpawnerWorks(self, request, workspace, editor, launcher_platform): + class test_EmptyInstanceSpawner_EmptySpawnerWorks(EditorSharedTest): from .EditorScripts import EmptyInstanceSpawner_EmptySpawnerWorks as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) + + class test_InstanceSpawnerPriority_LayerAndSubPriority_HigherValuesPlantOverLower(EditorSharedTest): + from .EditorScripts import InstanceSpawnerPriority_LayerAndSubPriority as test_module + + class test_LayerBlender_E2E_Editor(EditorSingleTest): + from .EditorScripts import LayerBlender_E2E_Editor as test_module + + # Custom setup/teardown to remove test level created during test + def setup(self, request, workspace, editor, editor_test_results, launcher_platform): + TestAutomation.cleanup_test_level(self, workspace) + + def teardown(self, request, workspace, editor, editor_test_results, launcher_platform): + TestAutomation.cleanup_test_level(self, workspace) + + class test_LayerBlocker_InstancesBlockedInConfiguredArea(EditorSharedTest): + from .EditorScripts import LayerBlocker_InstancesBlockedInConfiguredArea as test_module + + class test_LayerSpawner_FilterStageToggle(EditorSharedTest): + from .EditorScripts import LayerSpawner_FilterStageToggle as test_module + + class test_LayerSpawner_InheritBehaviorFlag(EditorSharedTest): + from .EditorScripts import LayerSpawner_InheritBehaviorFlag as test_module + + class test_LayerSpawner_InstancesPlantInAllSupportedShapes(EditorSharedTest): + from .EditorScripts import LayerSpawner_InstancesPlantInAllSupportedShapes as test_module + + @pytest.mark.xfail(reason="https://github.com/o3de/o3de/issues/6549") + class test_LayerSpawner_InstancesRefreshUsingCorrectViewportCamera(EditorSharedTest): + from .EditorScripts import LayerSpawner_InstancesRefreshUsingCorrectViewportCamera as test_module + + class test_MeshBlocker_InstancesBlockedByMesh(EditorSharedTest): + from .EditorScripts import MeshBlocker_InstancesBlockedByMesh as test_module + + class test_MeshBlocker_InstancesBlockedByMeshHeightTuning(EditorSharedTest): + from .EditorScripts import MeshBlocker_InstancesBlockedByMeshHeightTuning as test_module + + class test_MeshSurfaceTagEmitter_DependentOnMeshComponent(EditorSharedTest): + from .EditorScripts import MeshSurfaceTagEmitter_DependentOnMeshComponent as test_module + + class test_MeshSurfaceTagEmitter_SurfaceTagsAddRemoveSuccessfully(EditorSharedTest): + from .EditorScripts import MeshSurfaceTagEmitter_SurfaceTagsAddRemoveSuccessfully as test_module + + class test_PhysXColliderSurfaceTagEmitter_E2E_Editor(EditorSharedTest): + from .EditorScripts import PhysXColliderSurfaceTagEmitter_E2E_Editor as test_module + + class test_PositionModifier_AutoSnapToSurfaceWorks(EditorSharedTest): + from .EditorScripts import PositionModifier_AutoSnapToSurfaceWorks as test_module + + class test_PositionModifier_ComponentAndOverrides_InstancesPlantAtSpecifiedOffsets(EditorSharedTest): + from .EditorScripts import \ + PositionModifier_ComponentAndOverrides_InstancesPlantAtSpecifiedOffsets as test_module + + class test_PrefabInstanceSpawner_Embedded_E2E_Editor(EditorSingleTest): + from .EditorScripts import PrefabInstanceSpawner_Embedded_E2E as test_module + + # Custom setup/teardown to remove test level created during test + def setup(self, request, workspace, editor, editor_test_results, launcher_platform): + TestAutomation.cleanup_test_level(self, workspace) + + def teardown(self, request, workspace, editor, editor_test_results, launcher_platform): + TestAutomation.cleanup_test_level(self, workspace) + + class test_PrefabInstanceSpawner_External_E2E_Editor(EditorSingleTest): + from .EditorScripts import PrefabInstanceSpawner_External_E2E as test_module + + # Custom setup/teardown to remove test level created during test + def setup(self, request, workspace, editor, editor_test_results, launcher_platform): + TestAutomation.cleanup_test_level(self, workspace) + + def teardown(self, request, workspace, editor, editor_test_results, launcher_platform): + TestAutomation.cleanup_test_level(self, workspace) + + class test_RotationModifier_InstancesRotateWithinRange(EditorSharedTest): + from .EditorScripts import RotationModifier_InstancesRotateWithinRange as test_module + + class test_RotationModifierOverrides_InstancesRotateWithinRange(EditorSharedTest): + from .EditorScripts import RotationModifierOverrides_InstancesRotateWithinRange as test_module + + class test_ScaleModifier_InstancesProperlyScale(EditorSharedTest): + from .EditorScripts import ScaleModifier_InstancesProperlyScale as test_module + + class test_ScaleModifierOverrides_InstancesProperlyScale(EditorSharedTest): + from .EditorScripts import ScaleModifierOverrides_InstancesProperlyScale as test_module + + class test_ShapeIntersectionFilter_FilterStageToggle(EditorSharedTest): + from .EditorScripts import ShapeIntersectionFilter_FilterStageToggle as test_module + + class test_ShapeIntersectionFilter_InstancesPlantInAssignedShape(EditorSharedTest): + from .EditorScripts import ShapeIntersectionFilter_InstancesPlantInAssignedShape as test_module + + class test_SlopeAlignmentModifier_InstanceSurfaceAlignment(EditorSharedTest): + from .EditorScripts import SlopeAlignmentModifier_InstanceSurfaceAlignment as test_module + + class test_SlopeAlignmentModifierOverrides_InstanceSurfaceAlignment(EditorSharedTest): + from .EditorScripts import SlopeAlignmentModifierOverrides_InstanceSurfaceAlignment as test_module + + class test_SlopeFilter_ComponentAndOverrides_InstancesPlantOnValidSlopes(EditorSharedTest): + from .EditorScripts import SlopeFilter_ComponentAndOverrides_InstancesPlantOnValidSlope as test_module + + class test_SpawnerPrefabs_PrefabCreationAndVisibilityToggleWorks(EditorSharedTest): + from .EditorScripts import SpawnerPrefabs_PrefabCreationAndVisibilityToggleWorks as test_module + + class test_SurfaceDataRefreshes_RemainsStable(EditorSharedTest): + from .EditorScripts import SurfaceDataRefreshes_RemainsStable as test_module + + class test_SurfaceMaskFilter_BasicSurfaceTagCreation(EditorSharedTest): + from .EditorScripts import SurfaceMaskFilter_BasicSurfaceTagCreation as test_module + + class test_SurfaceMaskFilter_ExclusiveSurfaceTags_Function(EditorSharedTest): + from .EditorScripts import SurfaceMaskFilter_ExclusionList as test_module + + class test_SurfaceMaskFilter_InclusiveSurfaceTags_Function(EditorSharedTest): + from .EditorScripts import SurfaceMaskFilter_InclusionList as test_module + + class test_SurfaceMaskFilterOverrides_MultipleDescriptorOverridesPlantAsExpected(EditorSharedTest): + from .EditorScripts import SurfaceMaskFilterOverrides_MultipleDescriptorOverridesPlantAsExpected as test_module + + class test_SystemSettings_SectorPointDensity(EditorSharedTest): + from .EditorScripts import SystemSettings_SectorPointDensity as test_module + + class test_SystemSettings_SectorSize(EditorSharedTest): + from .EditorScripts import SystemSettings_SectorSize as test_module + + class test_VegetationInstances_DespawnWhenOutOfRange(EditorSharedTest): + from .EditorScripts import VegetationInstances_DespawnWhenOutOfRange as test_module diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/TestSuite_Main_Optimized.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/TestSuite_Main_Optimized.py deleted file mode 100644 index 5b1e504442..0000000000 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/TestSuite_Main_Optimized.py +++ /dev/null @@ -1,192 +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 pytest - -import ly_test_tools.environment.file_system as file_system -from ly_test_tools.o3de.editor_test import EditorSingleTest, EditorSharedTest, EditorParallelTest, EditorTestSuite - - -@pytest.mark.SUITE_main -@pytest.mark.parametrize("launcher_platform", ['windows_editor']) -@pytest.mark.parametrize("project", ["AutomatedTesting"]) -class TestAutomation(EditorTestSuite): - class test_AltitudeFilter_ComponentAndOverrides_InstancesPlantAtSpecifiedAltitude(EditorParallelTest): - from .EditorScripts import AltitudeFilter_ComponentAndOverrides_InstancesPlantAtSpecifiedAltitude as test_module - - class test_AltitudeFilter_FilterStageToggle(EditorParallelTest): - from .EditorScripts import AltitudeFilter_FilterStageToggle as test_module - - class test_AltitudeFilter_ShapeSample_InstancesPlantAtSpecifiedAltitude(EditorParallelTest): - from .EditorScripts import AltitudeFilter_ShapeSample_InstancesPlantAtSpecifiedAltitude as test_module - - -@pytest.mark.SUITE_main -@pytest.mark.parametrize("launcher_platform", ['windows_editor']) -@pytest.mark.parametrize("project", ["AutomatedTesting"]) -class TestAutomation_PrefabNotEnabled(EditorTestSuite): - - enable_prefab_system = False - - # Helpers for test asset cleanup - def cleanup_test_level(self, workspace): - file_system.delete([os.path.join(workspace.paths.engine_root(), "AutomatedTesting", "Levels", "tmp_level")], - True, True) - - def cleanup_test_slices(self, workspace): - file_system.delete([os.path.join(workspace.paths.engine_root(), "AutomatedTesting", "slices", - "TestSlice_1.slice")], True, True) - file_system.delete([os.path.join(workspace.paths.engine_root(), "AutomatedTesting", "slices", - "TestSlice_2.slice")], True, True) - - class test_DynamicSliceInstanceSpawner_DynamicSliceSpawnerWorks(EditorParallelTest): - from .EditorScripts import DynamicSliceInstanceSpawner_DynamicSliceSpawnerWorks as test_module - - class test_EmptyInstanceSpawner_EmptySpawnerWorks(EditorParallelTest): - from .EditorScripts import EmptyInstanceSpawner_EmptySpawnerWorks as test_module - - class test_SpawnerSlices_SliceCreationAndVisibilityToggleWorks(EditorSingleTest): - # Custom teardown to remove slice asset created during test - def teardown(self, request, workspace, editor, editor_test_results, launcher_platform): - TestAutomation_PrefabNotEnabled.cleanup_test_slices(self, workspace) - from .EditorScripts import SpawnerSlices_SliceCreationAndVisibilityToggleWorks as test_module - - class test_AssetListCombiner_CombinedDescriptorsExpressInConfiguredArea(EditorParallelTest): - from .EditorScripts import AssetListCombiner_CombinedDescriptorsExpressInConfiguredArea as test_module - - class test_AssetWeightSelector_InstancesExpressBasedOnWeight(EditorParallelTest): - from .EditorScripts import AssetWeightSelector_InstancesExpressBasedOnWeight as test_module - - @pytest.mark.skip(reason="https://github.com/o3de/o3de/issues/4155") - class test_DistanceBetweenFilter_InstancesPlantAtSpecifiedRadius(EditorParallelTest): - from .EditorScripts import DistanceBetweenFilter_InstancesPlantAtSpecifiedRadius as test_module - - @pytest.mark.skip(reason="https://github.com/o3de/o3de/issues/4155") - class test_DistanceBetweenFilterOverrides_InstancesPlantAtSpecifiedRadius(EditorParallelTest): - from .EditorScripts import DistanceBetweenFilterOverrides_InstancesPlantAtSpecifiedRadius as test_module - - class test_SurfaceDataRefreshes_RemainsStable(EditorParallelTest): - from .EditorScripts import SurfaceDataRefreshes_RemainsStable as test_module - - class test_VegetationInstances_DespawnWhenOutOfRange(EditorParallelTest): - from .EditorScripts import VegetationInstances_DespawnWhenOutOfRange as test_module - - class test_InstanceSpawnerPriority_LayerAndSubPriority_HigherValuesPlantOverLower(EditorParallelTest): - from .EditorScripts import InstanceSpawnerPriority_LayerAndSubPriority as test_module - - class test_LayerBlocker_InstancesBlockedInConfiguredArea(EditorParallelTest): - from .EditorScripts import LayerBlocker_InstancesBlockedInConfiguredArea as test_module - - class test_LayerSpawner_InheritBehaviorFlag(EditorParallelTest): - from .EditorScripts import LayerSpawner_InheritBehaviorFlag as test_module - - class test_LayerSpawner_InstancesPlantInAllSupportedShapes(EditorParallelTest): - from .EditorScripts import LayerSpawner_InstancesPlantInAllSupportedShapes as test_module - - class test_LayerSpawner_FilterStageToggle(EditorParallelTest): - from .EditorScripts import LayerSpawner_FilterStageToggle as test_module - - @pytest.mark.xfail(reason="https://github.com/o3de/o3de/issues/2038") - class test_LayerSpawner_InstancesRefreshUsingCorrectViewportCamera(EditorParallelTest): - from .EditorScripts import LayerSpawner_InstancesRefreshUsingCorrectViewportCamera as test_module - - class test_MeshBlocker_InstancesBlockedByMesh(EditorParallelTest): - from .EditorScripts import MeshBlocker_InstancesBlockedByMesh as test_module - - class test_MeshBlocker_InstancesBlockedByMeshHeightTuning(EditorParallelTest): - from .EditorScripts import MeshBlocker_InstancesBlockedByMeshHeightTuning as test_module - - class test_MeshSurfaceTagEmitter_DependentOnMeshComponent(EditorParallelTest): - from .EditorScripts import MeshSurfaceTagEmitter_DependentOnMeshComponent as test_module - - class test_MeshSurfaceTagEmitter_SurfaceTagsAddRemoveSuccessfully(EditorParallelTest): - from .EditorScripts import MeshSurfaceTagEmitter_SurfaceTagsAddRemoveSuccessfully as test_module - - class test_PhysXColliderSurfaceTagEmitter_E2E_Editor(EditorParallelTest): - from .EditorScripts import PhysXColliderSurfaceTagEmitter_E2E_Editor as test_module - - class test_PositionModifier_ComponentAndOverrides_InstancesPlantAtSpecifiedOffsets(EditorParallelTest): - from .EditorScripts import PositionModifier_ComponentAndOverrides_InstancesPlantAtSpecifiedOffsets as test_module - - class test_PositionModifier_AutoSnapToSurfaceWorks(EditorParallelTest): - from .EditorScripts import PositionModifier_AutoSnapToSurfaceWorks as test_module - - class test_RotationModifier_InstancesRotateWithinRange(EditorParallelTest): - from .EditorScripts import RotationModifier_InstancesRotateWithinRange as test_module - - class test_RotationModifierOverrides_InstancesRotateWithinRange(EditorParallelTest): - from .EditorScripts import RotationModifierOverrides_InstancesRotateWithinRange as test_module - - class test_ScaleModifier_InstancesProperlyScale(EditorParallelTest): - from .EditorScripts import ScaleModifier_InstancesProperlyScale as test_module - - class test_ScaleModifierOverrides_InstancesProperlyScale(EditorParallelTest): - from .EditorScripts import ScaleModifierOverrides_InstancesProperlyScale as test_module - - class test_ShapeIntersectionFilter_InstancesPlantInAssignedShape(EditorParallelTest): - from .EditorScripts import ShapeIntersectionFilter_InstancesPlantInAssignedShape as test_module - - class test_ShapeIntersectionFilter_FilterStageToggle(EditorParallelTest): - from .EditorScripts import ShapeIntersectionFilter_FilterStageToggle as test_module - - class test_SlopeAlignmentModifier_InstanceSurfaceAlignment(EditorParallelTest): - from .EditorScripts import SlopeAlignmentModifier_InstanceSurfaceAlignment as test_module - - class test_SlopeAlignmentModifierOverrides_InstanceSurfaceAlignment(EditorParallelTest): - from .EditorScripts import SlopeAlignmentModifierOverrides_InstanceSurfaceAlignment as test_module - - class test_SurfaceMaskFilter_BasicSurfaceTagCreation(EditorParallelTest): - from .EditorScripts import SurfaceMaskFilter_BasicSurfaceTagCreation as test_module - - class test_SurfaceMaskFilter_ExclusiveSurfaceTags_Function(EditorParallelTest): - from .EditorScripts import SurfaceMaskFilter_ExclusionList as test_module - - class test_SurfaceMaskFilter_InclusiveSurfaceTags_Function(EditorParallelTest): - from .EditorScripts import SurfaceMaskFilter_InclusionList as test_module - - class test_SurfaceMaskFilterOverrides_MultipleDescriptorOverridesPlantAsExpected(EditorParallelTest): - from .EditorScripts import SurfaceMaskFilterOverrides_MultipleDescriptorOverridesPlantAsExpected as test_module - - class test_SystemSettings_SectorPointDensity(EditorParallelTest): - from .EditorScripts import SystemSettings_SectorPointDensity as test_module - - class test_SystemSettings_SectorSize(EditorParallelTest): - from .EditorScripts import SystemSettings_SectorSize as test_module - - class test_SlopeFilter_ComponentAndOverrides_InstancesPlantOnValidSlopes(EditorParallelTest): - from .EditorScripts import SlopeFilter_ComponentAndOverrides_InstancesPlantOnValidSlope as test_module - - class test_DynamicSliceInstanceSpawner_Embedded_E2E_Editor(EditorSingleTest): - from .EditorScripts import DynamicSliceInstanceSpawner_Embedded_E2E as test_module - - # Custom setup/teardown to remove test level created during test - def setup(self, request, workspace, editor, editor_test_results, launcher_platform): - TestAutomation_PrefabNotEnabled.cleanup_test_level(self, workspace) - - def teardown(self, request, workspace, editor, editor_test_results, launcher_platform): - TestAutomation_PrefabNotEnabled.cleanup_test_level(self, workspace) - - class test_DynamicSliceInstanceSpawner_External_E2E_Editor(EditorSingleTest): - from .EditorScripts import DynamicSliceInstanceSpawner_External_E2E as test_module - - # Custom setup/teardown to remove test level created during test - def setup(self, request, workspace, editor, editor_test_results, launcher_platform): - TestAutomation_PrefabNotEnabled.cleanup_test_level(self, workspace) - - def teardown(self, request, workspace, editor, editor_test_results, launcher_platform): - TestAutomation_PrefabNotEnabled.cleanup_test_level(self, workspace) - - class test_LayerBlender_E2E_Editor(EditorSingleTest): - from .EditorScripts import LayerBlender_E2E_Editor as test_module - - # Custom setup/teardown to remove test level created during test - def setup(self, request, workspace, editor, editor_test_results, launcher_platform): - TestAutomation_PrefabNotEnabled.cleanup_test_level(self, workspace) - - def teardown(self, request, workspace, editor, editor_test_results, launcher_platform): - TestAutomation_PrefabNotEnabled.cleanup_test_level(self, workspace) diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/TestSuite_Periodic.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/TestSuite_Periodic.py index 64f6cfdf30..bf7e76f973 100644 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/TestSuite_Periodic.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/TestSuite_Periodic.py @@ -7,277 +7,17 @@ SPDX-License-Identifier: Apache-2.0 OR MIT import os import pytest -import sys -import ly_test_tools.environment.waiter as waiter import ly_test_tools.environment.file_system as file_system -import editor_python_test_tools.hydra_test_utils as hydra -from ly_remote_console.remote_console_commands import RemoteConsole as RemoteConsole - -sys.path.append(os.path.dirname(os.path.abspath(__file__)) + '/../../automatedtesting_shared') -from base import TestAutomationBase - - -@pytest.fixture -def remove_test_slice(request, workspace, project): - file_system.delete([os.path.join(workspace.paths.engine_root(), project, "slices", "TestSlice_1.slice")], True, - True) - file_system.delete([os.path.join(workspace.paths.engine_root(), project, "slices", "TestSlice_2.slice")], True, - True) - - def teardown(): - file_system.delete([os.path.join(workspace.paths.engine_root(), project, "slices", "TestSlice_1.slice")], True, - True) - file_system.delete([os.path.join(workspace.paths.engine_root(), project, "slices", "TestSlice_2.slice")], True, - True) - request.addfinalizer(teardown) - - -@pytest.fixture -def remote_console_instance(request): - console = RemoteConsole() - - def teardown(): - if console.connected: - console.stop() - - request.addfinalizer(teardown) - return console +from ly_test_tools.o3de.editor_test import EditorSingleTest, EditorSharedTest, EditorParallelTest, EditorTestSuite @pytest.mark.SUITE_periodic @pytest.mark.parametrize("launcher_platform", ['windows_editor']) @pytest.mark.parametrize("project", ["AutomatedTesting"]) -class TestAutomation(TestAutomationBase): +class TestAutomation(EditorTestSuite): - def test_AltitudeFilter_ComponentAndOverrides_InstancesPlantAtSpecifiedAltitude(self, request, workspace, editor, launcher_platform): - from .EditorScripts import AltitudeFilter_ComponentAndOverrides_InstancesPlantAtSpecifiedAltitude as test_module - self._run_test(request, workspace, editor, test_module) + global_extra_cmdline_args = ["-BatchMode", "-autotest_mode"] - def test_AltitudeFilter_ShapeSample_InstancesPlantAtSpecifiedAltitude(self, request, workspace, editor, launcher_platform): - from .EditorScripts import AltitudeFilter_ShapeSample_InstancesPlantAtSpecifiedAltitude as test_module - self._run_test(request, workspace, editor, test_module) - - def test_AltitudeFilter_FilterStageToggle(self, request, workspace, editor, launcher_platform): - from .EditorScripts import AltitudeFilter_FilterStageToggle as test_module - self._run_test(request, workspace, editor, test_module) - - def test_SpawnerSlices_SliceCreationAndVisibilityToggleWorks(self, request, workspace, editor, remove_test_slice, launcher_platform): - from .EditorScripts import SpawnerSlices_SliceCreationAndVisibilityToggleWorks as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_AssetListCombiner_CombinedDescriptorsExpressInConfiguredArea(self, request, workspace, editor, launcher_platform): - from .EditorScripts import AssetListCombiner_CombinedDescriptorsExpressInConfiguredArea as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_AssetWeightSelector_InstancesExpressBasedOnWeight(self, request, workspace, editor, launcher_platform): - from .EditorScripts import AssetWeightSelector_InstancesExpressBasedOnWeight as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - @pytest.mark.xfail(reason="https://github.com/o3de/o3de/issues/4155") - def test_DistanceBetweenFilter_InstancesPlantAtSpecifiedRadius(self, request, workspace, editor, launcher_platform): - from .EditorScripts import DistanceBetweenFilter_InstancesPlantAtSpecifiedRadius as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - @pytest.mark.xfail(reason="https://github.com/o3de/o3de/issues/4155") - def test_DistanceBetweenFilterOverrides_InstancesPlantAtSpecifiedRadius(self, request, workspace, editor, launcher_platform): - from .EditorScripts import DistanceBetweenFilterOverrides_InstancesPlantAtSpecifiedRadius as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_SurfaceDataRefreshes_RemainsStable(self, request, workspace, editor, launcher_platform): - from .EditorScripts import SurfaceDataRefreshes_RemainsStable as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_VegetationInstances_DespawnWhenOutOfRange(self, request, workspace, editor, launcher_platform): - from .EditorScripts import VegetationInstances_DespawnWhenOutOfRange as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_InstanceSpawnerPriority_LayerAndSubPriority_HigherValuesPlantOverLower(self, request, workspace, editor, launcher_platform): - from .EditorScripts import InstanceSpawnerPriority_LayerAndSubPriority as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_LayerBlocker_InstancesBlockedInConfiguredArea(self, request, workspace, editor, launcher_platform): - from .EditorScripts import LayerBlocker_InstancesBlockedInConfiguredArea as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_LayerSpawner_InheritBehaviorFlag(self, request, workspace, editor, launcher_platform): - from .EditorScripts import LayerSpawner_InheritBehaviorFlag as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_LayerSpawner_InstancesPlantInAllSupportedShapes(self, request, workspace, editor, launcher_platform): - from .EditorScripts import LayerSpawner_InstancesPlantInAllSupportedShapes as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_LayerSpawner_FilterStageToggle(self, request, workspace, editor, launcher_platform): - from .EditorScripts import LayerSpawner_FilterStageToggle as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - @pytest.mark.xfail(reason="https://github.com/o3de/o3de/issues/2038") - def test_LayerSpawner_InstancesRefreshUsingCorrectViewportCamera(self, request, workspace, editor, launcher_platform): - from .EditorScripts import LayerSpawner_InstancesRefreshUsingCorrectViewportCamera as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_MeshBlocker_InstancesBlockedByMesh(self, request, workspace, editor, launcher_platform): - from .EditorScripts import MeshBlocker_InstancesBlockedByMesh as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_MeshBlocker_InstancesBlockedByMeshHeightTuning(self, request, workspace, editor, launcher_platform): - from .EditorScripts import MeshBlocker_InstancesBlockedByMeshHeightTuning as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_MeshSurfaceTagEmitter_DependentOnMeshComponent(self, request, workspace, editor, launcher_platform): - from .EditorScripts import MeshSurfaceTagEmitter_DependentOnMeshComponent as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_MeshSurfaceTagEmitter_SurfaceTagsAddRemoveSuccessfully(self, request, workspace, editor, launcher_platform): - from .EditorScripts import MeshSurfaceTagEmitter_SurfaceTagsAddRemoveSuccessfully as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_PhysXColliderSurfaceTagEmitter_E2E_Editor(self, request, workspace, editor, launcher_platform): - from .EditorScripts import PhysXColliderSurfaceTagEmitter_E2E_Editor as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_PositionModifier_ComponentAndOverrides_InstancesPlantAtSpecifiedOffsets(self, request, workspace, editor, launcher_platform): - from .EditorScripts import PositionModifier_ComponentAndOverrides_InstancesPlantAtSpecifiedOffsets as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_PositionModifier_AutoSnapToSurfaceWorks(self, request, workspace, editor, launcher_platform): - from .EditorScripts import PositionModifier_AutoSnapToSurfaceWorks as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_RotationModifier_InstancesRotateWithinRange(self, request, workspace, editor, launcher_platform): - from .EditorScripts import RotationModifier_InstancesRotateWithinRange as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_RotationModifierOverrides_InstancesRotateWithinRange(self, request, workspace, editor, launcher_platform): - from .EditorScripts import RotationModifierOverrides_InstancesRotateWithinRange as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_ScaleModifier_InstancesProperlyScale(self, request, workspace, editor, launcher_platform): - from .EditorScripts import ScaleModifier_InstancesProperlyScale as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_ScaleModifierOverrides_InstancesProperlyScale(self, request, workspace, editor, launcher_platform): - from .EditorScripts import ScaleModifierOverrides_InstancesProperlyScale as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_ShapeIntersectionFilter_InstancesPlantInAssignedShape(self, request, workspace, editor, launcher_platform): - from .EditorScripts import ShapeIntersectionFilter_InstancesPlantInAssignedShape as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_ShapeIntersectionFilter_FilterStageToggle(self, request, workspace, editor, launcher_platform): - from .EditorScripts import ShapeIntersectionFilter_FilterStageToggle as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_SlopeAlignmentModifier_InstanceSurfaceAlignment(self, request, workspace, editor, launcher_platform): - from .EditorScripts import SlopeAlignmentModifier_InstanceSurfaceAlignment as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_SlopeAlignmentModifierOverrides_InstanceSurfaceAlignment(self, request, workspace, editor, launcher_platform): - from .EditorScripts import SlopeAlignmentModifierOverrides_InstanceSurfaceAlignment as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_SurfaceMaskFilter_BasicSurfaceTagCreation(self, request, workspace, editor, launcher_platform): - from .EditorScripts import SurfaceMaskFilter_BasicSurfaceTagCreation as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_SurfaceMaskFilter_ExclusiveSurfaceTags_Function(self, request, workspace, editor, launcher_platform): - from .EditorScripts import SurfaceMaskFilter_ExclusionList as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_SurfaceMaskFilter_InclusiveSurfaceTags_Function(self, request, workspace, editor, launcher_platform): - from .EditorScripts import SurfaceMaskFilter_InclusionList as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_SurfaceMaskFilterOverrides_MultipleDescriptorOverridesPlantAsExpected(self, request, workspace, editor, launcher_platform): - from .EditorScripts import SurfaceMaskFilterOverrides_MultipleDescriptorOverridesPlantAsExpected as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_SystemSettings_SectorPointDensity(self, request, workspace, editor, launcher_platform): - from .EditorScripts import SystemSettings_SectorPointDensity as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_SystemSettings_SectorSize(self, request, workspace, editor, launcher_platform): - from .EditorScripts import SystemSettings_SectorSize as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_SlopeFilter_ComponentAndOverrides_InstancesPlantOnValidSlopes(self, request, workspace, editor, launcher_platform): - from .EditorScripts import SlopeFilter_ComponentAndOverrides_InstancesPlantOnValidSlope as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - -@pytest.mark.SUITE_periodic -@pytest.mark.parametrize("project", ["AutomatedTesting"]) -@pytest.mark.parametrize("level", ["tmp_level"]) -class TestAutomationE2E(TestAutomationBase): - - # The following tests must run in order, please do not move tests out of order - - @pytest.mark.parametrize("launcher_platform", ['windows_editor']) - def test_DynamicSliceInstanceSpawner_Embedded_E2E_Editor(self, request, workspace, project, level, editor, launcher_platform): - # Ensure our test level does not already exist - file_system.delete([os.path.join(workspace.paths.engine_root(), project, "Levels", level)], True, True) - - from .EditorScripts import DynamicSliceInstanceSpawner_Embedded_E2E as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - @pytest.mark.parametrize("launcher_platform", ['windows']) - def test_DynamicSliceInstanceSpawner_Embedded_E2E_Launcher(self, workspace, launcher, level, - remote_console_instance, project, launcher_platform): - - expected_lines = [ - "Instances found in area = 400" - ] - - hydra.launch_and_validate_results_launcher(launcher, level, remote_console_instance, expected_lines, launch_ap=False) - - # Cleanup our temp level - file_system.delete([os.path.join(workspace.paths.engine_root(), project, "Levels", level)], True, True) - - @pytest.mark.parametrize("launcher_platform", ['windows_editor']) - def test_DynamicSliceInstanceSpawner_External_E2E_Editor(self, request, workspace, project, level, editor, launcher_platform): - # Ensure our test level does not already exist - file_system.delete([os.path.join(workspace.paths.engine_root(), project, "Levels", level)], True, True) - - from .EditorScripts import DynamicSliceInstanceSpawner_External_E2E as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - @pytest.mark.parametrize("launcher_platform", ['windows']) - def test_DynamicSliceInstanceSpawner_External_E2E_Launcher(self, workspace, launcher, level, - remote_console_instance, project, launcher_platform): - - expected_lines = [ - "Instances found in area = 400" - ] - - hydra.launch_and_validate_results_launcher(launcher, level, remote_console_instance, expected_lines, launch_ap=False) - - # Cleanup our temp level - file_system.delete([os.path.join(workspace.paths.engine_root(), project, "Levels", level)], True, True) - - @pytest.mark.parametrize("launcher_platform", ['windows_editor']) - def test_LayerBlender_E2E_Editor(self, request, workspace, project, level, editor, launcher_platform): - # Ensure our test level does not already exist - file_system.delete([os.path.join(workspace.paths.engine_root(), project, "Levels", level)], True, True) - - from .EditorScripts import LayerBlender_E2E_Editor as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - @pytest.mark.parametrize("launcher_platform", ['windows']) - @pytest.mark.xfail(reason="https://github.com/o3de/o3de/issues/4170") - def test_LayerBlender_E2E_Launcher(self, workspace, launcher, level, - remote_console_instance, project, launcher_platform): - - launcher.args.extend(["-rhi=Null"]) - launcher.start(launch_ap=False) - assert launcher.is_alive(), "Launcher failed to start" - - # Wait for test script to quit the launcher. If wait_for returns exc, test was not successful - waiter.wait_for(lambda: not launcher.is_alive(), timeout=300) - - # Verify launcher quit successfully and did not crash - ret_code = launcher.get_returncode() - assert ret_code == 0, "Test failed. See Game.log for details" - - # Cleanup our temp level - file_system.delete([os.path.join(workspace.paths.engine_root(), project, "Levels", level)], True, True) + class test_DynVegUtils_TempPrefabCreationWorks(EditorSharedTest): + from .EditorScripts import DynVegUtils_TempPrefabCreationWorks as test_module diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/TestSuite_Periodic_Optimized.py b/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/TestSuite_Periodic_Optimized.py deleted file mode 100644 index f87d6567ef..0000000000 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/dyn_veg/TestSuite_Periodic_Optimized.py +++ /dev/null @@ -1,23 +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 pytest - -import ly_test_tools.environment.file_system as file_system -from ly_test_tools.o3de.editor_test import EditorSingleTest, EditorSharedTest, EditorParallelTest, EditorTestSuite - - -@pytest.mark.SUITE_main -@pytest.mark.parametrize("launcher_platform", ['windows_editor']) -@pytest.mark.parametrize("project", ["AutomatedTesting"]) -class TestAutomation(EditorTestSuite): - - global_extra_cmdline_args = ["-BatchMode", "-autotest_mode"] - - class test_DynVegUtils_TempPrefabCreationWorks(EditorSharedTest): - from .EditorScripts import DynVegUtils_TempPrefabCreationWorks as test_module diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientGenerators_Incompatibilities.py b/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientGenerators_Incompatibilities.py index 09cd760647..6979ff1dee 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientGenerators_Incompatibilities.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientGenerators_Incompatibilities.py @@ -65,8 +65,7 @@ def GradientGenerators_Incompatibilities(): } # Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # For every gradient generator component, verify that they are incompatible # which each vegetation area component diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientModifiers_Incompatibilities.py b/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientModifiers_Incompatibilities.py index a4d9181744..962a0004f9 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientModifiers_Incompatibilities.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientModifiers_Incompatibilities.py @@ -74,8 +74,7 @@ def GradientModifiers_Incompatibilities(): } # Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # For every gradient modifier component, verify that they are incompatible # which each vegetation area and gradient generator/modifier component diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientPreviewSettings_ClearingPinnedEntitySetsPreviewToOrigin.py b/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientPreviewSettings_ClearingPinnedEntitySetsPreviewToOrigin.py index 3749f93bf5..87f9e1a9b1 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientPreviewSettings_ClearingPinnedEntitySetsPreviewToOrigin.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientPreviewSettings_ClearingPinnedEntitySetsPreviewToOrigin.py @@ -86,8 +86,7 @@ def GradientPreviewSettings_ClearingPinnedEntitySetsPreviewToOrigin(): return entity # 1) Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # 2) Create entity with Random Noise gradient and verify gradient position after clearing pinned entity clear_entityid_check_position( diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientPreviewSettings_DefaultPinnedEntityIsSelf.py b/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientPreviewSettings_DefaultPinnedEntityIsSelf.py index 3756452710..cd3fd7e1ee 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientPreviewSettings_DefaultPinnedEntityIsSelf.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientPreviewSettings_DefaultPinnedEntityIsSelf.py @@ -90,8 +90,7 @@ def GradientPreviewSettings_DefaultPinnedEntityIsSelf(): ] # 1) Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() for param in param_list: execute_test(param.required_components[param.accessed_component], diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientSampling_GradientReferencesAddRemoveSuccessfully.py b/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientSampling_GradientReferencesAddRemoveSuccessfully.py index 8e85345a6f..f2980d9634 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientSampling_GradientReferencesAddRemoveSuccessfully.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientSampling_GradientReferencesAddRemoveSuccessfully.py @@ -61,8 +61,7 @@ def GradientSampling_GradientReferencesAddRemoveSuccessfully(): Report.result(gradient_cleared_from_modifier, entity.Equal(EntityId.EntityId())) # 1) Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # 2) Create a new entity with components "Random Noise Gradient", "Gradient Transform Modifier" and "Box Shape" entity_position = math.Vector3(125.0, 136.0, 32.0) diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientSurfaceTagEmitter_ComponentDependencies.py b/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientSurfaceTagEmitter_ComponentDependencies.py index f653515a39..0cc325efd1 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientSurfaceTagEmitter_ComponentDependencies.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientSurfaceTagEmitter_ComponentDependencies.py @@ -42,8 +42,7 @@ def GradientSurfaceTagEmitter_ComponentDependencies(): return editor.EditorComponentAPIBus(bus.Broadcast, "IsComponentEnabled", EntityComponentIdPair) # Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # Create an entity with Gradient Surface Tag Emitter component position = math.Vector3(512.0, 512.0, 32.0) diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientSurfaceTagEmitter_SurfaceTagsAddRemoveSuccessfully.py b/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientSurfaceTagEmitter_SurfaceTagsAddRemoveSuccessfully.py index 90840a135d..cf48096a31 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientSurfaceTagEmitter_SurfaceTagsAddRemoveSuccessfully.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientSurfaceTagEmitter_SurfaceTagsAddRemoveSuccessfully.py @@ -36,8 +36,7 @@ def GradientSurfaceTagEmitter_SurfaceTagsAddRemoveSuccessfully(): from editor_python_test_tools.utils import TestHelper as helper # 1) Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # 2) Create an entity with Gradient Surface Tag Emitter and Reference Gradient components. entity_position = math.Vector3(125.0, 136.0, 32.0) diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientTransform_ComponentIncompatibleWithExpectedGradients.py b/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientTransform_ComponentIncompatibleWithExpectedGradients.py index 5e6df4d52f..27ef248d6c 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientTransform_ComponentIncompatibleWithExpectedGradients.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientTransform_ComponentIncompatibleWithExpectedGradients.py @@ -46,8 +46,7 @@ def GradientTransform_ComponentIncompatibleWithExpectedGradients(): return editor.EditorComponentAPIBus(bus.Broadcast, "IsComponentEnabled", EntityComponentIdPair) # 1) Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # 2) Create a new entity with components Gradient Transform Modifier and Box Shape entity_position = math.Vector3(125.0, 136.0, 32.0) diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientTransform_ComponentIncompatibleWithSpawners.py b/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientTransform_ComponentIncompatibleWithSpawners.py index fd65996fdd..9c23cdea75 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientTransform_ComponentIncompatibleWithSpawners.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientTransform_ComponentIncompatibleWithSpawners.py @@ -44,8 +44,7 @@ def GradientTransform_ComponentIncompatibleWithSpawners(): return editor.EditorComponentAPIBus(bus.Broadcast, "IsComponentEnabled", EntityComponentIdPair) # 1) Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # 2) Create a new entity with components Gradient Transform Modifier and Box Shape entity_position = math.Vector3(125.0, 136.0, 32.0) diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientTransform_FrequencyZoomCanBeSetBeyondSliderRange.py b/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientTransform_FrequencyZoomCanBeSetBeyondSliderRange.py index 530503db86..6d6911ff3a 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientTransform_FrequencyZoomCanBeSetBeyondSliderRange.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientTransform_FrequencyZoomCanBeSetBeyondSliderRange.py @@ -54,8 +54,7 @@ def GradientTransform_FrequencyZoomCanBeSetBeyondSliderRange(): from editor_python_test_tools.utils import TestHelper as helper # 1) Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # 2) Create entity entity_position = math.Vector3(125.0, 136.0, 32.0) diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientTransform_RequiresShape.py b/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientTransform_RequiresShape.py index 09cce359d5..ec142f92d2 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientTransform_RequiresShape.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/GradientTransform_RequiresShape.py @@ -47,8 +47,7 @@ def GradientTransform_RequiresShape(): from editor_python_test_tools.utils import TestHelper as helper # Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # Create a new Entity in the level entity_id = editor.ToolsApplicationRequestBus(bus.Broadcast, 'CreateNewEntity', entity.EntityId()) diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/ImageGradient_ProcessedImageAssignedSuccessfully.py b/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/ImageGradient_ProcessedImageAssignedSuccessfully.py index 42458665e1..afe0893da9 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/ImageGradient_ProcessedImageAssignedSuccessfully.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/ImageGradient_ProcessedImageAssignedSuccessfully.py @@ -56,8 +56,7 @@ def ImageGradient_ProcessedImageAssignedSuccessfully(): from editor_python_test_tools.utils import TestHelper as helper # 1) Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # 2) Create an entity with Image Gradient and Gradient Transform Modifier components components_to_add = ["Image Gradient", "Gradient Transform Modifier", "Box Shape"] diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/ImageGradient_RequiresShape.py b/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/ImageGradient_RequiresShape.py index 3b832d160a..85582d198a 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/ImageGradient_RequiresShape.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/EditorScripts/ImageGradient_RequiresShape.py @@ -47,8 +47,7 @@ def ImageGradient_RequiresShape(): from editor_python_test_tools.utils import TestHelper as helper # Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # Create a new Entity in the level entity_id = editor.ToolsApplicationRequestBus(bus.Broadcast, 'CreateNewEntity', entity.EntityId()) diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/TestSuite_Periodic.py b/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/TestSuite_Periodic.py index 3ad27eb973..d4199c31f6 100644 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/TestSuite_Periodic.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/TestSuite_Periodic.py @@ -5,67 +5,51 @@ For complete copyright and license terms please see the LICENSE at the root of t SPDX-License-Identifier: Apache-2.0 OR MIT """ -import os import pytest -import sys -sys.path.append(os.path.dirname(os.path.abspath(__file__)) + '/../../automatedtesting_shared') -from base import TestAutomationBase +from ly_test_tools.o3de.editor_test import EditorSingleTest, EditorSharedTest, EditorParallelTest, EditorTestSuite @pytest.mark.SUITE_periodic @pytest.mark.parametrize("launcher_platform", ['windows_editor']) @pytest.mark.parametrize("project", ["AutomatedTesting"]) -class TestAutomation(TestAutomationBase): +class TestAutomation(EditorTestSuite): - def test_GradientGenerators_Incompatibilities(self, request, workspace, editor, launcher_platform): + class test_GradientGenerators_Incompatibilities(EditorSharedTest): from .EditorScripts import GradientGenerators_Incompatibilities as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - def test_GradientModifiers_Incompatibilities(self, request, workspace, editor, launcher_platform): + class test_GradientModifiers_Incompatibilities(EditorSharedTest): from .EditorScripts import GradientModifiers_Incompatibilities as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - def test_GradientPreviewSettings_DefaultPinnedEntityIsSelf(self, request, workspace, editor, launcher_platform): - from .EditorScripts import GradientPreviewSettings_DefaultPinnedEntityIsSelf as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_GradientPreviewSettings_ClearingPinnedEntitySetsPreviewToOrigin(self, request, workspace, editor, launcher_platform): + class test_GradientPreviewSettings_ClearingPinnedEntitySetsPreviewToOrigin(EditorSharedTest): from .EditorScripts import GradientPreviewSettings_ClearingPinnedEntitySetsPreviewToOrigin as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - def test_GradientSampling_GradientReferencesAddRemoveSuccessfully(self, request, workspace, editor, launcher_platform): + class test_GradientPreviewSettings_DefaultPinnedEntityIsSelf(EditorSharedTest): + from .EditorScripts import GradientPreviewSettings_DefaultPinnedEntityIsSelf as test_module + + class test_GradientSampling_GradientReferencesAddRemoveSuccessfully(EditorSharedTest): from .EditorScripts import GradientSampling_GradientReferencesAddRemoveSuccessfully as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - def test_GradientSurfaceTagEmitter_ComponentDependencies(self, request, workspace, editor, launcher_platform): + class test_GradientSurfaceTagEmitter_ComponentDependencies(EditorSharedTest): from .EditorScripts import GradientSurfaceTagEmitter_ComponentDependencies as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - def test_GradientSurfaceTagEmitter_SurfaceTagsAddRemoveSuccessfully(self, request, workspace, editor, launcher_platform): + class test_GradientSurfaceTagEmitter_SurfaceTagsAddRemoveSuccessfully(EditorSharedTest): from .EditorScripts import GradientSurfaceTagEmitter_SurfaceTagsAddRemoveSuccessfully as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - def test_GradientTransform_RequiresShape(self, request, workspace, editor, launcher_platform): - from .EditorScripts import GradientTransform_RequiresShape as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_GradientTransform_FrequencyZoomCanBeSetBeyondSliderRange(self, request, workspace, editor, launcher_platform): - from .EditorScripts import GradientTransform_FrequencyZoomCanBeSetBeyondSliderRange as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_GradientTransform_ComponentIncompatibleWithSpawners(self, request, workspace, editor, launcher_platform): - from .EditorScripts import GradientTransform_ComponentIncompatibleWithSpawners as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_GradientTransform_ComponentIncompatibleWithExpectedGradients(self, request, workspace, editor, launcher_platform): + class test_GradientTransform_ComponentIncompatibleWithExpectedGradients(EditorSharedTest): from .EditorScripts import GradientTransform_ComponentIncompatibleWithExpectedGradients as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - def test_ImageGradient_RequiresShape(self, request, workspace, editor, launcher_platform): - from .EditorScripts import ImageGradient_RequiresShape as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) + class test_GradientTransform_ComponentIncompatibleWithSpawners(EditorSharedTest): + from .EditorScripts import GradientTransform_ComponentIncompatibleWithSpawners as test_module - def test_ImageGradient_ProcessedImageAssignedSuccessfully(self, request, workspace, editor, launcher_platform): + class test_GradientTransform_FrequencyZoomCanBeSetBeyondSliderRange(EditorSharedTest): + from .EditorScripts import GradientTransform_FrequencyZoomCanBeSetBeyondSliderRange as test_module + + class test_GradientTransform_RequiresShape(EditorSharedTest): + from .EditorScripts import GradientTransform_RequiresShape as test_module + + class test_ImageGradient_ProcessedImageAssignedSuccessfully(EditorSharedTest): from .EditorScripts import ImageGradient_ProcessedImageAssignedSuccessfully as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) + + class test_ImageGradient_RequiresShape(EditorSharedTest): + from .EditorScripts import ImageGradient_RequiresShape as test_module diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/TestSuite_Periodic_Optimized.py b/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/TestSuite_Periodic_Optimized.py deleted file mode 100644 index 6ac0658b4d..0000000000 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/gradient_signal/TestSuite_Periodic_Optimized.py +++ /dev/null @@ -1,57 +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 pytest - -from ly_test_tools.o3de.editor_test import EditorSingleTest, EditorSharedTest, EditorParallelTest, EditorTestSuite - - -@pytest.mark.SUITE_periodic -@pytest.mark.parametrize("launcher_platform", ['windows_editor']) -@pytest.mark.parametrize("project", ["AutomatedTesting"]) -class TestAutomation(EditorTestSuite): - - enable_prefab_system = False - - class test_GradientGenerators_Incompatibilities(EditorSharedTest): - from .EditorScripts import GradientGenerators_Incompatibilities as test_module - - class test_GradientModifiers_Incompatibilities(EditorSharedTest): - from .EditorScripts import GradientModifiers_Incompatibilities as test_module - - class test_GradientPreviewSettings_DefaultPinnedEntityIsSelf(EditorSharedTest): - from .EditorScripts import GradientPreviewSettings_DefaultPinnedEntityIsSelf as test_module - - class test_GradientPreviewSettings_ClearingPinnedEntitySetsPreviewToOrigin(EditorSharedTest): - from .EditorScripts import GradientPreviewSettings_ClearingPinnedEntitySetsPreviewToOrigin as test_module - - class test_GradientSampling_GradientReferencesAddRemoveSuccessfully(EditorSharedTest): - from .EditorScripts import GradientSampling_GradientReferencesAddRemoveSuccessfully as test_module - - class test_GradientSurfaceTagEmitter_ComponentDependencies(EditorSharedTest): - from .EditorScripts import GradientSurfaceTagEmitter_ComponentDependencies as test_module - - class test_GradientSurfaceTagEmitter_SurfaceTagsAddRemoveSuccessfully(EditorSharedTest): - from .EditorScripts import GradientSurfaceTagEmitter_SurfaceTagsAddRemoveSuccessfully as test_module - - class test_GradientTransform_RequiresShape(EditorSharedTest): - from .EditorScripts import GradientTransform_RequiresShape as test_module - - class test_GradientTransform_FrequencyZoomCanBeSetBeyondSliderRange(EditorSharedTest): - from .EditorScripts import GradientTransform_FrequencyZoomCanBeSetBeyondSliderRange as test_module - - class test_GradientTransform_ComponentIncompatibleWithSpawners(EditorSharedTest): - from .EditorScripts import GradientTransform_ComponentIncompatibleWithSpawners as test_module - - class test_GradientTransform_ComponentIncompatibleWithExpectedGradients(EditorSharedTest): - from .EditorScripts import GradientTransform_ComponentIncompatibleWithExpectedGradients as test_module - - class test_ImageGradient_RequiresShape(EditorSharedTest): - from .EditorScripts import ImageGradient_RequiresShape as test_module - - class test_ImageGradient_ProcessedImageAssignedSuccessfully(EditorSharedTest): - from .EditorScripts import ImageGradient_ProcessedImageAssignedSuccessfully as test_module diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/AreaNodes_DependentComponentsAdded.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/AreaNodes_DependentComponentsAdded.py index c69ce77041..09dc6d7d0b 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/AreaNodes_DependentComponentsAdded.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/AreaNodes_DependentComponentsAdded.py @@ -68,8 +68,7 @@ def AreaNodes_DependentComponentsAdded(): newEntityId = parameters[0] # Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # Open Landscape Canvas tool and verify general.open_pane('Landscape Canvas') diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/AreaNodes_EntityCreatedOnNodeAdd.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/AreaNodes_EntityCreatedOnNodeAdd.py index f3f4a1862d..95294de2d2 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/AreaNodes_EntityCreatedOnNodeAdd.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/AreaNodes_EntityCreatedOnNodeAdd.py @@ -58,7 +58,6 @@ def AreaNodes_EntityCreatedOnNodeAdd(): import editor_python_test_tools.hydra_editor_utils as hydra from editor_python_test_tools.utils import Report - from editor_python_test_tools.utils import TestHelper as helper editorId = azlmbr.globals.property.LANDSCAPE_CANVAS_EDITOR_ID @@ -67,8 +66,7 @@ def AreaNodes_EntityCreatedOnNodeAdd(): newEntityId = parameters[0] # Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # Open Landscape Canvas tool and verify general.open_pane('Landscape Canvas') diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/AreaNodes_EntityRemovedOnNodeDelete.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/AreaNodes_EntityRemovedOnNodeDelete.py index f8b0539759..4e5e75b3e1 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/AreaNodes_EntityRemovedOnNodeDelete.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/AreaNodes_EntityRemovedOnNodeDelete.py @@ -59,8 +59,8 @@ def AreaNodes_EntityRemovedOnNodeDelete(): import azlmbr.math as math import azlmbr.paths + import editor_python_test_tools.hydra_editor_utils as hydra from editor_python_test_tools.utils import Report - from editor_python_test_tools.utils import TestHelper as helper editorId = azlmbr.globals.property.LANDSCAPE_CANVAS_EDITOR_ID @@ -73,8 +73,7 @@ def AreaNodes_EntityRemovedOnNodeDelete(): deletedEntityId = parameters[0] # Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # Open Landscape Canvas tool and verify general.open_pane('Landscape Canvas') diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/ComponentUpdates_UpdateGraph.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/ComponentUpdates_UpdateGraph.py index cc40d8b861..1635365a08 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/ComponentUpdates_UpdateGraph.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/ComponentUpdates_UpdateGraph.py @@ -1,15 +1,14 @@ """ 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 """ class Tests: - slice_instantiated = ( - "Slice instantiated successfully", - "Failed to instantiate slice" + prefab_instantiated = ( + "Prefab instantiated successfully", + "Failed to instantiate prefab" ) lc_entity_found = ( "LandscapeCanvas entity found", @@ -24,7 +23,7 @@ class Tests: "Failed to find Distribution Filter component on BushSpawner entity" ) existing_graph_opened = ( - "Opened existing graph from slice", + "Opened existing graph from prefab", "Failed to open existing graph" ) dist_filter_node_found = ( @@ -66,10 +65,8 @@ def ComponentUpdates_UpdateGraph(): Summary: This test verifies that the Landscape Canvas graphs update properly when components are added/removed outside of Landscape Canvas. - Expected Behavior: Graphs properly reflect component changes made to entities outside of Landscape Canvas. - Test Steps: 1. Open Level 2. Find LandscapeCanvas named entity @@ -83,41 +80,36 @@ def ComponentUpdates_UpdateGraph(): 9. Add a new entity with unique name as a child of the Landscape Canvas entity 10. Add a Box Shape component to the new child entity 11. Ensure Box Shape node is present on the open graph - Note: - This test file must be called from the Open 3D Engine Editor command terminal - Any passed and failed tests are written to the Editor.log file. Parsing the file or running a log_monitor are required to observe the test results. - :return: None """ import os - import azlmbr.asset as asset import azlmbr.bus as bus import azlmbr.editor as editor import azlmbr.entity as entity import azlmbr.legacy.general as general import azlmbr.landscapecanvas as landscapecanvas import azlmbr.math as math - import azlmbr.slice as slice + import azlmbr.prefab as prefab import editor_python_test_tools.hydra_editor_utils as hydra from editor_python_test_tools.utils import Report from editor_python_test_tools.utils import TestHelper as helper - # Open a simple level and instantiate LC_BushFlowerBlender.slice - helper.init_idle() - helper.open_level("Physics", "Base") + # Open a simple level and instantiate BushFlowerBlender.prefab + hydra.open_base_level() transform = math.Transform_CreateIdentity() position = math.Vector3(64.0, 64.0, 32.0) transform.invoke('SetPosition', position) - test_slice_path = os.path.join("Slices", "LC_BushFlowerBlender.slice") - test_slice_id = asset.AssetCatalogRequestBus(bus.Broadcast, "GetAssetIdByPath", test_slice_path, math.Uuid(), - False) - test_slice = slice.SliceRequestBus(bus.Broadcast, 'InstantiateSliceFromAssetId', test_slice_id, transform) - Report.critical_result(Tests.slice_instantiated, test_slice.IsValid()) + test_prefab_path = os.path.join("Assets", "Prefabs", "BushFlowerBlender.prefab") + prefab_result = prefab.PrefabPublicRequestBus(bus.Broadcast, 'InstantiatePrefab', test_prefab_path, + entity.EntityId(), position) + Report.critical_result(Tests.prefab_instantiated, prefab_result.IsSuccess()) # Find root entity in the loaded level search_filter = entity.SearchFilter() @@ -126,8 +118,8 @@ def ComponentUpdates_UpdateGraph(): # Allow a few seconds for matching entity to be found helper.wait_for_condition(lambda: len(entity.SearchBus(bus.Broadcast, 'SearchEntities', search_filter)) > 0, 5.0) lc_matching_entities = entity.SearchBus(bus.Broadcast, 'SearchEntities', search_filter) - slice_root_id = lc_matching_entities[0] #Entity with Landscape Canvas component - Report.critical_result(Tests.lc_entity_found, slice_root_id.IsValid()) + prefab_root_id = lc_matching_entities[0] #Entity with Landscape Canvas component + Report.critical_result(Tests.lc_entity_found, prefab_root_id.IsValid()) # Find the BushSpawner entity search_filter.names = ["BushSpawner"] @@ -147,7 +139,7 @@ def ComponentUpdates_UpdateGraph(): # Open Landscape Canvas and the existing graph general.open_pane('Landscape Canvas') - open_graph = landscapecanvas.LandscapeCanvasRequestBus(bus.Broadcast, 'OnGraphEntity', slice_root_id) + open_graph = landscapecanvas.LandscapeCanvasRequestBus(bus.Broadcast, 'OnGraphEntity', prefab_root_id) Report.critical_result(Tests.existing_graph_opened, open_graph.IsValid()) # Verify that Distribution Filter node is present on the graph diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/Component_AddedRemoved.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/Component_AddedRemoved.py index 7f21a26595..465cf14481 100644 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/Component_AddedRemoved.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/Component_AddedRemoved.py @@ -45,11 +45,9 @@ def Component_AddedRemoved(): import editor_python_test_tools.hydra_editor_utils as hydra from editor_python_test_tools.utils import Report - from editor_python_test_tools.utils import TestHelper as helper # Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # Create an Entity at the root of the level newEntityId = editor.ToolsApplicationRequestBus(bus.Broadcast, 'CreateNewEntity', entity.EntityId()) diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/Edit_DisabledNodeDuplication.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/Edit_DisabledNodeDuplication.py index 4dfc227c53..e5b66399cb 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/Edit_DisabledNodeDuplication.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/Edit_DisabledNodeDuplication.py @@ -59,8 +59,7 @@ def Edit_DisabledNodeDuplication(): newEntityId = parameters[0] # Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # Open Landscape Canvas tool and verify general.open_pane('Landscape Canvas') diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/Edit_UndoNodeDelete_SliceEntity.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/Edit_UndoNodeDelete_PrefabEntity.py old mode 100755 new mode 100644 similarity index 85% rename from AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/Edit_UndoNodeDelete_SliceEntity.py rename to AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/Edit_UndoNodeDelete_PrefabEntity.py index a26e16755f..d7735f59c2 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/Edit_UndoNodeDelete_SliceEntity.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/Edit_UndoNodeDelete_PrefabEntity.py @@ -1,15 +1,14 @@ """ 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 """ class Tests: - slice_spawned = ( - "Slice instantiated successfully", - "Failed to instantiate slice" + prefab_instantiated = ( + "Prefab instantiated successfully", + "Failed to instantiate prefab" ) lc_entity_found = ( "Landscape Canvas entity found", @@ -31,31 +30,28 @@ class Tests: "Vegetation Layer Spawner node was successfully removed", "Failed to remove Vegetation Layer Spawner node" ) -def Edit_UndoNodeDelete_SliceEntity(): + + +def Edit_UndoNodeDelete_PrefabEntity(): """ Summary: - This test verifies Editor stability after undoing the deletion of nodes on a slice entity. - + This test verifies Editor stability after undoing the deletion of nodes on a prefab entity. Expected Behavior: Editor remains stable and free of crashes. - Test Steps: 1) Open a simple level - 2) Instantiate a slice with a Landscape Canvas setup + 2) Instantiate a prefab with a Landscape Canvas setup 3) Find a specific node on the graph, and delete it 4) Restore the node with Undo - Note: - This test file must be called from the Open 3D Engine Editor command terminal - Any passed and failed tests are written to the Editor.log file. Parsing the file or running a log_monitor are required to observe the test results. - :return: None """ import os - import azlmbr.asset as asset import azlmbr.bus as bus import azlmbr.editor as editor import azlmbr.entity as entity @@ -63,25 +59,23 @@ def Edit_UndoNodeDelete_SliceEntity(): import azlmbr.editor.graph as graph import azlmbr.landscapecanvas as landscapecanvas import azlmbr.math as math - import azlmbr.slice as slice + import azlmbr.prefab as prefab import editor_python_test_tools.hydra_editor_utils as hydra from editor_python_test_tools.utils import Report from editor_python_test_tools.utils import TestHelper as helper # Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # Instantiate slice transform = math.Transform_CreateIdentity() position = math.Vector3(64.0, 64.0, 32.0) transform.invoke('SetPosition', position) - test_slice_path = os.path.join("Slices", "LC_BushFlowerBlender.slice") - test_slice_id = asset.AssetCatalogRequestBus(bus.Broadcast, "GetAssetIdByPath", test_slice_path, math.Uuid(), - False) - test_slice = slice.SliceRequestBus(bus.Broadcast, 'InstantiateSliceFromAssetId', test_slice_id, transform) - Report.result(Tests.slice_spawned, test_slice.IsValid()) + test_prefab_path = os.path.join("Assets", "Prefabs", "BushFlowerBlender.prefab") + prefab_result = prefab.PrefabPublicRequestBus(bus.Broadcast, 'InstantiatePrefab', test_prefab_path, + entity.EntityId(), position) + Report.critical_result(Tests.prefab_instantiated, prefab_result.IsSuccess()) # Find root entity in the loaded level search_filter = entity.SearchFilter() @@ -134,5 +128,4 @@ def Edit_UndoNodeDelete_SliceEntity(): if __name__ == "__main__": from editor_python_test_tools.utils import Report - Report.start_test(Edit_UndoNodeDelete_SliceEntity) - + Report.start_test(Edit_UndoNodeDelete_PrefabEntity) diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientMixer_NodeConstruction.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientMixer_NodeConstruction.py index c390df7c61..95a9b08fe5 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientMixer_NodeConstruction.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientMixer_NodeConstruction.py @@ -76,7 +76,6 @@ def GradientMixer_NodeConstruction(): import editor_python_test_tools.hydra_editor_utils as hydra from editor_python_test_tools.utils import Report - from editor_python_test_tools.utils import TestHelper as helper editorId = azlmbr.globals.property.LANDSCAPE_CANVAS_EDITOR_ID @@ -85,8 +84,7 @@ def GradientMixer_NodeConstruction(): newEntityId = parameters[0] # Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # Open Landscape Canvas tool and verify general.open_pane('Landscape Canvas') diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientModifierNodes_EntityCreatedOnNodeAdd.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientModifierNodes_EntityCreatedOnNodeAdd.py index c3952fe34b..3b6e28ca3d 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientModifierNodes_EntityCreatedOnNodeAdd.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientModifierNodes_EntityCreatedOnNodeAdd.py @@ -58,7 +58,6 @@ def GradientModifierNodes_EntityCreatedOnNodeAdd(): import editor_python_test_tools.hydra_editor_utils as hydra from editor_python_test_tools.utils import Report - from editor_python_test_tools.utils import TestHelper as helper editorId = azlmbr.globals.property.LANDSCAPE_CANVAS_EDITOR_ID @@ -67,8 +66,7 @@ def GradientModifierNodes_EntityCreatedOnNodeAdd(): newEntityId = parameters[0] # Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # Open Landscape Canvas tool and verify general.open_pane('Landscape Canvas') diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientModifierNodes_EntityRemovedOnNodeDelete.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientModifierNodes_EntityRemovedOnNodeDelete.py index d7789a21fb..e6fb61e10a 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientModifierNodes_EntityRemovedOnNodeDelete.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientModifierNodes_EntityRemovedOnNodeDelete.py @@ -58,8 +58,8 @@ def GradientModifierNodes_EntityRemovedOnNodeDelete(): import azlmbr.legacy.general as general import azlmbr.math as math + import editor_python_test_tools.hydra_editor_utils as hydra from editor_python_test_tools.utils import Report - from editor_python_test_tools.utils import TestHelper as helper editorId = azlmbr.globals.property.LANDSCAPE_CANVAS_EDITOR_ID @@ -72,8 +72,7 @@ def GradientModifierNodes_EntityRemovedOnNodeDelete(): deletedEntityId = parameters[0] # Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # Open Landscape Canvas tool and verify general.open_pane('Landscape Canvas') diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientNodes_DependentComponentsAdded.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientNodes_DependentComponentsAdded.py index 63df9a6fcb..c2007e49e2 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientNodes_DependentComponentsAdded.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientNodes_DependentComponentsAdded.py @@ -60,7 +60,6 @@ def GradientNodes_DependentComponentsAdded(): import editor_python_test_tools.hydra_editor_utils as hydra from editor_python_test_tools.utils import Report - from editor_python_test_tools.utils import TestHelper as helper editorId = azlmbr.globals.property.LANDSCAPE_CANVAS_EDITOR_ID @@ -69,8 +68,7 @@ def GradientNodes_DependentComponentsAdded(): newEntityId = parameters[0] # Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # Open Landscape Canvas tool and verify general.open_pane('Landscape Canvas') diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientNodes_EntityCreatedOnNodeAdd.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientNodes_EntityCreatedOnNodeAdd.py index d5595e342c..5111f45f22 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientNodes_EntityCreatedOnNodeAdd.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientNodes_EntityCreatedOnNodeAdd.py @@ -58,7 +58,6 @@ def GradientNodes_EntityCreatedOnNodeAdd(): import editor_python_test_tools.hydra_editor_utils as hydra from editor_python_test_tools.utils import Report - from editor_python_test_tools.utils import TestHelper as helper editorId = azlmbr.globals.property.LANDSCAPE_CANVAS_EDITOR_ID @@ -67,8 +66,7 @@ def GradientNodes_EntityCreatedOnNodeAdd(): newEntityId = parameters[0] # Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # Open Landscape Canvas tool and verify general.open_pane('Landscape Canvas') diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientNodes_EntityRemovedOnNodeDelete.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientNodes_EntityRemovedOnNodeDelete.py index e5bfbfc7f1..1840fd3f1a 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientNodes_EntityRemovedOnNodeDelete.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GradientNodes_EntityRemovedOnNodeDelete.py @@ -58,8 +58,8 @@ def GradientNodes_EntityRemovedOnNodeDelete(): import azlmbr.legacy.general as general import azlmbr.math as math + import editor_python_test_tools.hydra_editor_utils as hydra from editor_python_test_tools.utils import Report - from editor_python_test_tools.utils import TestHelper as helper editorId = azlmbr.globals.property.LANDSCAPE_CANVAS_EDITOR_ID @@ -72,8 +72,7 @@ def GradientNodes_EntityRemovedOnNodeDelete(): deletedEntityId = parameters[0] # Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # Open Landscape Canvas tool and verify general.open_pane('Landscape Canvas') diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GraphClosed_OnEntityDelete.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GraphClosed_OnEntityDelete.py index 0f83688206..1902516fb3 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GraphClosed_OnEntityDelete.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GraphClosed_OnEntityDelete.py @@ -51,8 +51,8 @@ def GraphClosed_OnEntityDelete(): import azlmbr.editor.graph as graph import azlmbr.legacy.general as general + import editor_python_test_tools.hydra_editor_utils as hydra from editor_python_test_tools.utils import Report - from editor_python_test_tools.utils import TestHelper as helper editorId = azlmbr.globals.property.LANDSCAPE_CANVAS_EDITOR_ID @@ -61,8 +61,7 @@ def GraphClosed_OnEntityDelete(): newRootEntityId = parameters[0] # Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # Open Landscape Canvas tool and verify general.open_pane('Landscape Canvas') diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GraphClosed_OnLevelChange.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GraphClosed_OnLevelChange.py index 67c2ec6908..d5d46c042d 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GraphClosed_OnLevelChange.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GraphClosed_OnLevelChange.py @@ -51,14 +51,13 @@ def GraphClosed_OnLevelChange(): import azlmbr.editor.graph as graph import azlmbr.legacy.general as general + import editor_python_test_tools.hydra_editor_utils as hydra from editor_python_test_tools.utils import Report - from editor_python_test_tools.utils import TestHelper as helper editorId = azlmbr.globals.property.LANDSCAPE_CANVAS_EDITOR_ID # Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # Open Landscape Canvas tool and verify general.open_pane('Landscape Canvas') @@ -73,7 +72,7 @@ def GraphClosed_OnLevelChange(): Report.result(Tests.graph_registered, graph_registered) # Open a different level, which should close any open Landscape Canvas graphs - general.open_level_no_prompt('WhiteBox/EmptyLevel') + general.open_level_no_prompt('Base') # Make sure the graph we created is now closed graphIsOpen = graph.AssetEditorRequestBus(bus.Event, 'ContainsGraph', editorId, newGraphId) diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GraphClosed_TabbedGraph.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GraphClosed_TabbedGraph.py index 83762e0afb..d33ee7746f 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GraphClosed_TabbedGraph.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GraphClosed_TabbedGraph.py @@ -51,8 +51,8 @@ def GraphClosed_TabbedGraphClosesIndependently(): import azlmbr.editor.graph as graph import azlmbr.legacy.general as general + import editor_python_test_tools.hydra_editor_utils as hydra from editor_python_test_tools.utils import Report - from editor_python_test_tools.utils import TestHelper as helper editor_id = azlmbr.globals.property.LANDSCAPE_CANVAS_EDITOR_ID @@ -65,8 +65,7 @@ def GraphClosed_TabbedGraphClosesIndependently(): return graph_open # Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # Open Landscape Canvas tool and verify general.open_pane('Landscape Canvas') diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GraphUpdates_UpdateComponents.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GraphUpdates_UpdateComponents.py index c489c738d5..6a007a9014 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GraphUpdates_UpdateComponents.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/GraphUpdates_UpdateComponents.py @@ -1,18 +1,17 @@ """ 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 """ class Tests: - slice_instantiated = ( - "Slice instantiated successfully", - "Failed to instantiate slice" + prefab_instantiated = ( + "Prefab instantiated successfully", + "Failed to instantiate prefab" ) existing_graph_opened = ( - "Opened existing graph from slice", + "Opened existing graph from prefab", "Failed to open existing graph" ) node_removed = ( @@ -37,13 +36,11 @@ def GraphUpdates_UpdateComponent(): """ Summary: This test verifies that components are properly updated as nodes are added/removed/updated. - Expected Behavior: Landscape Canvas node CRUD properly updates component entities. - Test Steps: 1. Open Level. - 2. Open the graph on LC_BushFlowerBlender.slice + 2. Open the graph on BushFlowerBlender.prefab 3. Find the Rotation Modifier node on the BushSpawner entity 4. Delete the Rotation Modifier node 5. Ensure the Vegetation Rotation Modifier component is removed from the BushSpawner entity @@ -51,18 +48,15 @@ def GraphUpdates_UpdateComponent(): 7. Ensure BushSpawner entity is deleted 8. Change connection from second Rotation Modifier node to a different Gradient 9. Ensure Gradient reference on component is updated - Note: - This test file must be called from the Open 3D Engine Editor command terminal - Any passed and failed tests are written to the Editor.log file. Parsing the file or running a log_monitor are required to observe the test results. - :return: None """ import os - import azlmbr.asset as asset import azlmbr.bus as bus import azlmbr.editor as editor import azlmbr.entity as entity @@ -70,39 +64,37 @@ def GraphUpdates_UpdateComponent(): import azlmbr.editor.graph as graph import azlmbr.landscapecanvas as landscapecanvas import azlmbr.math as math - import azlmbr.slice as slice + import azlmbr.prefab as prefab import automatedtesting_shared.landscape_canvas_utils as lc import editor_python_test_tools.hydra_editor_utils as hydra from editor_python_test_tools.utils import Report from editor_python_test_tools.utils import TestHelper as helper - # Open a simple level and instantiate LC_BushFlowerBlender.slice - helper.init_idle() - helper.open_level("Physics", "Base") + # Open a simple level and instantiate BushFlowerBlender.prefab + hydra.open_base_level() transform = math.Transform_CreateIdentity() position = math.Vector3(64.0, 64.0, 32.0) transform.invoke('SetPosition', position) - test_slice_path = os.path.join("Slices", "LC_BushFlowerBlender.slice") - test_slice_id = asset.AssetCatalogRequestBus(bus.Broadcast, "GetAssetIdByPath", test_slice_path, math.Uuid(), - False) - test_slice = slice.SliceRequestBus(bus.Broadcast, 'InstantiateSliceFromAssetId', test_slice_id, transform) - Report.critical_result(Tests.slice_instantiated, test_slice.IsValid()) + test_prefab_path = os.path.join("Assets", "Prefabs", "BushFlowerBlender.prefab") + prefab_result = prefab.PrefabPublicRequestBus(bus.Broadcast, 'InstantiatePrefab', test_prefab_path, + entity.EntityId(), position) + Report.critical_result(Tests.prefab_instantiated, prefab_result.IsSuccess()) - # Search for root entity to ensure slice is loaded + # Search for root entity to ensure prefab is loaded search_filter = entity.SearchFilter() search_filter.names = ["LandscapeCanvas"] helper.wait_for_condition(lambda: len(entity.SearchBus(bus.Broadcast, 'SearchEntities', search_filter)) > 0, 5.0) + prefab_lc_root = entity.SearchBus(bus.Broadcast, 'SearchEntities', search_filter)[0] # Find needed entities in the loaded level - slice_root_id = hydra.find_entity_by_name('LandscapeCanvas') bush_spawner_id = hydra.find_entity_by_name('BushSpawner') flower_spawner_id = hydra.find_entity_by_name('FlowerSpawner') inverted_perlin_noise_id = hydra.find_entity_by_name('Invert') # Open Landscape Canvas and the existing graph general.open_pane('Landscape Canvas') - open_graph_id = landscapecanvas.LandscapeCanvasRequestBus(bus.Broadcast, 'OnGraphEntity', slice_root_id) + open_graph_id = landscapecanvas.LandscapeCanvasRequestBus(bus.Broadcast, 'OnGraphEntity', prefab_lc_root) Report.critical_result(Tests.existing_graph_opened, open_graph_id.IsValid()) # Find the Rotation Modifier node on the BushSpawner entity @@ -110,6 +102,7 @@ def GraphUpdates_UpdateComponent(): # Remove the Rotation Modifier node graph.GraphControllerRequestBus(bus.Event, 'RemoveNode', open_graph_id, rotation_modifier_node[0]) + general.idle_wait_frames(2) # Verify node was removed rotation_modifier_node = lc.find_nodes_matching_entity_component('Vegetation Rotation Modifier', bush_spawner_id) @@ -121,14 +114,18 @@ def GraphUpdates_UpdateComponent(): Report.result(Tests.component_removed, not has_rotation_modifier) # Find the Vegetation Layer Spawner node on the BushSpawner entity + open_graph_id = landscapecanvas.LandscapeCanvasRequestBus(bus.Broadcast, 'OnGraphEntity', prefab_lc_root) layer_spawner_node = lc.find_nodes_matching_entity_component('Vegetation Layer Spawner', bush_spawner_id) # Remove the Vegetation Layer Spawner node and verify the corresponding entity is deleted graph.GraphControllerRequestBus(bus.Event, 'RemoveNode', open_graph_id, layer_spawner_node[0]) + general.idle_wait_frames(2) + layer_spawner_node = lc.find_nodes_matching_entity_component('Vegetation Layer Spawner', bush_spawner_id) bush_spawner_id = hydra.find_entity_by_name('BushSpawner') - Report.result(Tests.entity_deleted, not bush_spawner_id) + Report.result(Tests.entity_deleted, not layer_spawner_node and not bush_spawner_id) # Connect the FlowerSpawner's Rotation Modifier node to the Invert Gradient Modifier node + open_graph_id = landscapecanvas.LandscapeCanvasRequestBus(bus.Broadcast, 'OnGraphEntity', prefab_lc_root) rotation_modifier_node = lc.find_nodes_matching_entity_component('Vegetation Rotation Modifier', flower_spawner_id) invert_node = lc.find_nodes_matching_entity_component('Invert Gradient Modifier', inverted_perlin_noise_id) @@ -137,7 +134,7 @@ def GraphUpdates_UpdateComponent(): graph.GraphControllerRequestBus(bus.Event, 'AddConnectionBySlotId', open_graph_id, invert_node[0], outbound_gradient_slot, rotation_modifier_node[0], inbound_gradient_z_slot) - general.idle_wait(1.0) # Add a small wait to ensure component property has time to update + general.idle_wait_frames(2) # Add a small wait to ensure component property has time to update # Verify the Gradient Entity Id reference on the Rotation Modifier component was properly set rotation_type_id = hydra.get_component_type_id('Vegetation Rotation Modifier') diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/LayerBlender_NodeConstruction.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/LayerBlender_NodeConstruction.py index b2bf20411b..da9a21aee6 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/LayerBlender_NodeConstruction.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/LayerBlender_NodeConstruction.py @@ -64,7 +64,6 @@ def LayerBlender_NodeConstruction(): import editor_python_test_tools.hydra_editor_utils as hydra from editor_python_test_tools.utils import Report - from editor_python_test_tools.utils import TestHelper as helper editorId = azlmbr.globals.property.LANDSCAPE_CANVAS_EDITOR_ID @@ -73,8 +72,7 @@ def LayerBlender_NodeConstruction(): newEntityId = parameters[0] # Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # Open Landscape Canvas tool and verify general.open_pane('Landscape Canvas') diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/LayerExtenderNodes_ComponentEntitySync.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/LayerExtenderNodes_ComponentEntitySync.py index 510c404614..cd54a741ec 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/LayerExtenderNodes_ComponentEntitySync.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/LayerExtenderNodes_ComponentEntitySync.py @@ -63,7 +63,6 @@ def LayerExtenderNodes_ComponentEntitySync(): import editor_python_test_tools.hydra_editor_utils as hydra from editor_python_test_tools.utils import Report - from editor_python_test_tools.utils import TestHelper as helper editorId = azlmbr.globals.property.LANDSCAPE_CANVAS_EDITOR_ID @@ -72,8 +71,7 @@ def LayerExtenderNodes_ComponentEntitySync(): newEntityId = parameters[0] # Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # Open Landscape Canvas tool and verify general.open_pane('Landscape Canvas') diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/NewGraph_CreatedSuccessfully.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/NewGraph_CreatedSuccessfully.py index d13c5dfa2f..f7564a643d 100644 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/NewGraph_CreatedSuccessfully.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/NewGraph_CreatedSuccessfully.py @@ -60,7 +60,6 @@ def NewGraph_CreatedSuccessfully(): import editor_python_test_tools.hydra_editor_utils as hydra from editor_python_test_tools.utils import Report - from editor_python_test_tools.utils import TestHelper as helper editorId = azlmbr.globals.property.LANDSCAPE_CANVAS_EDITOR_ID @@ -69,8 +68,7 @@ def NewGraph_CreatedSuccessfully(): new_root_entity_id = parameters[0] # Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # Listen for entity creation notifications so we can check if the entity created # with the new graph has our Landscape Canvas component automatically added diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/Prefab_CreateInstantiate.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/Prefab_CreateInstantiate.py new file mode 100644 index 0000000000..894a69a40e --- /dev/null +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/Prefab_CreateInstantiate.py @@ -0,0 +1,69 @@ +""" +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 +""" + + +class Tests: + prefab_created = ( + "Prefab created successfully", + "Failed to create prefab" + ) + prefab_instantiated = ( + "Prefab instantiated successfully", + "Failed to instantiate prefab" + ) + + +def Prefab_CreateInstantiate(): + """ + Summary: + A prefab containing the LandscapeCanvas component can be created/instantiated. + Expected Result: + Prefab is created/processed/instantiated successfully and free of errors/warnings. + Test Steps: + 1) Open a simple level + 2) Create a new entity with a Landscape Canvas component + 3) Create a prefab of the new entity + 4) Instantiate a new copy of the prefab + Note: + - This test file must be called from the Open 3D Engine Editor command terminal + - Any passed and failed tests are written to the Editor.log file. + Parsing the file or running a log_monitor are required to observe the test results. + :return: None + """ + + import azlmbr.math as math + + import editor_python_test_tools.hydra_editor_utils as hydra + from editor_python_test_tools.utils import Report + from editor_python_test_tools.utils import TestHelper as helper + from editor_python_test_tools.prefab_utils import Prefab + + # Open an existing simple level + hydra.open_base_level() + + # Create entity with Landscape Canvas component + position = math.Vector3(512.0, 512.0, 32.0) + landscape_canvas = hydra.Entity("landscape_canvas_entity") + landscape_canvas.create_entity(position, ["Landscape Canvas"]) + + # Create in-memory prefab from the created entity + lc_prefab_filename = "LC_PrefabTest" + lc_prefab, lc_prefab_instance = Prefab.create_prefab([landscape_canvas], lc_prefab_filename) + + # Verify if prefab is created + helper.wait_for_condition(lambda: lc_prefab.is_prefab_loaded(lc_prefab_filename), 5.0) + Report.result(Tests.prefab_created, lc_prefab.is_prefab_loaded(lc_prefab_filename)) + + # Instantiate prefab + lc_prefab_instance2 = lc_prefab.instantiate() + helper.wait_for_condition(lambda: lc_prefab_instance2.has_editor_prefab_component(), 5.0) + Report.result(Tests.prefab_instantiated, lc_prefab_instance2.has_editor_prefab_component()) + + +if __name__ == "__main__": + + from editor_python_test_tools.utils import Report + Report.start_test(Prefab_CreateInstantiate) \ No newline at end of file diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/ShapeNodes_EntityCreatedOnNodeAdd.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/ShapeNodes_EntityCreatedOnNodeAdd.py index 93464c7ad3..c93b377945 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/ShapeNodes_EntityCreatedOnNodeAdd.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/ShapeNodes_EntityCreatedOnNodeAdd.py @@ -58,7 +58,6 @@ def ShapeNodes_EntityCreatedOnNodeAdd(): import editor_python_test_tools.hydra_editor_utils as hydra from editor_python_test_tools.utils import Report - from editor_python_test_tools.utils import TestHelper as helper editorId = azlmbr.globals.property.LANDSCAPE_CANVAS_EDITOR_ID @@ -66,10 +65,8 @@ def ShapeNodes_EntityCreatedOnNodeAdd(): global newEntityId newEntityId = parameters[0] - # Open an existing simple level - - helper.init_idle() - helper.open_level("Physics", "Base") + # Open an existing simple level + hydra.open_base_level() # Open Landscape Canvas tool and verify general.open_pane('Landscape Canvas') diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/ShapeNodes_EntityRemovedOnNodeDelete.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/ShapeNodes_EntityRemovedOnNodeDelete.py index d2708f643d..4057e7f6e9 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/ShapeNodes_EntityRemovedOnNodeDelete.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/ShapeNodes_EntityRemovedOnNodeDelete.py @@ -58,8 +58,8 @@ def ShapeNodes_EntityRemovedOnNodeDelete(): import azlmbr.legacy.general as general import azlmbr.math as math + import editor_python_test_tools.hydra_editor_utils as hydra from editor_python_test_tools.utils import Report - from editor_python_test_tools.utils import TestHelper as helper editorId = azlmbr.globals.property.LANDSCAPE_CANVAS_EDITOR_ID @@ -72,8 +72,7 @@ def ShapeNodes_EntityRemovedOnNodeDelete(): deletedEntityId = parameters[0] # Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # Open Landscape Canvas tool and verify general.open_pane('Landscape Canvas') diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/Slice_CreateInstantiate.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/Slice_CreateInstantiate.py deleted file mode 100644 index c5ab08f99a..0000000000 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/Slice_CreateInstantiate.py +++ /dev/null @@ -1,84 +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 -""" - - -class Tests: - slice_created = ( - "Slice created successfully", - "Failed to create slice" - ) - slice_instantiated = ( - "Slice instantiated successfully", - "Failed to instantiate slice" - ) - - -def Slice_CreateInstantiate(): - """ - Summary: - A slice containing the LandscapeCanvas component can be created/instantiated. - - Expected Result: - Slice is created/processed/instantiated successfully and free of errors/warnings. - - Test Steps: - 1) Open a simple level - 2) Create a new entity with a Landscape Canvas component - 3) Create a slice of the new entity - 4) Instantiate a new copy of the slice - - Note: - - This test file must be called from the Open 3D Engine Editor command terminal - - Any passed and failed tests are written to the Editor.log file. - Parsing the file or running a log_monitor are required to observe the test results. - :return: None - """ - - import os - - import azlmbr.math as math - import azlmbr.bus as bus - import azlmbr.asset as asset - import azlmbr.slice as slice - - import editor_python_test_tools.hydra_editor_utils as hydra - from editor_python_test_tools.utils import Report - from editor_python_test_tools.utils import TestHelper as helper - - def path_is_valid_asset(asset_path): - asset_id = asset.AssetCatalogRequestBus(bus.Broadcast, "GetAssetIdByPath", asset_path, math.Uuid(), False) - return asset_id.invoke("IsValid") - - # Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") - - # Create entity with Landscape Canvas component - position = math.Vector3(512.0, 512.0, 32.0) - landscape_canvas = hydra.Entity("landscape_canvas_entity") - landscape_canvas.create_entity(position, ["Landscape Canvas"]) - - # Create slice from the created entity - slice_path = os.path.join("slices", "TestSlice.slice") - slice.SliceRequestBus(bus.Broadcast, "CreateNewSlice", landscape_canvas.id, slice_path) - - # Verify if slice is created - helper.wait_for_condition(lambda: path_is_valid_asset(slice_path), 5.0) - Report.result(Tests.slice_created, path_is_valid_asset(slice_path)) - - # Instantiate slice - transform = math.Transform_CreateIdentity() - asset_id = asset.AssetCatalogRequestBus(bus.Broadcast, "GetAssetIdByPath", slice_path, math.Uuid(), False) - test_slice = slice.SliceRequestBus(bus.Broadcast, "InstantiateSliceFromAssetId", asset_id, transform) - helper.wait_for_condition(lambda: test_slice.IsValid(), 5.0) - Report.result(Tests.slice_instantiated, test_slice.IsValid()) - - -if __name__ == "__main__": - - from editor_python_test_tools.utils import Report - Report.start_test(Slice_CreateInstantiate) diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/SlotConnections_UpdateComponentReferences.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/SlotConnections_UpdateComponentReferences.py index 3169908621..208849ea61 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/SlotConnections_UpdateComponentReferences.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/EditorScripts/SlotConnections_UpdateComponentReferences.py @@ -67,7 +67,6 @@ def SlotConnections_UpdateComponentReferences(): import editor_python_test_tools.hydra_editor_utils as hydra from editor_python_test_tools.utils import Report - from editor_python_test_tools.utils import TestHelper as helper editorId = azlmbr.globals.property.LANDSCAPE_CANVAS_EDITOR_ID @@ -101,8 +100,7 @@ def SlotConnections_UpdateComponentReferences(): newEntityId = parameters[0] # Open an existing simple level - helper.init_idle() - helper.open_level("Physics", "Base") + hydra.open_base_level() # Open Landscape Canvas tool and verify general.open_pane('Landscape Canvas') diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/TestSuite_Main.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/TestSuite_Main.py index dedc9c70c0..12e426e400 100644 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/TestSuite_Main.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/TestSuite_Main.py @@ -1,29 +1,88 @@ """ Copyright (c) Contributors to the Open 3D Engine Project. For complete copyright and license terms please see the LICENSE at the root of this distribution. - SPDX-License-Identifier: Apache-2.0 OR MIT """ -import os import pytest -import sys -import ly_test_tools.environment.file_system as file_system - -sys.path.append(os.path.dirname(os.path.abspath(__file__)) + '/../../automatedtesting_shared') -from base import TestAutomationBase +from ly_test_tools.o3de.editor_test import EditorSingleTest, EditorSharedTest, EditorParallelTest, EditorTestSuite -@pytest.mark.SUITE_main @pytest.mark.parametrize("launcher_platform", ['windows_editor']) @pytest.mark.parametrize("project", ["AutomatedTesting"]) -class TestAutomation(TestAutomationBase): +class TestAutomation(EditorTestSuite): - def test_LandscapeCanvas_SlotConnections_UpdateComponentReferences(self, request, workspace, editor, launcher_platform): - from .EditorScripts import SlotConnections_UpdateComponentReferences as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) + class test_LandscapeCanvas_AreaNodes_DependentComponentsAdded(EditorSharedTest): + from .EditorScripts import AreaNodes_DependentComponentsAdded as test_module - def test_LandscapeCanvas_GradientMixer_NodeConstruction(self, request, workspace, editor, launcher_platform): + class test_LandscapeCanvas_AreaNodes_EntityCreatedOnNodeAdd(EditorSharedTest): + from .EditorScripts import AreaNodes_EntityCreatedOnNodeAdd as test_module + + class test_LandscapeCanvas_AreaNodes_EntityRemovedOnNodeDelete(EditorSharedTest): + from .EditorScripts import AreaNodes_EntityRemovedOnNodeDelete as test_module + + class test_LandscapeCanvas_Component_AddedRemoved(EditorSharedTest): + from .EditorScripts import Component_AddedRemoved as test_module + + class test_LandscapeCanvas_ComponentUpdates_UpdateGraph(EditorSharedTest): + from .EditorScripts import ComponentUpdates_UpdateGraph as test_module + + class test_LandscapeCanvas_Edit_DisabledNodeDuplication(EditorSharedTest): + from .EditorScripts import Edit_DisabledNodeDuplication as test_module + + class test_LandscapeCanvas_Edit_UndoNodeDelete_PrefabEntity(EditorSharedTest): + from .EditorScripts import Edit_UndoNodeDelete_PrefabEntity as test_module + + class test_LandscapeCanvas_GradientMixer_NodeConstruction(EditorSharedTest): from .EditorScripts import GradientMixer_NodeConstruction as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) + + class test_LandscapeCanvas_GradientModifierNodes_EntityCreatedOnNodeAdd(EditorSharedTest): + from .EditorScripts import GradientModifierNodes_EntityCreatedOnNodeAdd as test_module + + class test_LandscapeCanvas_GradientModifierNodes_EntityRemovedOnNodeDelete(EditorSharedTest): + from .EditorScripts import GradientModifierNodes_EntityRemovedOnNodeDelete as test_module + + class test_LandscapeCanvas_GradientNodes_DependentComponentsAdded(EditorSharedTest): + from .EditorScripts import GradientNodes_DependentComponentsAdded as test_module + + class test_LandscapeCanvas_GradientNodes_EntityCreatedOnNodeAdd(EditorSharedTest): + from .EditorScripts import GradientNodes_EntityCreatedOnNodeAdd as test_module + + class test_LandscapeCanvas_GradientNodes_EntityRemovedOnNodeDelete(EditorSharedTest): + from .EditorScripts import GradientNodes_EntityRemovedOnNodeDelete as test_module + + @pytest.mark.xfail(reason="https://github.com/o3de/o3de/issues/2201") + class test_LandscapeCanvas_GraphClosed_OnEntityDelete(EditorSharedTest): + from .EditorScripts import GraphClosed_OnEntityDelete as test_module + + class test_LandscapeCanvas_GraphClosed_OnLevelChange(EditorSharedTest): + from .EditorScripts import GraphClosed_OnLevelChange as test_module + + class test_LandscapeCanvas_GraphClosed_TabbedGraphClosesIndependently(EditorSharedTest): + from .EditorScripts import GraphClosed_TabbedGraph as test_module + + @pytest.mark.skip(reason="https://github.com/o3de/o3de/issues/7141" "https://github.com/o3de/o3de/issues/4872") + class test_LandscapeCanvas_GraphUpdates_UpdateComponents(EditorSharedTest): + from .EditorScripts import GraphUpdates_UpdateComponents as test_module + + class test_LandscapeCanvas_LayerBlender_NodeConstruction(EditorSharedTest): + from .EditorScripts import LayerBlender_NodeConstruction as test_module + + class test_LandscapeCanvas_LayerExtenderNodes_ComponentEntitySync(EditorSharedTest): + from .EditorScripts import LayerExtenderNodes_ComponentEntitySync as test_module + + class test_LandscapeCanvas_NewGraph_CreatedSuccessfully(EditorSharedTest): + from .EditorScripts import NewGraph_CreatedSuccessfully as test_module + + class test_LandscapeCanvas_Prefab_CreateInstantiate(EditorSharedTest): + from .EditorScripts import Prefab_CreateInstantiate as test_module + + class test_LandscapeCanvas_ShapeNodes_EntityCreatedOnNodeAdd(EditorSharedTest): + from .EditorScripts import ShapeNodes_EntityCreatedOnNodeAdd as test_module + + class test_LandscapeCanvas_ShapeNodes_EntityRemovedOnNodeDelete(EditorSharedTest): + from .EditorScripts import ShapeNodes_EntityRemovedOnNodeDelete as test_module + + class test_LandscapeCanvas_SlotConnections_UpdateComponentReferences(EditorSharedTest): + from .EditorScripts import SlotConnections_UpdateComponentReferences as test_module diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/TestSuite_Main_Optimized.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/TestSuite_Main_Optimized.py deleted file mode 100644 index 402df133cb..0000000000 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/TestSuite_Main_Optimized.py +++ /dev/null @@ -1,100 +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 pytest - -import ly_test_tools.environment.file_system as file_system -import ly_test_tools._internal.pytest_plugin as internal_plugin -from ly_test_tools.o3de.editor_test import EditorSingleTest, EditorSharedTest, EditorParallelTest, EditorTestSuite - - -@pytest.mark.SUITE_periodic -@pytest.mark.parametrize("launcher_platform", ['windows_editor']) -@pytest.mark.parametrize("project", ["AutomatedTesting"]) -class TestAutomation(EditorTestSuite): - - enable_prefab_system = False - - class test_LandscapeCanvas_SlotConnections_UpdateComponentReferences(EditorSharedTest): - from .EditorScripts import SlotConnections_UpdateComponentReferences as test_module - - class test_LandscapeCanvas_GradientMixer_NodeConstruction(EditorSharedTest): - from .EditorScripts import GradientMixer_NodeConstruction as test_module - - class test_LandscapeCanvas_AreaNodes_DependentComponentsAdded(EditorSharedTest): - from .EditorScripts import AreaNodes_DependentComponentsAdded as test_module - - class test_LandscapeCanvas_AreaNodes_EntityCreatedOnNodeAdd(EditorSharedTest): - from .EditorScripts import AreaNodes_EntityCreatedOnNodeAdd as test_module - - class test_LandscapeCanvas_AreaNodes_EntityRemovedOnNodeDelete(EditorSharedTest): - from .EditorScripts import AreaNodes_EntityRemovedOnNodeDelete as test_module - - class test_LandscapeCanvas_LayerExtenderNodes_ComponentEntitySync(EditorSharedTest): - from .EditorScripts import LayerExtenderNodes_ComponentEntitySync as test_module - - class test_LandscapeCanvas_Edit_DisabledNodeDuplication(EditorSharedTest): - from .EditorScripts import Edit_DisabledNodeDuplication as test_module - - class test_LandscapeCanvas_Edit_UndoNodeDelete_SliceEntity(EditorSharedTest): - from .EditorScripts import Edit_UndoNodeDelete_SliceEntity as test_module - - class test_LandscapeCanvas_NewGraph_CreatedSuccessfully(EditorSharedTest): - from .EditorScripts import NewGraph_CreatedSuccessfully as test_module - - class test_LandscapeCanvas_Component_AddedRemoved(EditorSharedTest): - from .EditorScripts import Component_AddedRemoved as test_module - - class test_LandscapeCanvas_GraphClosed_OnLevelChange(EditorSharedTest): - from .EditorScripts import GraphClosed_OnLevelChange as test_module - - @pytest.mark.xfail(reason="https://github.com/o3de/o3de/issues/2201") - class test_LandscapeCanvas_GraphClosed_OnEntityDelete(EditorSharedTest): - from .EditorScripts import GraphClosed_OnEntityDelete as test_module - - class test_LandscapeCanvas_GraphClosed_TabbedGraphClosesIndependently(EditorSharedTest): - from .EditorScripts import GraphClosed_TabbedGraph as test_module - - class test_LandscapeCanvas_Slice_CreateInstantiate(EditorSingleTest): - from .EditorScripts import Slice_CreateInstantiate as test_module - # Custom teardown to remove slice asset created during test - def teardown(self, request, workspace, editor, editor_test_results, launcher_platform): - file_system.delete([os.path.join(workspace.paths.engine_root(), "AutomatedTesting", "slices", - "TestSlice.slice")], True, True) - - class test_LandscapeCanvas_GradientModifierNodes_EntityCreatedOnNodeAdd(EditorSharedTest): - from .EditorScripts import GradientModifierNodes_EntityCreatedOnNodeAdd as test_module - - class test_LandscapeCanvas_GradientModifierNodes_EntityRemovedOnNodeDelete(EditorSharedTest): - from .EditorScripts import GradientModifierNodes_EntityRemovedOnNodeDelete as test_module - - class test_LandscapeCanvas_GradientNodes_DependentComponentsAdded(EditorSharedTest): - from .EditorScripts import GradientNodes_DependentComponentsAdded as test_module - - class test_LandscapeCanvas_GradientNodes_EntityCreatedOnNodeAdd(EditorSharedTest): - from .EditorScripts import GradientNodes_EntityCreatedOnNodeAdd as test_module - - class test_LandscapeCanvas_GradientNodes_EntityRemovedOnNodeDelete(EditorSharedTest): - from .EditorScripts import GradientNodes_EntityRemovedOnNodeDelete as test_module - - @pytest.mark.skipif("debug" == os.path.basename(internal_plugin.build_directory), - reason="https://github.com/o3de/o3de/issues/4872") - class test_LandscapeCanvas_GraphUpdates_UpdateComponents(EditorSharedTest): - from .EditorScripts import GraphUpdates_UpdateComponents as test_module - - class test_LandscapeCanvas_ComponentUpdates_UpdateGraph(EditorSharedTest): - from .EditorScripts import ComponentUpdates_UpdateGraph as test_module - - class test_LandscapeCanvas_LayerBlender_NodeConstruction(EditorSharedTest): - from .EditorScripts import LayerBlender_NodeConstruction as test_module - - class test_LandscapeCanvas_ShapeNodes_EntityCreatedOnNodeAdd(EditorSharedTest): - from .EditorScripts import ShapeNodes_EntityCreatedOnNodeAdd as test_module - - class test_LandscapeCanvas_ShapeNodes_EntityRemovedOnNodeDelete(EditorSharedTest): - from .EditorScripts import ShapeNodes_EntityRemovedOnNodeDelete as test_module \ No newline at end of file diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/TestSuite_Periodic.py b/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/TestSuite_Periodic.py deleted file mode 100644 index a719b1a7c0..0000000000 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/landscape_canvas/TestSuite_Periodic.py +++ /dev/null @@ -1,121 +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 pytest -import sys - -import ly_test_tools.environment.file_system as file_system - -sys.path.append(os.path.dirname(os.path.abspath(__file__)) + '/../../automatedtesting_shared') -from base import TestAutomationBase - - -@pytest.fixture -def remove_test_slice(request, workspace, project): - file_system.delete([os.path.join(workspace.paths.engine_root(), project, "slices", "TestSlice.slice")], True, True) - - def teardown(): - file_system.delete([os.path.join(workspace.paths.engine_root(), project, "slices", "TestSlice.slice")], True, - True) - - request.addfinalizer(teardown) - - -@pytest.mark.SUITE_periodic -@pytest.mark.parametrize("launcher_platform", ['windows_editor']) -@pytest.mark.parametrize("project", ["AutomatedTesting"]) -class TestAutomation(TestAutomationBase): - - def test_LandscapeCanvas_AreaNodes_DependentComponentsAdded(self, request, workspace, editor, launcher_platform): - from .EditorScripts import AreaNodes_DependentComponentsAdded as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_LandscapeCanvas_AreaNodes_EntityCreatedOnNodeAdd(self, request, workspace, editor, launcher_platform): - from .EditorScripts import AreaNodes_EntityCreatedOnNodeAdd as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_LandscapeCanvas_AreaNodes_EntityRemovedOnNodeDelete(self, request, workspace, editor, launcher_platform): - from .EditorScripts import AreaNodes_EntityRemovedOnNodeDelete as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_LandscapeCanvas_LayerExtenderNodes_ComponentEntitySync(self, request, workspace, editor, launcher_platform): - from .EditorScripts import LayerExtenderNodes_ComponentEntitySync as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_LandscapeCanvas_Edit_DisabledNodeDuplication(self, request, workspace, editor, launcher_platform): - from .EditorScripts import Edit_DisabledNodeDuplication as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_LandscapeCanvas_Edit_UndoNodeDelete_SliceEntity(self, request, workspace, editor, launcher_platform): - from .EditorScripts import Edit_UndoNodeDelete_SliceEntity as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_LandscapeCanvas_NewGraph_CreatedSuccessfully(self, request, workspace, editor, launcher_platform): - from .EditorScripts import NewGraph_CreatedSuccessfully as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_LandscapeCanvas_Component_AddedRemoved(self, request, workspace, editor, launcher_platform): - from .EditorScripts import Component_AddedRemoved as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_LandscapeCanvas_GraphClosed_OnLevelChange(self, request, workspace, editor, launcher_platform): - from .EditorScripts import GraphClosed_OnLevelChange as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - @pytest.mark.xfail(reason="https://github.com/o3de/o3de/issues/2201") - def test_LandscapeCanvas_GraphClosed_OnEntityDelete(self, request, workspace, editor, launcher_platform): - from .EditorScripts import GraphClosed_OnEntityDelete as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_LandscapeCanvas_GraphClosed_TabbedGraphClosesIndependently(self, request, workspace, editor, launcher_platform): - from .EditorScripts import GraphClosed_TabbedGraph as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_LandscapeCanvas_Slice_CreateInstantiate(self, request, workspace, editor, remove_test_slice, launcher_platform): - from .EditorScripts import Slice_CreateInstantiate as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_LandscapeCanvas_GradientModifierNodes_EntityCreatedOnNodeAdd(self, request, workspace, editor, launcher_platform): - from .EditorScripts import GradientModifierNodes_EntityCreatedOnNodeAdd as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_LandscapeCanvas_GradientModifierNodes_EntityRemovedOnNodeDelete(self, request, workspace, editor, launcher_platform): - from .EditorScripts import GradientModifierNodes_EntityRemovedOnNodeDelete as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_LandscapeCanvas_GradientNodes_DependentComponentsAdded(self, request, workspace, editor, launcher_platform): - from .EditorScripts import GradientNodes_DependentComponentsAdded as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_LandscapeCanvas_GradientNodes_EntityCreatedOnNodeAdd(self, request, workspace, editor, launcher_platform): - from .EditorScripts import GradientNodes_EntityCreatedOnNodeAdd as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_LandscapeCanvas_GradientNodes_EntityRemovedOnNodeDelete(self, request, workspace, editor, launcher_platform): - from .EditorScripts import GradientNodes_EntityRemovedOnNodeDelete as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_LandscapeCanvas_GraphUpdates_UpdateComponents(self, request, workspace, editor, launcher_platform): - from .EditorScripts import GraphUpdates_UpdateComponents as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_LandscapeCanvas_ComponentUpdates_UpdateGraph(self, request, workspace, editor, launcher_platform): - from .EditorScripts import ComponentUpdates_UpdateGraph as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_LandscapeCanvas_LayerBlender_NodeConstruction(self, request, workspace, editor, launcher_platform): - from .EditorScripts import LayerBlender_NodeConstruction as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_LandscapeCanvas_ShapeNodes_EntityCreatedOnNodeAdd(self, request, workspace, editor, launcher_platform): - from .EditorScripts import ShapeNodes_EntityCreatedOnNodeAdd as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) - - def test_LandscapeCanvas_ShapeNodes_EntityRemovedOnNodeDelete(self, request, workspace, editor, launcher_platform): - from .EditorScripts import ShapeNodes_EntityRemovedOnNodeDelete as test_module - self._run_test(request, workspace, editor, test_module, enable_prefab_system=False) diff --git a/AutomatedTesting/Gem/PythonTests/largeworlds/large_worlds_utils/editor_dynveg_test_helper.py b/AutomatedTesting/Gem/PythonTests/largeworlds/large_worlds_utils/editor_dynveg_test_helper.py index 37afeff8c0..fd6a907b2e 100755 --- a/AutomatedTesting/Gem/PythonTests/largeworlds/large_worlds_utils/editor_dynveg_test_helper.py +++ b/AutomatedTesting/Gem/PythonTests/largeworlds/large_worlds_utils/editor_dynveg_test_helper.py @@ -114,7 +114,8 @@ def create_dynamic_slice_vegetation_area(name, center_point, box_size_x, box_siz return spawner_entity -def create_prefab_vegetation_area(name, center_point, box_size_x, box_size_y, box_size_z, target_prefab): +def create_temp_prefab_vegetation_area(name, center_point, box_size_x, box_size_y, box_size_z, target_prefab): + """Creates a vegetation area using in-memory prefabs. Use when test is solely contained to Editor""" # Create a vegetation area entity to use as our test vegetation spawner spawner_entity = hydra.Entity(name) spawner_entity.create_entity( @@ -148,6 +149,31 @@ def create_prefab_vegetation_area(name, center_point, box_size_x, box_size_y, bo return spawner_entity +def create_prefab_vegetation_area(name, center_point, box_size_x, box_size_y, box_size_z, prefab_path): + """Creates a vegetation area using on-disk spawnable prefabs. Use when test requires saving/loading in Launcher""" + # Create a vegetation area entity to use as our test vegetation spawner + prefab_asset_id = asset.AssetCatalogRequestBus(bus.Broadcast, "GetAssetIdByPath", prefab_path, math.Uuid(), + False) + spawner_entity = hydra.Entity(name) + spawner_entity.create_entity( + center_point, + ["Vegetation Layer Spawner", "Box Shape", "Vegetation Asset List"] + ) + if spawner_entity.id.IsValid(): + print(f"'{spawner_entity.name}' created") + spawner_entity.get_set_test(1, "Box Shape|Box Configuration|Dimensions", math.Vector3(box_size_x, box_size_y, + box_size_z)) + + # Set the vegetation area to a prefab instance spawner with a specific prefab asset selected + descriptor = hydra.get_component_property_value(spawner_entity.components[2], + 'Configuration|Embedded Assets|[0]') + prefab_spawner = vegetation.PrefabInstanceSpawner() + prefab_spawner.SetPrefabAssetId(prefab_asset_id) + descriptor.spawner = prefab_spawner + spawner_entity.get_set_test(2, "Configuration|Embedded Assets|[0]", descriptor) + return spawner_entity + + def create_blocker_area(name, center_point, box_size_x, box_size_y, box_size_z): # Create a Vegetation Layer Blocker area blocker_entity = hydra.Entity(name) @@ -162,6 +188,23 @@ def create_blocker_area(name, center_point, box_size_x, box_size_y, box_size_z): return blocker_entity +def create_empty_vegetation_area(name, center_point, box_size_x, box_size_y, box_size_z): + # Create a vegetation area entity to use as our test vegetation spawner + spawner_entity = EditorEntity.create_editor_entity_at(center_point, name=name) + spawner_entity.add_components(["Vegetation Layer Spawner", "Box Shape", "Vegetation Asset List"]) + if spawner_entity.id.IsValid(): + print(f"'{spawner_entity.get_name()}' created") + spawner_entity.components[1].set_component_property_value("Box Shape|Box Configuration|Dimensions", + math.Vector3(box_size_x, box_size_y, box_size_z)) + + # Set the vegetation area to an empty spawner + empty_spawner = vegetation.EmptyInstanceSpawner() + descriptor = spawner_entity.components[2].get_component_property_value("Configuration|Embedded Assets|[0]") + descriptor.spawner = empty_spawner + spawner_entity.components[2].set_component_property_value("Configuration|Embedded Assets|[0]", descriptor) + return spawner_entity + + def validate_instance_count(center, radius, num_expected): # Verify that we have the correct number of instances in the given area. This creates a bounding box based on a # sphere radius diff --git a/AutomatedTesting/Levels/Graphics/base_empty/base_empty.prefab b/AutomatedTesting/Levels/Graphics/base_empty/base_empty.prefab new file mode 100644 index 0000000000..f7e42e7731 --- /dev/null +++ b/AutomatedTesting/Levels/Graphics/base_empty/base_empty.prefab @@ -0,0 +1,53 @@ +{ + "ContainerEntity": { + "Id": "Entity_[1146574390643]", + "Name": "Level", + "Components": { + "Component_[10641544592923449938]": { + "$type": "EditorInspectorComponent", + "Id": 10641544592923449938 + }, + "Component_[12039882709170782873]": { + "$type": "EditorOnlyEntityComponent", + "Id": 12039882709170782873 + }, + "Component_[12265484671603697631]": { + "$type": "EditorPendingCompositionComponent", + "Id": 12265484671603697631 + }, + "Component_[14126657869720434043]": { + "$type": "EditorEntitySortComponent", + "Id": 14126657869720434043 + }, + "Component_[15230859088967841193]": { + "$type": "{27F1E1A1-8D9D-4C3B-BD3A-AFB9762449C0} TransformComponent", + "Id": 15230859088967841193, + "Parent Entity": "" + }, + "Component_[16239496886950819870]": { + "$type": "EditorDisabledCompositionComponent", + "Id": 16239496886950819870 + }, + "Component_[5688118765544765547]": { + "$type": "EditorEntityIconComponent", + "Id": 5688118765544765547 + }, + "Component_[6545738857812235305]": { + "$type": "SelectionComponent", + "Id": 6545738857812235305 + }, + "Component_[7247035804068349658]": { + "$type": "EditorPrefabComponent", + "Id": 7247035804068349658 + }, + "Component_[9307224322037797205]": { + "$type": "EditorLockComponent", + "Id": 9307224322037797205 + }, + "Component_[9562516168917670048]": { + "$type": "EditorVisibilityComponent", + "Id": 9562516168917670048 + } + } + } +} \ No newline at end of file diff --git a/AutomatedTesting/Levels/Graphics/base_empty/tags.txt b/AutomatedTesting/Levels/Graphics/base_empty/tags.txt new file mode 100644 index 0000000000..0d6c1880e7 --- /dev/null +++ b/AutomatedTesting/Levels/Graphics/base_empty/tags.txt @@ -0,0 +1,12 @@ +0,0,0,0,0,0 +0,0,0,0,0,0 +0,0,0,0,0,0 +0,0,0,0,0,0 +0,0,0,0,0,0 +0,0,0,0,0,0 +0,0,0,0,0,0 +0,0,0,0,0,0 +0,0,0,0,0,0 +0,0,0,0,0,0 +0,0,0,0,0,0 +0,0,0,0,0,0 diff --git a/AutomatedTesting/Levels/Multiplayer/SimpleNetworkLevelEntity/Player.prefab b/AutomatedTesting/Levels/Multiplayer/SimpleNetworkLevelEntity/Player.prefab new file mode 100644 index 0000000000..975319a516 --- /dev/null +++ b/AutomatedTesting/Levels/Multiplayer/SimpleNetworkLevelEntity/Player.prefab @@ -0,0 +1,151 @@ +{ + "ContainerEntity": { + "Id": "ContainerEntity", + "Name": "Player", + "Components": { + "Component_[10626669441604518614]": { + "$type": "EditorPrefabComponent", + "Id": 10626669441604518614 + }, + "Component_[15284109105474306026]": { + "$type": "EditorVisibilityComponent", + "Id": 15284109105474306026 + }, + "Component_[1884250773831675865]": { + "$type": "SelectionComponent", + "Id": 1884250773831675865 + }, + "Component_[3027124663594865592]": { + "$type": "EditorInspectorComponent", + "Id": 3027124663594865592 + }, + "Component_[3314300526416851038]": { + "$type": "EditorEntitySortComponent", + "Id": 3314300526416851038, + "Child Entity Order": [ + "Entity_[1340484004600]" + ] + }, + "Component_[5583377204116393478]": { + "$type": "EditorEntityIconComponent", + "Id": 5583377204116393478 + }, + "Component_[5897955848881060165]": { + "$type": "EditorLockComponent", + "Id": 5897955848881060165 + }, + "Component_[6405389103180201977]": { + "$type": "{27F1E1A1-8D9D-4C3B-BD3A-AFB9762449C0} TransformComponent", + "Id": 6405389103180201977, + "Parent Entity": "" + }, + "Component_[7695912346724202125]": { + "$type": "EditorDisabledCompositionComponent", + "Id": 7695912346724202125 + }, + "Component_[775363990560391238]": { + "$type": "EditorOnlyEntityComponent", + "Id": 775363990560391238 + }, + "Component_[904355854135646057]": { + "$type": "EditorPendingCompositionComponent", + "Id": 904355854135646057 + } + } + }, + "Entities": { + "Entity_[1340484004600]": { + "Id": "Entity_[1340484004600]", + "Name": "Player", + "Components": { + "Component_[12294726333564087591]": { + "$type": "SelectionComponent", + "Id": 12294726333564087591 + }, + "Component_[13587084088242540786]": { + "$type": "EditorInspectorComponent", + "Id": 13587084088242540786, + "ComponentOrderEntryArray": [ + { + "ComponentId": 6819443882832501114 + }, + { + "ComponentId": 4337571454344109612, + "SortIndex": 1 + }, + { + "ComponentId": 16457408099527309065, + "SortIndex": 2 + }, + { + "ComponentId": 5577505593558922067, + "SortIndex": 3 + } + ] + }, + "Component_[14335168881008289852]": { + "$type": "EditorEntitySortComponent", + "Id": 14335168881008289852 + }, + "Component_[16308902899170829847]": { + "$type": "EditorVisibilityComponent", + "Id": 16308902899170829847 + }, + "Component_[16457408099527309065]": { + "$type": "GenericComponentWrapper", + "Id": 16457408099527309065, + "m_template": { + "$type": "Multiplayer::NetworkTransformComponent" + } + }, + "Component_[16541569566865026527]": { + "$type": "EditorOnlyEntityComponent", + "Id": 16541569566865026527 + }, + "Component_[2002761223483048905]": { + "$type": "EditorPendingCompositionComponent", + "Id": 2002761223483048905 + }, + "Component_[4337571454344109612]": { + "$type": "GenericComponentWrapper", + "Id": 4337571454344109612, + "m_template": { + "$type": "NetBindComponent" + } + }, + "Component_[477591477979440744]": { + "$type": "EditorLockComponent", + "Id": 477591477979440744 + }, + "Component_[5577505593558922067]": { + "$type": "AZ::Render::EditorMeshComponent", + "Id": 5577505593558922067, + "Controller": { + "Configuration": { + "ModelAsset": { + "assetId": { + "guid": "{6DE0E9A8-A1C7-5D0F-9407-4E627C1F223C}", + "subId": 284780167 + }, + "assetHint": "models/sphere.azmodel" + } + } + } + }, + "Component_[5828214869455694702]": { + "$type": "EditorDisabledCompositionComponent", + "Id": 5828214869455694702 + }, + "Component_[6819443882832501114]": { + "$type": "{27F1E1A1-8D9D-4C3B-BD3A-AFB9762449C0} TransformComponent", + "Id": 6819443882832501114, + "Parent Entity": "ContainerEntity" + }, + "Component_[8838623765985560328]": { + "$type": "EditorEntityIconComponent", + "Id": 8838623765985560328 + } + } + } + } +} \ No newline at end of file diff --git a/AutomatedTesting/Levels/Multiplayer/SimpleNetworkLevelEntity/SimpleNetworkLevelEntity.prefab b/AutomatedTesting/Levels/Multiplayer/SimpleNetworkLevelEntity/SimpleNetworkLevelEntity.prefab new file mode 100644 index 0000000000..abe458246a --- /dev/null +++ b/AutomatedTesting/Levels/Multiplayer/SimpleNetworkLevelEntity/SimpleNetworkLevelEntity.prefab @@ -0,0 +1,580 @@ +{ + "ContainerEntity": { + "Id": "Entity_[1146574390643]", + "Name": "Level", + "Components": { + "Component_[10641544592923449938]": { + "$type": "EditorInspectorComponent", + "Id": 10641544592923449938 + }, + "Component_[12039882709170782873]": { + "$type": "EditorOnlyEntityComponent", + "Id": 12039882709170782873 + }, + "Component_[12265484671603697631]": { + "$type": "EditorPendingCompositionComponent", + "Id": 12265484671603697631 + }, + "Component_[14126657869720434043]": { + "$type": "EditorEntitySortComponent", + "Id": 14126657869720434043, + "Child Entity Order": [ + "Entity_[1176639161715]", + "Entity_[806656324666]" + ] + }, + "Component_[15230859088967841193]": { + "$type": "{27F1E1A1-8D9D-4C3B-BD3A-AFB9762449C0} TransformComponent", + "Id": 15230859088967841193, + "Parent Entity": "" + }, + "Component_[16239496886950819870]": { + "$type": "EditorDisabledCompositionComponent", + "Id": 16239496886950819870 + }, + "Component_[5688118765544765547]": { + "$type": "EditorEntityIconComponent", + "Id": 5688118765544765547 + }, + "Component_[6545738857812235305]": { + "$type": "SelectionComponent", + "Id": 6545738857812235305 + }, + "Component_[7247035804068349658]": { + "$type": "EditorPrefabComponent", + "Id": 7247035804068349658 + }, + "Component_[9307224322037797205]": { + "$type": "EditorLockComponent", + "Id": 9307224322037797205 + }, + "Component_[9562516168917670048]": { + "$type": "EditorVisibilityComponent", + "Id": 9562516168917670048 + } + } + }, + "Entities": { + "Entity_[1155164325235]": { + "Id": "Entity_[1155164325235]", + "Name": "Sun", + "Components": { + "Component_[10440557478882592717]": { + "$type": "SelectionComponent", + "Id": 10440557478882592717 + }, + "Component_[13620450453324765907]": { + "$type": "EditorLockComponent", + "Id": 13620450453324765907 + }, + "Component_[2134313378593666258]": { + "$type": "EditorInspectorComponent", + "Id": 2134313378593666258 + }, + "Component_[234010807770404186]": { + "$type": "EditorVisibilityComponent", + "Id": 234010807770404186 + }, + "Component_[2970359110423865725]": { + "$type": "EditorEntityIconComponent", + "Id": 2970359110423865725 + }, + "Component_[3722854130373041803]": { + "$type": "EditorOnlyEntityComponent", + "Id": 3722854130373041803 + }, + "Component_[5992533738676323195]": { + "$type": "EditorDisabledCompositionComponent", + "Id": 5992533738676323195 + }, + "Component_[7378860763541895402]": { + "$type": "AZ::Render::EditorDirectionalLightComponent", + "Id": 7378860763541895402, + "Controller": { + "Configuration": { + "Intensity": 1.0, + "CameraEntityId": "", + "ShadowFilterMethod": 1 + } + } + }, + "Component_[7892834440890947578]": { + "$type": "{27F1E1A1-8D9D-4C3B-BD3A-AFB9762449C0} TransformComponent", + "Id": 7892834440890947578, + "Parent Entity": "Entity_[1176639161715]", + "Transform Data": { + "Translate": [ + 0.0, + 0.0, + 13.487043380737305 + ], + "Rotate": [ + -76.13099670410156, + -0.847000002861023, + -15.8100004196167 + ] + } + }, + "Component_[8599729549570828259]": { + "$type": "EditorEntitySortComponent", + "Id": 8599729549570828259 + }, + "Component_[952797371922080273]": { + "$type": "EditorPendingCompositionComponent", + "Id": 952797371922080273 + } + } + }, + "Entity_[1159459292531]": { + "Id": "Entity_[1159459292531]", + "Name": "Ground", + "Components": { + "Component_[11701138785793981042]": { + "$type": "SelectionComponent", + "Id": 11701138785793981042 + }, + "Component_[12260880513256986252]": { + "$type": "EditorEntityIconComponent", + "Id": 12260880513256986252 + }, + "Component_[13711420870643673468]": { + "$type": "EditorDisabledCompositionComponent", + "Id": 13711420870643673468 + }, + "Component_[138002849734991713]": { + "$type": "EditorOnlyEntityComponent", + "Id": 138002849734991713 + }, + "Component_[16578565737331764849]": { + "$type": "{27F1E1A1-8D9D-4C3B-BD3A-AFB9762449C0} TransformComponent", + "Id": 16578565737331764849, + "Parent Entity": "Entity_[1176639161715]" + }, + "Component_[16919232076966545697]": { + "$type": "EditorInspectorComponent", + "Id": 16919232076966545697 + }, + "Component_[5182430712893438093]": { + "$type": "EditorMaterialComponent", + "Id": 5182430712893438093 + }, + "Component_[5675108321710651991]": { + "$type": "AZ::Render::EditorMeshComponent", + "Id": 5675108321710651991, + "Controller": { + "Configuration": { + "ModelAsset": { + "assetId": { + "guid": "{0CD745C0-6AA8-569A-A68A-73A3270986C4}", + "subId": 277889906 + }, + "assetHint": "objects/groudplane/groundplane_512x512m.azmodel" + } + } + } + }, + "Component_[5681893399601237518]": { + "$type": "EditorEntitySortComponent", + "Id": 5681893399601237518 + }, + "Component_[592692962543397545]": { + "$type": "EditorPendingCompositionComponent", + "Id": 592692962543397545 + }, + "Component_[7090012899106946164]": { + "$type": "EditorLockComponent", + "Id": 7090012899106946164 + }, + "Component_[9410832619875640998]": { + "$type": "EditorVisibilityComponent", + "Id": 9410832619875640998 + } + } + }, + "Entity_[1163754259827]": { + "Id": "Entity_[1163754259827]", + "Name": "Camera", + "Components": { + "Component_[11895140916889160460]": { + "$type": "EditorEntityIconComponent", + "Id": 11895140916889160460 + }, + "Component_[16880285896855930892]": { + "$type": "{CA11DA46-29FF-4083-B5F6-E02C3A8C3A3D} EditorCameraComponent", + "Id": 16880285896855930892, + "Controller": { + "Configuration": { + "Field of View": 55.0, + "EditorEntityId": 9021008456353177945 + } + } + }, + "Component_[17187464423780271193]": { + "$type": "EditorLockComponent", + "Id": 17187464423780271193 + }, + "Component_[17495696818315413311]": { + "$type": "EditorEntitySortComponent", + "Id": 17495696818315413311 + }, + "Component_[18086214374043522055]": { + "$type": "{27F1E1A1-8D9D-4C3B-BD3A-AFB9762449C0} TransformComponent", + "Id": 18086214374043522055, + "Parent Entity": "Entity_[1176639161715]", + "Transform Data": { + "Translate": [ + -2.3000001907348633, + -3.9368600845336914, + 1.0 + ], + "Rotate": [ + -2.050307512283325, + 1.9552897214889526, + -43.623355865478516 + ] + } + }, + "Component_[18387556550380114975]": { + "$type": "SelectionComponent", + "Id": 18387556550380114975 + }, + "Component_[2654521436129313160]": { + "$type": "EditorVisibilityComponent", + "Id": 2654521436129313160 + }, + "Component_[5265045084611556958]": { + "$type": "EditorDisabledCompositionComponent", + "Id": 5265045084611556958 + }, + "Component_[7169798125182238623]": { + "$type": "EditorPendingCompositionComponent", + "Id": 7169798125182238623 + }, + "Component_[7255796294953281766]": { + "$type": "GenericComponentWrapper", + "Id": 7255796294953281766, + "m_template": { + "$type": "FlyCameraInputComponent" + } + }, + "Component_[8866210352157164042]": { + "$type": "EditorInspectorComponent", + "Id": 8866210352157164042 + }, + "Component_[9129253381063760879]": { + "$type": "EditorOnlyEntityComponent", + "Id": 9129253381063760879 + } + } + }, + "Entity_[1168049227123]": { + "Id": "Entity_[1168049227123]", + "Name": "Grid", + "Components": { + "Component_[11443347433215807130]": { + "$type": "EditorEntityIconComponent", + "Id": 11443347433215807130 + }, + "Component_[11779275529534764488]": { + "$type": "SelectionComponent", + "Id": 11779275529534764488 + }, + "Component_[14249419413039427459]": { + "$type": "EditorInspectorComponent", + "Id": 14249419413039427459 + }, + "Component_[15448581635946161318]": { + "$type": "AZ::Render::EditorGridComponent", + "Id": 15448581635946161318, + "Controller": { + "Configuration": { + "primarySpacing": 4.0, + "primaryColor": [ + 0.501960813999176, + 0.501960813999176, + 0.501960813999176 + ], + "secondarySpacing": 0.5, + "secondaryColor": [ + 0.250980406999588, + 0.250980406999588, + 0.250980406999588 + ] + } + } + }, + "Component_[1843303322527297409]": { + "$type": "EditorDisabledCompositionComponent", + "Id": 1843303322527297409 + }, + "Component_[380249072065273654]": { + "$type": "{27F1E1A1-8D9D-4C3B-BD3A-AFB9762449C0} TransformComponent", + "Id": 380249072065273654, + "Parent Entity": "Entity_[1176639161715]" + }, + "Component_[7476660583684339787]": { + "$type": "EditorPendingCompositionComponent", + "Id": 7476660583684339787 + }, + "Component_[7557626501215118375]": { + "$type": "EditorEntitySortComponent", + "Id": 7557626501215118375 + }, + "Component_[7984048488947365511]": { + "$type": "EditorVisibilityComponent", + "Id": 7984048488947365511 + }, + "Component_[8118181039276487398]": { + "$type": "EditorOnlyEntityComponent", + "Id": 8118181039276487398 + }, + "Component_[9189909764215270515]": { + "$type": "EditorLockComponent", + "Id": 9189909764215270515 + } + } + }, + "Entity_[1176639161715]": { + "Id": "Entity_[1176639161715]", + "Name": "Atom Default Environment", + "Components": { + "Component_[10757302973393310045]": { + "$type": "{27F1E1A1-8D9D-4C3B-BD3A-AFB9762449C0} TransformComponent", + "Id": 10757302973393310045, + "Parent Entity": "Entity_[1146574390643]" + }, + "Component_[14505817420424255464]": { + "$type": "EditorInspectorComponent", + "Id": 14505817420424255464, + "ComponentOrderEntryArray": [ + { + "ComponentId": 10757302973393310045 + } + ] + }, + "Component_[14988041764659020032]": { + "$type": "EditorLockComponent", + "Id": 14988041764659020032 + }, + "Component_[15808690248755038124]": { + "$type": "SelectionComponent", + "Id": 15808690248755038124 + }, + "Component_[15900837685796817138]": { + "$type": "EditorVisibilityComponent", + "Id": 15900837685796817138 + }, + "Component_[3298767348226484884]": { + "$type": "EditorOnlyEntityComponent", + "Id": 3298767348226484884 + }, + "Component_[4076975109609220594]": { + "$type": "EditorPendingCompositionComponent", + "Id": 4076975109609220594 + }, + "Component_[5679760548946028854]": { + "$type": "EditorDisabledCompositionComponent", + "Id": 5679760548946028854 + }, + "Component_[5855590796136709437]": { + "$type": "EditorEntitySortComponent", + "Id": 5855590796136709437, + "Child Entity Order": [ + "Entity_[1155164325235]", + "Entity_[1180934129011]", + "Entity_[1168049227123]", + "Entity_[1163754259827]", + "Entity_[1159459292531]" + ] + }, + "Component_[9277695270015777859]": { + "$type": "EditorEntityIconComponent", + "Id": 9277695270015777859 + } + } + }, + "Entity_[1180934129011]": { + "Id": "Entity_[1180934129011]", + "Name": "Global Sky", + "Components": { + "Component_[11231930600558681245]": { + "$type": "AZ::Render::EditorHDRiSkyboxComponent", + "Id": 11231930600558681245, + "Controller": { + "Configuration": { + "CubemapAsset": { + "assetId": { + "guid": "{215E47FD-D181-5832-B1AB-91673ABF6399}", + "subId": 1000 + }, + "assetHint": "lightingpresets/highcontrast/goegap_4k_skyboxcm.exr.streamingimage" + } + } + } + }, + "Component_[11980494120202836095]": { + "$type": "SelectionComponent", + "Id": 11980494120202836095 + }, + "Component_[1428633914413949476]": { + "$type": "EditorLockComponent", + "Id": 1428633914413949476 + }, + "Component_[14936200426671614999]": { + "$type": "AZ::Render::EditorImageBasedLightComponent", + "Id": 14936200426671614999, + "Controller": { + "Configuration": { + "diffuseImageAsset": { + "assetId": { + "guid": "{3FD09945-D0F2-55C8-B9AF-B2FD421FE3BE}", + "subId": 3000 + }, + "assetHint": "lightingpresets/highcontrast/goegap_4k_iblglobalcm_ibldiffuse.exr.streamingimage" + }, + "specularImageAsset": { + "assetId": { + "guid": "{3FD09945-D0F2-55C8-B9AF-B2FD421FE3BE}", + "subId": 2000 + }, + "assetHint": "lightingpresets/highcontrast/goegap_4k_iblglobalcm_iblspecular.exr.streamingimage" + } + } + } + }, + "Component_[14994774102579326069]": { + "$type": "EditorDisabledCompositionComponent", + "Id": 14994774102579326069 + }, + "Component_[15417479889044493340]": { + "$type": "EditorPendingCompositionComponent", + "Id": 15417479889044493340 + }, + "Component_[15826613364991382688]": { + "$type": "EditorEntitySortComponent", + "Id": 15826613364991382688 + }, + "Component_[1665003113283562343]": { + "$type": "EditorOnlyEntityComponent", + "Id": 1665003113283562343 + }, + "Component_[3704934735944502280]": { + "$type": "EditorEntityIconComponent", + "Id": 3704934735944502280 + }, + "Component_[5698542331457326479]": { + "$type": "EditorVisibilityComponent", + "Id": 5698542331457326479 + }, + "Component_[6644513399057217122]": { + "$type": "{27F1E1A1-8D9D-4C3B-BD3A-AFB9762449C0} TransformComponent", + "Id": 6644513399057217122, + "Parent Entity": "Entity_[1176639161715]" + }, + "Component_[931091830724002070]": { + "$type": "EditorInspectorComponent", + "Id": 931091830724002070 + } + } + }, + "Entity_[806656324666]": { + "Id": "Entity_[806656324666]", + "Name": "NetEntity", + "Components": { + "Component_[10272449525230713408]": { + "$type": "EditorScriptCanvasComponent", + "Id": 10272449525230713408, + "m_name": "SimpleNetworkLevelEntity.scriptcanvas", + "runtimeDataIsValid": true, + "runtimeDataOverrides": { + "source": { + "id": "{C8F17F94-1225-5FFB-A89F-7C5546FF9DD2}", + "path": "C:/prj/o3de/AutomatedTesting/Levels/Multiplayer/SimpleNetworkLevelEntity/SimpleNetworkLevelEntity.scriptcanvas" + } + }, + "sourceHandle": { + "id": "{C8F17F94-1225-5FFB-A89F-7C5546FF9DD2}", + "path": "C:/prj/o3de/AutomatedTesting/Levels/Multiplayer/SimpleNetworkLevelEntity/SimpleNetworkLevelEntity.scriptcanvas" + } + }, + "Component_[12604265186664827718]": { + "$type": "EditorDisabledCompositionComponent", + "Id": 12604265186664827718 + }, + "Component_[12971088454284742740]": { + "$type": "EditorInspectorComponent", + "Id": 12971088454284742740 + }, + "Component_[13637345797899267673]": { + "$type": "EditorPendingCompositionComponent", + "Id": 13637345797899267673 + }, + "Component_[14691827217729577086]": { + "$type": "EditorVisibilityComponent", + "Id": 14691827217729577086 + }, + "Component_[17587769654029626028]": { + "$type": "AZ::Render::EditorMeshComponent", + "Id": 17587769654029626028, + "Controller": { + "Configuration": { + "ModelAsset": { + "assetId": { + "guid": "{6DE0E9A8-A1C7-5D0F-9407-4E627C1F223C}", + "subId": 284780167 + }, + "assetHint": "models/sphere.azmodel" + } + } + } + }, + "Component_[3583806849894952953]": { + "$type": "EditorOnlyEntityComponent", + "Id": 3583806849894952953 + }, + "Component_[3992057042487734240]": { + "$type": "EditorLockComponent", + "Id": 3992057042487734240 + }, + "Component_[4205899043279271481]": { + "$type": "GenericComponentWrapper", + "Id": 4205899043279271481, + "m_template": { + "$type": "Multiplayer::NetworkTransformComponent" + } + }, + "Component_[4416976521140638764]": { + "$type": "EditorEntityIconComponent", + "Id": 4416976521140638764 + }, + "Component_[4951162661196722987]": { + "$type": "EditorEntitySortComponent", + "Id": 4951162661196722987 + }, + "Component_[57491843687005111]": { + "$type": "{27F1E1A1-8D9D-4C3B-BD3A-AFB9762449C0} TransformComponent", + "Id": 57491843687005111, + "Parent Entity": "Entity_[1146574390643]", + "Transform Data": { + "Translate": [ + -0.010266244411468506, + 0.09999752044677734, + 0.4922151565551758 + ] + } + }, + "Component_[7427201282284088219]": { + "$type": "SelectionComponent", + "Id": 7427201282284088219 + }, + "Component_[9767802049284917261]": { + "$type": "GenericComponentWrapper", + "Id": 9767802049284917261, + "m_template": { + "$type": "NetBindComponent" + } + } + } + } + } +} \ No newline at end of file diff --git a/AutomatedTesting/Levels/Multiplayer/SimpleNetworkLevelEntity/SimpleNetworkLevelEntity.scriptcanvas b/AutomatedTesting/Levels/Multiplayer/SimpleNetworkLevelEntity/SimpleNetworkLevelEntity.scriptcanvas new file mode 100644 index 0000000000..7f41ed9af2 --- /dev/null +++ b/AutomatedTesting/Levels/Multiplayer/SimpleNetworkLevelEntity/SimpleNetworkLevelEntity.scriptcanvas @@ -0,0 +1,228 @@ +{ + "Type": "JsonSerialization", + "Version": 1, + "ClassName": "ScriptCanvasData", + "ClassData": { + "m_scriptCanvas": { + "Id": { + "id": 5227099818161821361 + }, + "Name": "Script Canvas Graph", + "Components": { + "Component_[14745706451564425001]": { + "$type": "EditorGraphVariableManagerComponent", + "Id": 14745706451564425001 + }, + "Component_[6188351434280490877]": { + "$type": "EditorGraph", + "Id": 6188351434280490877, + "m_graphData": { + "m_nodes": [ + { + "Id": { + "id": 1181151842701 + }, + "Name": "SC-Node(Print)", + "Components": { + "Component_[11204048151736284490]": { + "$type": "Print", + "Id": 11204048151736284490, + "Slots": [ + { + "id": { + "m_id": "{A417FF98-493E-4DE6-AD3A-E7A1848661E4}" + }, + "contracts": [ + { + "$type": "SlotTypeContract" + } + ], + "slotName": "In", + "toolTip": "Input signal", + "Descriptor": { + "ConnectionType": 1, + "SlotType": 1 + } + }, + { + "id": { + "m_id": "{38BC2AB1-7654-407E-9903-4B5D77EDB6F3}" + }, + "contracts": [ + { + "$type": "SlotTypeContract" + } + ], + "slotName": "Out", + "Descriptor": { + "ConnectionType": 2, + "SlotType": 1 + } + } + ], + "m_format": "SimpleNetworkLevelEntity: On Graph Start\n", + "m_unresolvedString": [ + "SimpleNetworkLevelEntity: On Graph Start\n" + ] + } + } + }, + { + "Id": { + "id": 811784655245 + }, + "Name": "SC-Node(Start)", + "Components": { + "Component_[2986280341871382503]": { + "$type": "Start", + "Id": 2986280341871382503, + "Slots": [ + { + "id": { + "m_id": "{61FBEFC6-23BA-4A53-89BF-D0D0E834608C}" + }, + "contracts": [ + { + "$type": "SlotTypeContract" + } + ], + "slotName": "Out", + "toolTip": "Signaled when the entity that owns this graph is fully activated.", + "Descriptor": { + "ConnectionType": 2, + "SlotType": 1 + } + } + ] + } + } + } + ], + "m_connections": [ + { + "Id": { + "id": 2521181639053 + }, + "Name": "srcEndpoint=(On Graph Start: Out), destEndpoint=(Print: In)", + "Components": { + "Component_[16295428600276205051]": { + "$type": "{64CA5016-E803-4AC4-9A36-BDA2C890C6EB} Connection", + "Id": 16295428600276205051, + "sourceEndpoint": { + "nodeId": { + "id": 811784655245 + }, + "slotId": { + "m_id": "{61FBEFC6-23BA-4A53-89BF-D0D0E834608C}" + } + }, + "targetEndpoint": { + "nodeId": { + "id": 1181151842701 + }, + "slotId": { + "m_id": "{A417FF98-493E-4DE6-AD3A-E7A1848661E4}" + } + } + } + } + } + ] + }, + "m_assetType": "{00000000-0000-0000-D033-B2489A010000}", + "versionData": { + "_grammarVersion": 1, + "_runtimeVersion": 1, + "_fileVersion": 1 + }, + "GraphCanvasData": [ + { + "Key": { + "id": 811784655245 + }, + "Value": { + "ComponentData": { + "{24CB38BB-1705-4EC5-8F63-B574571B4DCD}": { + "$type": "NodeSaveData" + }, + "{328FF15C-C302-458F-A43D-E1794DE0904E}": { + "$type": "GeneralNodeTitleComponentSaveData", + "PaletteOverride": "TimeNodeTitlePalette" + }, + "{7CC444B1-F9B3-41B5-841B-0C4F2179F111}": { + "$type": "GeometrySaveData", + "Position": [ + 340.0, + 180.0 + ] + }, + "{B0B99C8A-03AF-4CF6-A926-F65C874C3D97}": { + "$type": "StylingComponentSaveData" + }, + "{B1F49A35-8408-40DA-B79E-F1E3B64322CE}": { + "$type": "PersistentIdComponentSaveData", + "PersistentId": "{6045F7F7-02B0-442A-96C7-A0CBCEFF7275}" + } + } + } + }, + { + "Key": { + "id": 1181151842701 + }, + "Value": { + "ComponentData": { + "{24CB38BB-1705-4EC5-8F63-B574571B4DCD}": { + "$type": "NodeSaveData" + }, + "{328FF15C-C302-458F-A43D-E1794DE0904E}": { + "$type": "GeneralNodeTitleComponentSaveData", + "PaletteOverride": "StringNodeTitlePalette" + }, + "{7CC444B1-F9B3-41B5-841B-0C4F2179F111}": { + "$type": "GeometrySaveData", + "Position": [ + 580.0, + 180.0 + ] + }, + "{B0B99C8A-03AF-4CF6-A926-F65C874C3D97}": { + "$type": "StylingComponentSaveData" + }, + "{B1F49A35-8408-40DA-B79E-F1E3B64322CE}": { + "$type": "PersistentIdComponentSaveData", + "PersistentId": "{589F773E-D82A-4EDD-AEBD-3ADC07FC67CE}" + } + } + } + }, + { + "Key": { + "id": 5227099818161821361 + }, + "Value": { + "ComponentData": { + "{5F84B500-8C45-40D1-8EFC-A5306B241444}": { + "$type": "SceneComponentSaveData" + } + } + } + } + ], + "StatisticsHelper": { + "InstanceCounter": [ + { + "Key": 4199610336680704683, + "Value": 1 + }, + { + "Key": 10684225535275896474, + "Value": 1 + } + ] + } + } + } + } + } +} \ No newline at end of file diff --git a/AutomatedTesting/Levels/Multiplayer/SimpleNetworkLevelEntity/tags.txt b/AutomatedTesting/Levels/Multiplayer/SimpleNetworkLevelEntity/tags.txt new file mode 100644 index 0000000000..0d6c1880e7 --- /dev/null +++ b/AutomatedTesting/Levels/Multiplayer/SimpleNetworkLevelEntity/tags.txt @@ -0,0 +1,12 @@ +0,0,0,0,0,0 +0,0,0,0,0,0 +0,0,0,0,0,0 +0,0,0,0,0,0 +0,0,0,0,0,0 +0,0,0,0,0,0 +0,0,0,0,0,0 +0,0,0,0,0,0 +0,0,0,0,0,0 +0,0,0,0,0,0 +0,0,0,0,0,0 +0,0,0,0,0,0 diff --git a/Gems/ScriptCanvas/Assets/TranslationAssets/AZEvents/AuthorityToAutonomousNoParamsNotifyEvent.names b/AutomatedTesting/ScriptCanvas/TranslationAssets/AZEvents/AuthorityToAutonomousNoParamsNotifyEvent.names similarity index 100% rename from Gems/ScriptCanvas/Assets/TranslationAssets/AZEvents/AuthorityToAutonomousNoParamsNotifyEvent.names rename to AutomatedTesting/ScriptCanvas/TranslationAssets/AZEvents/AuthorityToAutonomousNoParamsNotifyEvent.names diff --git a/Gems/ScriptCanvas/Assets/TranslationAssets/AZEvents/AuthorityToAutonomousNotifyEvent.names b/AutomatedTesting/ScriptCanvas/TranslationAssets/AZEvents/AuthorityToAutonomousNotifyEvent.names similarity index 100% rename from Gems/ScriptCanvas/Assets/TranslationAssets/AZEvents/AuthorityToAutonomousNotifyEvent.names rename to AutomatedTesting/ScriptCanvas/TranslationAssets/AZEvents/AuthorityToAutonomousNotifyEvent.names diff --git a/AutomatedTesting/ScriptCanvas/TranslationAssets/AZEvents/AuthorityToAutonomous_PlayerNumberNotifyEvent.names b/AutomatedTesting/ScriptCanvas/TranslationAssets/AZEvents/AuthorityToAutonomous_PlayerNumberNotifyEvent.names new file mode 100644 index 0000000000..7255c61d23 --- /dev/null +++ b/AutomatedTesting/ScriptCanvas/TranslationAssets/AZEvents/AuthorityToAutonomous_PlayerNumberNotifyEvent.names @@ -0,0 +1,56 @@ +{ + "entries": [ + { + "base": "AuthorityToAutonomous_PlayerNumber Notify Event", + "context": "AZEventHandler", + "variant": "", + "details": { + "name": "Authority To Autonomous_ Player Number Notify Event" + }, + "slots": [ + { + "base": "player_number", + "details": { + "name": "player_number" + } + }, + { + "base": "AuthorityToAutonomous_PlayerNumber Notify Event", + "details": { + "name": "AuthorityToAutonomous_PlayerNumber Notify Event" + } + }, + { + "base": "Connect", + "details": { + "name": "Connect" + } + }, + { + "base": "Disconnect", + "details": { + "name": "Disconnect" + } + }, + { + "base": "On Connected", + "details": { + "name": "On Connected" + } + }, + { + "base": "On Disconnected", + "details": { + "name": "On Disconnected" + } + }, + { + "base": "OnEvent", + "details": { + "name": "OnEvent" + } + } + ] + } + ] +} \ No newline at end of file diff --git a/Gems/ScriptCanvas/Assets/TranslationAssets/AZEvents/AuthorityToClientNoParamsNotifyEvent.names b/AutomatedTesting/ScriptCanvas/TranslationAssets/AZEvents/AuthorityToClientNoParamsNotifyEvent.names similarity index 100% rename from Gems/ScriptCanvas/Assets/TranslationAssets/AZEvents/AuthorityToClientNoParamsNotifyEvent.names rename to AutomatedTesting/ScriptCanvas/TranslationAssets/AZEvents/AuthorityToClientNoParamsNotifyEvent.names diff --git a/AutomatedTesting/ScriptCanvas/TranslationAssets/AZEvents/AuthorityToClientNoParams_PlayFxNotifyEvent.names b/AutomatedTesting/ScriptCanvas/TranslationAssets/AZEvents/AuthorityToClientNoParams_PlayFxNotifyEvent.names new file mode 100644 index 0000000000..3e0207a705 --- /dev/null +++ b/AutomatedTesting/ScriptCanvas/TranslationAssets/AZEvents/AuthorityToClientNoParams_PlayFxNotifyEvent.names @@ -0,0 +1,50 @@ +{ + "entries": [ + { + "base": "AuthorityToClientNoParams_PlayFx Notify Event", + "context": "AZEventHandler", + "variant": "", + "details": { + "name": "Authority To Client No Params_ Play Fx Notify Event" + }, + "slots": [ + { + "base": "AuthorityToClientNoParams_PlayFx Notify Event", + "details": { + "name": "AuthorityToClientNoParams_PlayFx Notify Event" + } + }, + { + "base": "Connect", + "details": { + "name": "Connect" + } + }, + { + "base": "Disconnect", + "details": { + "name": "Disconnect" + } + }, + { + "base": "On Connected", + "details": { + "name": "On Connected" + } + }, + { + "base": "On Disconnected", + "details": { + "name": "On Disconnected" + } + }, + { + "base": "OnEvent", + "details": { + "name": "OnEvent" + } + } + ] + } + ] +} \ No newline at end of file diff --git a/Gems/ScriptCanvas/Assets/TranslationAssets/AZEvents/AuthorityToClientNotifyEvent.names b/AutomatedTesting/ScriptCanvas/TranslationAssets/AZEvents/AuthorityToClientNotifyEvent.names similarity index 100% rename from Gems/ScriptCanvas/Assets/TranslationAssets/AZEvents/AuthorityToClientNotifyEvent.names rename to AutomatedTesting/ScriptCanvas/TranslationAssets/AZEvents/AuthorityToClientNotifyEvent.names diff --git a/Gems/ScriptCanvas/Assets/TranslationAssets/AZEvents/AutonomousToAuthorityNoParamsNotifyEvent.names b/AutomatedTesting/ScriptCanvas/TranslationAssets/AZEvents/AutonomousToAuthorityNoParamsNotifyEvent.names similarity index 100% rename from Gems/ScriptCanvas/Assets/TranslationAssets/AZEvents/AutonomousToAuthorityNoParamsNotifyEvent.names rename to AutomatedTesting/ScriptCanvas/TranslationAssets/AZEvents/AutonomousToAuthorityNoParamsNotifyEvent.names diff --git a/Gems/ScriptCanvas/Assets/TranslationAssets/AZEvents/AutonomousToAuthorityNotifyEvent.names b/AutomatedTesting/ScriptCanvas/TranslationAssets/AZEvents/AutonomousToAuthorityNotifyEvent.names similarity index 100% rename from Gems/ScriptCanvas/Assets/TranslationAssets/AZEvents/AutonomousToAuthorityNotifyEvent.names rename to AutomatedTesting/ScriptCanvas/TranslationAssets/AZEvents/AutonomousToAuthorityNotifyEvent.names diff --git a/Gems/ScriptCanvas/Assets/TranslationAssets/AZEvents/ServerToAuthorityNoParamNotifyEvent.names b/AutomatedTesting/ScriptCanvas/TranslationAssets/AZEvents/ServerToAuthorityNoParamNotifyEvent.names similarity index 100% rename from Gems/ScriptCanvas/Assets/TranslationAssets/AZEvents/ServerToAuthorityNoParamNotifyEvent.names rename to AutomatedTesting/ScriptCanvas/TranslationAssets/AZEvents/ServerToAuthorityNoParamNotifyEvent.names diff --git a/Gems/ScriptCanvas/Assets/TranslationAssets/AZEvents/ServerToAuthorityNotifyEvent.names b/AutomatedTesting/ScriptCanvas/TranslationAssets/AZEvents/ServerToAuthorityNotifyEvent.names similarity index 100% rename from Gems/ScriptCanvas/Assets/TranslationAssets/AZEvents/ServerToAuthorityNotifyEvent.names rename to AutomatedTesting/ScriptCanvas/TranslationAssets/AZEvents/ServerToAuthorityNotifyEvent.names diff --git a/AutomatedTesting/ScriptCanvas/TranslationAssets/AZEvents/ServerToAuthority_DealDamageNotifyEvent.names b/AutomatedTesting/ScriptCanvas/TranslationAssets/AZEvents/ServerToAuthority_DealDamageNotifyEvent.names new file mode 100644 index 0000000000..2505d9593a --- /dev/null +++ b/AutomatedTesting/ScriptCanvas/TranslationAssets/AZEvents/ServerToAuthority_DealDamageNotifyEvent.names @@ -0,0 +1,56 @@ +{ + "entries": [ + { + "base": "ServerToAuthority_DealDamage Notify Event", + "context": "AZEventHandler", + "variant": "", + "details": { + "name": "Server To Authority_ Deal Damage Notify Event" + }, + "slots": [ + { + "base": "damage", + "details": { + "name": "damage" + } + }, + { + "base": "ServerToAuthority_DealDamage Notify Event", + "details": { + "name": "ServerToAuthority_DealDamage Notify Event" + } + }, + { + "base": "Connect", + "details": { + "name": "Connect" + } + }, + { + "base": "Disconnect", + "details": { + "name": "Disconnect" + } + }, + { + "base": "On Connected", + "details": { + "name": "On Connected" + } + }, + { + "base": "On Disconnected", + "details": { + "name": "On Disconnected" + } + }, + { + "base": "OnEvent", + "details": { + "name": "OnEvent" + } + } + ] + } + ] +} \ No newline at end of file diff --git a/Gems/ScriptCanvas/Assets/TranslationAssets/Classes/NetworkTestPlayerComponent.names b/AutomatedTesting/ScriptCanvas/TranslationAssets/Classes/NetworkTestPlayerComponent.names similarity index 90% rename from Gems/ScriptCanvas/Assets/TranslationAssets/Classes/NetworkTestPlayerComponent.names rename to AutomatedTesting/ScriptCanvas/TranslationAssets/Classes/NetworkTestPlayerComponent.names index 22636e0453..03e949f784 100644 --- a/Gems/ScriptCanvas/Assets/TranslationAssets/Classes/NetworkTestPlayerComponent.names +++ b/AutomatedTesting/ScriptCanvas/TranslationAssets/Classes/NetworkTestPlayerComponent.names @@ -8,64 +8,6 @@ "name": "Network Test Player Component" }, "methods": [ - { - "base": "AutonomousToAuthority", - "context": "NetworkTestPlayerComponent", - "entry": { - "name": "In", - "tooltip": "When signaled, this will invoke Autonomous To Authority" - }, - "exit": { - "name": "Out", - "tooltip": "Signaled after Autonomous To Authority is invoked" - }, - "details": { - "name": "Autonomous To Authority" - }, - "params": [ - { - "typeid": "{CA5E5C37-98A6-04D2-E15C-1B4BFEE4C7DD}", - "details": { - "name": "Network Test Player Component" - } - }, - { - "typeid": "{EA2C3E90-AFBE-44D4-A90D-FAAF79BAF93D}", - "details": { - "name": "float" - } - } - ] - }, - { - "base": "ServerToAuthority", - "context": "NetworkTestPlayerComponent", - "entry": { - "name": "In", - "tooltip": "When signaled, this will invoke Server To Authority" - }, - "exit": { - "name": "Out", - "tooltip": "Signaled after Server To Authority is invoked" - }, - "details": { - "name": "Server To Authority" - }, - "params": [ - { - "typeid": "{CA5E5C37-98A6-04D2-E15C-1B4BFEE4C7DD}", - "details": { - "name": "Network Test Player Component" - } - }, - { - "typeid": "{EA2C3E90-AFBE-44D4-A90D-FAAF79BAF93D}", - "details": { - "name": "float" - } - } - ] - }, { "base": "AutonomousToAuthorityByEntityId", "context": "NetworkTestPlayerComponent", @@ -97,18 +39,72 @@ ] }, { - "base": "ServerToAuthorityByEntityId", + "base": "AuthorityToClientNoParams_PlayFxByEntityId", "context": "NetworkTestPlayerComponent", "entry": { "name": "In", - "tooltip": "When signaled, this will invoke Server To Authority By Entity Id" + "tooltip": "When signaled, this will invoke Authority To Client No Params_ Play Fx By Entity Id" }, "exit": { "name": "Out", - "tooltip": "Signaled after Server To Authority By Entity Id is invoked" + "tooltip": "Signaled after Authority To Client No Params_ Play Fx By Entity Id is invoked" }, "details": { - "name": "Server To Authority By Entity Id" + "name": "Authority To Client No Params_ Play Fx By Entity Id" + }, + "params": [ + { + "typeid": "{6383F1D3-BB27-4E6B-A49A-6409B2059EAA}", + "details": { + "name": "Source", + "tooltip": "The Source containing the NetworkTestPlayerComponentController" + } + } + ] + }, + { + "base": "AuthorityToAutonomous_PlayerNumberByEntityId", + "context": "NetworkTestPlayerComponent", + "entry": { + "name": "In", + "tooltip": "When signaled, this will invoke Authority To Autonomous_ Player Number By Entity Id" + }, + "exit": { + "name": "Out", + "tooltip": "Signaled after Authority To Autonomous_ Player Number By Entity Id is invoked" + }, + "details": { + "name": "Authority To Autonomous_ Player Number By Entity Id" + }, + "params": [ + { + "typeid": "{6383F1D3-BB27-4E6B-A49A-6409B2059EAA}", + "details": { + "name": "Source", + "tooltip": "The Source containing the NetworkTestPlayerComponentController" + } + }, + { + "typeid": "{72039442-EB38-4D42-A1AD-CB68F7E0EEF6}", + "details": { + "name": "player_number" + } + } + ] + }, + { + "base": "ServerToAuthority_DealDamageByEntityId", + "context": "NetworkTestPlayerComponent", + "entry": { + "name": "In", + "tooltip": "When signaled, this will invoke Server To Authority_ Deal Damage By Entity Id" + }, + "exit": { + "name": "Out", + "tooltip": "Signaled after Server To Authority_ Deal Damage By Entity Id is invoked" + }, + "details": { + "name": "Server To Authority_ Deal Damage By Entity Id" }, "params": [ { @@ -121,47 +117,48 @@ { "typeid": "{EA2C3E90-AFBE-44D4-A90D-FAAF79BAF93D}", "details": { - "name": "some Float" + "name": "damage" } } ] }, { - "base": "AutonomousToAuthorityNoParams", + "base": "AutonomousToAuthorityNoParamsByEntityId", "context": "NetworkTestPlayerComponent", "entry": { "name": "In", - "tooltip": "When signaled, this will invoke Autonomous To Authority No Params" + "tooltip": "When signaled, this will invoke Autonomous To Authority No Params By Entity Id" }, "exit": { "name": "Out", - "tooltip": "Signaled after Autonomous To Authority No Params is invoked" + "tooltip": "Signaled after Autonomous To Authority No Params By Entity Id is invoked" }, "details": { - "name": "Autonomous To Authority No Params" + "name": "Autonomous To Authority No Params By Entity Id" }, "params": [ { - "typeid": "{CA5E5C37-98A6-04D2-E15C-1B4BFEE4C7DD}", + "typeid": "{6383F1D3-BB27-4E6B-A49A-6409B2059EAA}", "details": { - "name": "Network Test Player Component" + "name": "Source", + "tooltip": "The Source containing the NetworkTestPlayerComponentController" } } ] }, { - "base": "AuthorityToAutonomous", + "base": "ServerToAuthority_DealDamage", "context": "NetworkTestPlayerComponent", "entry": { "name": "In", - "tooltip": "When signaled, this will invoke Authority To Autonomous" + "tooltip": "When signaled, this will invoke Server To Authority_ Deal Damage" }, "exit": { "name": "Out", - "tooltip": "Signaled after Authority To Autonomous is invoked" + "tooltip": "Signaled after Server To Authority_ Deal Damage is invoked" }, "details": { - "name": "Authority To Autonomous" + "name": "Server To Authority_ Deal Damage" }, "params": [ { @@ -179,18 +176,18 @@ ] }, { - "base": "AuthorityToClientNoParams", + "base": "AutonomousToAuthority", "context": "NetworkTestPlayerComponent", "entry": { "name": "In", - "tooltip": "When signaled, this will invoke Authority To Client No Params" + "tooltip": "When signaled, this will invoke Autonomous To Authority" }, "exit": { "name": "Out", - "tooltip": "Signaled after Authority To Client No Params is invoked" + "tooltip": "Signaled after Autonomous To Authority is invoked" }, "details": { - "name": "Authority To Client No Params" + "name": "Autonomous To Authority" }, "params": [ { @@ -198,6 +195,41 @@ "details": { "name": "Network Test Player Component" } + }, + { + "typeid": "{EA2C3E90-AFBE-44D4-A90D-FAAF79BAF93D}", + "details": { + "name": "float" + } + } + ] + }, + { + "base": "AuthorityToAutonomous_PlayerNumber", + "context": "NetworkTestPlayerComponent", + "entry": { + "name": "In", + "tooltip": "When signaled, this will invoke Authority To Autonomous_ Player Number" + }, + "exit": { + "name": "Out", + "tooltip": "Signaled after Authority To Autonomous_ Player Number is invoked" + }, + "details": { + "name": "Authority To Autonomous_ Player Number" + }, + "params": [ + { + "typeid": "{CA5E5C37-98A6-04D2-E15C-1B4BFEE4C7DD}", + "details": { + "name": "Network Test Player Component" + } + }, + { + "typeid": "{72039442-EB38-4D42-A1AD-CB68F7E0EEF6}", + "details": { + "name": "int" + } } ] }, @@ -308,79 +340,47 @@ ] }, { - "base": "AuthorityToClientNoParamsByEntityId", + "base": "AutonomousToAuthorityNoParams", "context": "NetworkTestPlayerComponent", "entry": { "name": "In", - "tooltip": "When signaled, this will invoke Authority To Client No Params By Entity Id" + "tooltip": "When signaled, this will invoke Autonomous To Authority No Params" }, "exit": { "name": "Out", - "tooltip": "Signaled after Authority To Client No Params By Entity Id is invoked" + "tooltip": "Signaled after Autonomous To Authority No Params is invoked" }, "details": { - "name": "Authority To Client No Params By Entity Id" + "name": "Autonomous To Authority No Params" }, "params": [ { - "typeid": "{6383F1D3-BB27-4E6B-A49A-6409B2059EAA}", + "typeid": "{CA5E5C37-98A6-04D2-E15C-1B4BFEE4C7DD}", "details": { - "name": "Source", - "tooltip": "The Source containing the NetworkTestPlayerComponentController" + "name": "Network Test Player Component" } } ] }, { - "base": "AuthorityToAutonomousByEntityId", + "base": "AuthorityToClientNoParams_PlayFx", "context": "NetworkTestPlayerComponent", "entry": { "name": "In", - "tooltip": "When signaled, this will invoke Authority To Autonomous By Entity Id" + "tooltip": "When signaled, this will invoke Authority To Client No Params_ Play Fx" }, "exit": { "name": "Out", - "tooltip": "Signaled after Authority To Autonomous By Entity Id is invoked" + "tooltip": "Signaled after Authority To Client No Params_ Play Fx is invoked" }, "details": { - "name": "Authority To Autonomous By Entity Id" + "name": "Authority To Client No Params_ Play Fx" }, "params": [ { - "typeid": "{6383F1D3-BB27-4E6B-A49A-6409B2059EAA}", + "typeid": "{CA5E5C37-98A6-04D2-E15C-1B4BFEE4C7DD}", "details": { - "name": "Source", - "tooltip": "The Source containing the NetworkTestPlayerComponentController" - } - }, - { - "typeid": "{EA2C3E90-AFBE-44D4-A90D-FAAF79BAF93D}", - "details": { - "name": "some Float" - } - } - ] - }, - { - "base": "AutonomousToAuthorityNoParamsByEntityId", - "context": "NetworkTestPlayerComponent", - "entry": { - "name": "In", - "tooltip": "When signaled, this will invoke Autonomous To Authority No Params By Entity Id" - }, - "exit": { - "name": "Out", - "tooltip": "Signaled after Autonomous To Authority No Params By Entity Id is invoked" - }, - "details": { - "name": "Autonomous To Authority No Params By Entity Id" - }, - "params": [ - { - "typeid": "{6383F1D3-BB27-4E6B-A49A-6409B2059EAA}", - "details": { - "name": "Source", - "tooltip": "The Source containing the NetworkTestPlayerComponentController" + "name": "Network Test Player Component" } } ] diff --git a/Gems/ScriptCanvas/Assets/TranslationAssets/Classes/NetworkTestPlayerComponentNetworkInput.names b/AutomatedTesting/ScriptCanvas/TranslationAssets/Classes/NetworkTestPlayerComponentNetworkInput.names similarity index 100% rename from Gems/ScriptCanvas/Assets/TranslationAssets/Classes/NetworkTestPlayerComponentNetworkInput.names rename to AutomatedTesting/ScriptCanvas/TranslationAssets/Classes/NetworkTestPlayerComponentNetworkInput.names diff --git a/AutomatedTesting/ScriptCanvas/instance_counter.scriptcanvas b/AutomatedTesting/ScriptCanvas/instance_counter.scriptcanvas index 0e5524273c..4ef5f0a8d5 100644 --- a/AutomatedTesting/ScriptCanvas/instance_counter.scriptcanvas +++ b/AutomatedTesting/ScriptCanvas/instance_counter.scriptcanvas @@ -5,7 +5,7 @@ "ClassData": { "m_scriptCanvas": { "Id": { - "id": 3744110453276 + "id": 337666590525276931 }, "Name": "instance_counter", "Components": { @@ -87,7 +87,6 @@ ], "Datums": [ { - "isOverloadedStorage": false, "scriptCanvasType": { "m_type": 3 }, @@ -228,7 +227,6 @@ ], "Datums": [ { - "isOverloadedStorage": false, "scriptCanvasType": { "m_type": 1 }, @@ -237,7 +235,7 @@ "value": { "id": 2901262558 }, - "label": "Source" + "label": "EntityID: 0" } ], "methodType": 0, @@ -340,7 +338,6 @@ ], "Datums": [ { - "isOverloadedStorage": false, "scriptCanvasType": { "m_type": 3 }, @@ -587,26 +584,10 @@ "m_assetType": "{3E2AC8CD-713F-453E-967F-29517F331784}", "versionData": { "_grammarVersion": 1, - "_runtimeVersion": 1 + "_runtimeVersion": 1, + "_fileVersion": 1 }, "GraphCanvasData": [ - { - "Key": { - "id": 3744110453276 - }, - "Value": { - "ComponentData": { - "{5F84B500-8C45-40D1-8EFC-A5306B241444}": { - "$type": "SceneComponentSaveData", - "ViewParams": { - "Scale": 0.9218543514249998, - "AnchorX": 50.98419189453125, - "AnchorY": -272.27728271484375 - } - } - } - } - }, { "Key": { "id": 3748405420572 @@ -757,6 +738,18 @@ } } } + }, + { + "Key": { + "id": 337666590525276931 + }, + "Value": { + "ComponentData": { + "{5F84B500-8C45-40D1-8EFC-A5306B241444}": { + "$type": "SceneComponentSaveData" + } + } + } } ], "StatisticsHelper": { diff --git a/AutomatedTesting/project.json b/AutomatedTesting/project.json index 5a4b303570..a928547f20 100644 --- a/AutomatedTesting/project.json +++ b/AutomatedTesting/project.json @@ -16,4 +16,4 @@ "external_subdirectories": [ "Gem" ] -} \ No newline at end of file +} diff --git a/CMakeLists.txt b/CMakeLists.txt index c81581fe0f..efcc866195 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -93,6 +93,10 @@ endfunction() # Add the projects first so the Launcher can find them include(cmake/Projects.cmake) +if(LY_EXTERNAL_SUBDIRS) + set_property(GLOBAL APPEND PROPERTY LY_EXTERNAL_SUBDIRS ${LY_EXTERNAL_SUBDIRS}) +endif() + if(NOT INSTALLED_ENGINE) # Add external subdirectories listed in the engine.json. LY_EXTERNAL_SUBDIRS is a cache variable so the user can add extra # external subdirectories. This should go before adding the rest of the targets so the targets are availbe to the launcher. diff --git a/Code/Editor/CMakeLists.txt b/Code/Editor/CMakeLists.txt index 9d74f8e3a2..3f340e37d8 100644 --- a/Code/Editor/CMakeLists.txt +++ b/Code/Editor/CMakeLists.txt @@ -104,13 +104,11 @@ ly_add_target( 3rdParty::Qt::Concurrent 3rdParty::TIFF 3rdParty::squish-ccr - 3rdParty::AWSNativeSDK::STS Legacy::CryCommon Legacy::EditorCommon AZ::AzCore AZ::AzToolsFramework Gem::LmbrCentral.Static - AZ::AWSNativeSDKInit AZ::AtomCore Gem::Atom_RPI.Edit Gem::Atom_RPI.Public @@ -119,7 +117,6 @@ ly_add_target( Gem::AtomViewportDisplayInfo ${additional_dependencies} PUBLIC - 3rdParty::AWSNativeSDK::Core 3rdParty::Qt::Network Legacy::EditorCore RUNTIME_DEPENDENCIES diff --git a/Code/Editor/CryEdit.cpp b/Code/Editor/CryEdit.cpp index 3beaf4d438..805a22e880 100644 --- a/Code/Editor/CryEdit.cpp +++ b/Code/Editor/CryEdit.cpp @@ -36,14 +36,6 @@ AZ_POP_DISABLE_WARNING #include #include -// Aws Native SDK -#include -#include -#include -#include -#include -#include - // AzCore #include #include @@ -144,9 +136,7 @@ AZ_POP_DISABLE_WARNING #include "Plugins/ComponentEntityEditorPlugin/Objects/ComponentEntityObject.h" -// AWSNativeSDK #include -#include #if defined(AZ_PLATFORM_WINDOWS) @@ -2125,8 +2115,6 @@ bool CCryEditApp::FixDanglingSharedMemory(const QString& sharedMemName) const int CCryEditApp::ExitInstance(int exitCode) { - AZ_TracePrintf("Exit", "Called ExitInstance() with exit code: 0x%x", exitCode); - if (m_pEditor) { m_pEditor->OnBeginShutdownSequence(); @@ -3363,6 +3351,10 @@ CCryEditDoc* CCryEditApp::OpenDocumentFile(const char* filename, bool addToMostR return GetIEditor()->GetDocument(); } + bool usePrefabSystemForLevels = false; + AzFramework::ApplicationRequests::Bus::BroadcastResult( + usePrefabSystemForLevels, &AzFramework::ApplicationRequests::IsPrefabSystemForLevelsEnabled); + // If we are loading and we're in simulate mode, then switch it off before we do anything else if (GetIEditor()->GetGameEngine() && GetIEditor()->GetGameEngine()->GetSimulationMode()) { @@ -3370,6 +3362,15 @@ CCryEditDoc* CCryEditApp::OpenDocumentFile(const char* filename, bool addToMostR bool bIsDocModified = GetIEditor()->GetDocument()->IsModified(); OnSwitchPhysics(); GetIEditor()->GetDocument()->SetModifiedFlag(bIsDocModified); + + if (usePrefabSystemForLevels) + { + auto* rootSpawnableInterface = AzFramework::RootSpawnableInterface::Get(); + if (rootSpawnableInterface) + { + rootSpawnableInterface->ProcessSpawnableQueue(); + } + } } // We're about to start loading a level, so start recording errors to display at the end. diff --git a/Code/Editor/EditorPreferencesPageAWS.cpp b/Code/Editor/EditorPreferencesPageAWS.cpp index 9279dce7bc..968969245d 100644 --- a/Code/Editor/EditorPreferencesPageAWS.cpp +++ b/Code/Editor/EditorPreferencesPageAWS.cpp @@ -101,7 +101,7 @@ void CEditorPreferencesPage_AWS::SaveSettingsRegistryFile() return; } - bool saved{}; + [[maybe_unused]] bool saved{}; constexpr auto configurationMode = AZ::IO::SystemFile::SF_OPEN_CREATE | AZ::IO::SystemFile::SF_OPEN_CREATE_PATH | AZ::IO::SystemFile::SF_OPEN_WRITE_ONLY; if (AZ::IO::SystemFile outputFile; outputFile.Open(resolvedPath.data(), configurationMode)) diff --git a/Code/Editor/GameEngine.cpp b/Code/Editor/GameEngine.cpp index 9786dcf1b8..8aab168b6d 100644 --- a/Code/Editor/GameEngine.cpp +++ b/Code/Editor/GameEngine.cpp @@ -18,6 +18,7 @@ // AzCore #include #include +#include #include #include diff --git a/Code/Editor/IEditorImpl.cpp b/Code/Editor/IEditorImpl.cpp index ec688b27c7..d3f881a252 100644 --- a/Code/Editor/IEditorImpl.cpp +++ b/Code/Editor/IEditorImpl.cpp @@ -17,12 +17,6 @@ // Qt #include -// AWS Native SDK -AZ_PUSH_DISABLE_WARNING(4251 4355 4996, "-Wunknown-warning-option") -#include -#include -AZ_POP_DISABLE_WARNING - // AzCore #include #include @@ -76,9 +70,6 @@ AZ_POP_DISABLE_WARNING #include "Editor/AzAssetBrowser/AzAssetBrowserRequestHandler.h" #include "Editor/AssetEditor/AssetEditorRequestsHandler.h" -// AWSNativeSDK -#include - #include "Core/QtEditorApplication.h" // for Editor::EditorQtApplication static CCryEditDoc * theDocument; @@ -130,7 +121,6 @@ CEditorImpl::CEditorImpl() , m_pSettingsManager(nullptr) , m_pLevelIndependentFileMan(nullptr) , m_pExportManager(nullptr) - , m_awsResourceManager(nullptr) , m_bMatEditMode(false) , m_bShowStatusText(true) , m_bInitialized(false) diff --git a/Code/Editor/IEditorImpl.h b/Code/Editor/IEditorImpl.h index f53b1b84d5..08629e434b 100644 --- a/Code/Editor/IEditorImpl.h +++ b/Code/Editor/IEditorImpl.h @@ -361,7 +361,6 @@ protected: QString m_selectFileBuffer; QString m_levelNameBuffer; - IAWSResourceManager* m_awsResourceManager; //! True if the editor is in material edit mode. Fast preview of materials. //! In this mode only very limited functionality is available. diff --git a/Code/Editor/Lib/Tests/test_ModularViewportCameraController.cpp b/Code/Editor/Lib/Tests/test_ModularViewportCameraController.cpp index 67d89ad967..5009c626e2 100644 --- a/Code/Editor/Lib/Tests/test_ModularViewportCameraController.cpp +++ b/Code/Editor/Lib/Tests/test_ModularViewportCameraController.cpp @@ -47,12 +47,12 @@ namespace UnitTest void ViewportMouseCursorRequestImpl::BeginCursorCapture() { - m_inputChannelMapper->SetCursorCaptureEnabled(true); + m_inputChannelMapper->SetCursorMode(AzToolsFramework::CursorInputMode::CursorModeCaptured); } void ViewportMouseCursorRequestImpl::EndCursorCapture() { - m_inputChannelMapper->SetCursorCaptureEnabled(false); + m_inputChannelMapper->SetCursorMode(AzToolsFramework::CursorInputMode::CursorModeNone); } bool ViewportMouseCursorRequestImpl::IsMouseOver() const diff --git a/Code/Editor/MainWindow.cpp b/Code/Editor/MainWindow.cpp index dca6de4fc3..3a52bb85a1 100644 --- a/Code/Editor/MainWindow.cpp +++ b/Code/Editor/MainWindow.cpp @@ -11,11 +11,6 @@ #include -// AWs Native SDK -AZ_PUSH_DISABLE_WARNING(4251 4355 4996, "-Wunknown-warning-option") -#include -AZ_POP_DISABLE_WARNING - // Qt #include #include diff --git a/Code/Editor/MainWindow.h b/Code/Editor/MainWindow.h index 5adf9a8036..9759dadade 100644 --- a/Code/Editor/MainWindow.h +++ b/Code/Editor/MainWindow.h @@ -63,11 +63,11 @@ namespace AzToolsFramework //! @name Reverse URLs. //! Used to identify common actions and override them when necessary. //@{ - constexpr inline AZ::Crc32 EditModeMove = AZ_CRC_CE("com.o3de.action.editor.editmode.move"); - constexpr inline AZ::Crc32 EditModeRotate = AZ_CRC_CE("com.o3de.action.editor.editmode.rotate"); - constexpr inline AZ::Crc32 EditModeScale = AZ_CRC_CE("com.o3de.action.editor.editmode.scale"); - constexpr inline AZ::Crc32 SnapToGrid = AZ_CRC_CE("com.o3de.action.editor.snaptogrid"); - constexpr inline AZ::Crc32 SnapAngle = AZ_CRC_CE("com.o3de.action.editor.snapangle"); + constexpr inline AZ::Crc32 EditModeMove = AZ_CRC_CE("org.o3de.action.editor.editmode.move"); + constexpr inline AZ::Crc32 EditModeRotate = AZ_CRC_CE("org.o3de.action.editor.editmode.rotate"); + constexpr inline AZ::Crc32 EditModeScale = AZ_CRC_CE("org.o3de.action.editor.editmode.scale"); + constexpr inline AZ::Crc32 SnapToGrid = AZ_CRC_CE("org.o3de.action.editor.snaptogrid"); + constexpr inline AZ::Crc32 SnapAngle = AZ_CRC_CE("org.o3de.action.editor.snapangle"); //@} } diff --git a/Code/Editor/Settings.cpp b/Code/Editor/Settings.cpp index 8561e6dba3..9514957795 100644 --- a/Code/Editor/Settings.cpp +++ b/Code/Editor/Settings.cpp @@ -1128,7 +1128,7 @@ void SEditorSettings::SaveSettingsRegistryFile() return; } - bool saved{}; + [[maybe_unused]] bool saved{}; constexpr auto configurationMode = AZ::IO::SystemFile::SF_OPEN_CREATE | AZ::IO::SystemFile::SF_OPEN_CREATE_PATH | AZ::IO::SystemFile::SF_OPEN_WRITE_ONLY; diff --git a/Code/Editor/Util/ModalWindowDismisser.cpp b/Code/Editor/Util/ModalWindowDismisser.cpp index 7ae62e4a67..17bd1f8543 100644 --- a/Code/Editor/Util/ModalWindowDismisser.cpp +++ b/Code/Editor/Util/ModalWindowDismisser.cpp @@ -45,7 +45,8 @@ bool ModalWindowDismisser::eventFilter(QObject* object, QEvent* event) { if (dialog->isModal()) { - if (event->type() == QEvent::Show) + QEvent::Type test = event->type(); + if (test == QEvent::Show || test == QEvent::WindowActivate) { auto it = AZStd::find(m_windows.begin(), m_windows.end(), dialog); if (it == m_windows.end()) diff --git a/Code/Editor/ViewPane.cpp b/Code/Editor/ViewPane.cpp index e3494a4049..99b4c5a1cc 100644 --- a/Code/Editor/ViewPane.cpp +++ b/Code/Editor/ViewPane.cpp @@ -87,29 +87,15 @@ public: } // Handle labels with submenus - if (auto toolLabel = qobject_cast(toolWidget)) + if (auto toolLabel = qobject_cast(toolWidget)) { if (!toolLabel->isVisible()) { // Manually turn the custom context menus into submenus - if (toolLabel->objectName() == "m_fovStaticCtrl") + if (toolLabel->menu()) { - QAction* newAction = menu->addMenu(m_viewportDlg->GetFovMenu()); - newAction->setText(QString("FOV: %1").arg(toolLabel->text())); - } - else if (toolLabel->objectName() == "m_ratioStaticCtrl") - { - QAction* newAction = menu->addMenu(m_viewportDlg->GetAspectMenu()); - newAction->setText(QString("Ratio: %1").arg(toolLabel->text())); - } - else if (toolLabel->objectName() == "m_sizeStaticCtrl") - { - QAction* newAction = menu->addMenu(m_viewportDlg->GetResolutionMenu()); - newAction->setText(QString("%1").arg(toolLabel->text())); - } - else - { - // Don't add actions for other Labels + QAction* action = menu->addMenu(toolLabel->menu()); + action->setText(toolLabel->text()); continue; } } @@ -179,14 +165,25 @@ CLayoutViewPane::CLayoutViewPane(QWidget* parent) toolbar->installEventFilter(&m_viewportTitleDlg); toolbar->setContextMenuPolicy(Qt::CustomContextMenu); connect(toolbar, &QWidget::customContextMenuRequested, &m_viewportTitleDlg, &QWidget::customContextMenuRequested); - setContextMenuPolicy(Qt::NoContextMenu); - + if (QToolButton* expansion = AzQtComponents::ToolBar::getToolBarExpansionButton(toolbar)) { expansion->installEventFilter(m_expanderWatcher); } + AzQtComponents::BreadCrumbs* prefabsBreadcrumbs = + qobject_cast(toolbar->findChild("m_prefabFocusPath")); + QToolButton* backButton = qobject_cast(toolbar->findChild("m_prefabFocusBackButton")); + + AZ_Assert(prefabsBreadcrumbs, "Could not find Prefabs Breadcrumbs widget on CLayoutViewPane initialization!"); + AZ_Assert(backButton, "Could not find Prefabs Breadcrumbs back button on CLayoutViewPane initialization!"); + + if (prefabsBreadcrumbs && backButton) + { + m_viewportTitleDlg.InitializePrefabViewportFocusPathHandler(prefabsBreadcrumbs, backButton); + } + m_id = -1; } @@ -745,7 +742,7 @@ namespace void PySetActiveViewport(unsigned int viewportIndex) { - bool success = false; + [[maybe_unused]] bool success = false; CLayoutWnd* layout = GetIEditor()->GetViewManager()->GetLayout(); if (layout) { diff --git a/Code/Editor/ViewportManipulatorController.cpp b/Code/Editor/ViewportManipulatorController.cpp index 9879a84b62..93c999f71f 100644 --- a/Code/Editor/ViewportManipulatorController.cpp +++ b/Code/Editor/ViewportManipulatorController.cpp @@ -17,6 +17,7 @@ #include #include #include +#include #include @@ -33,53 +34,6 @@ namespace SandboxEditor ViewportManipulatorControllerInstance::~ViewportManipulatorControllerInstance() = default; - AzToolsFramework::ViewportInteraction::MouseButton ViewportManipulatorControllerInstance::GetMouseButton( - const AzFramework::InputChannel& inputChannel) - { - using AzToolsFramework::ViewportInteraction::MouseButton; - using InputButton = AzFramework::InputDeviceMouse::Button; - const auto& id = inputChannel.GetInputChannelId(); - if (id == InputButton::Left) - { - return MouseButton::Left; - } - if (id == InputButton::Middle) - { - return MouseButton::Middle; - } - if (id == InputButton::Right) - { - return MouseButton::Right; - } - return MouseButton::None; - } - - bool ViewportManipulatorControllerInstance::IsMouseMove(const AzFramework::InputChannel& inputChannel) - { - return inputChannel.GetInputChannelId() == AzFramework::InputDeviceMouse::SystemCursorPosition; - } - - AzToolsFramework::ViewportInteraction::KeyboardModifier ViewportManipulatorControllerInstance::GetKeyboardModifier( - const AzFramework::InputChannel& inputChannel) - { - using AzToolsFramework::ViewportInteraction::KeyboardModifier; - using Key = AzFramework::InputDeviceKeyboard::Key; - const auto& id = inputChannel.GetInputChannelId(); - if (id == Key::ModifierAltL || id == Key::ModifierAltR) - { - return KeyboardModifier::Alt; - } - if (id == Key::ModifierCtrlL || id == Key::ModifierCtrlR) - { - return KeyboardModifier::Ctrl; - } - if (id == Key::ModifierShiftL || id == Key::ModifierShiftR) - { - return KeyboardModifier::Shift; - } - return KeyboardModifier::None; - } - bool ViewportManipulatorControllerInstance::HandleInputChannelEvent(const AzFramework::ViewportControllerInputEvent& event) { // We only care about manipulator and viewport interaction events @@ -97,6 +51,7 @@ namespace SandboxEditor using AzToolsFramework::ViewportInteraction::MouseInteractionEvent; using AzToolsFramework::ViewportInteraction::ProjectedViewportRay; using AzToolsFramework::ViewportInteraction::ViewportInteractionRequestBus; + using AzToolsFramework::ViewportInteraction::Helpers; bool interactionHandled = false; float wheelDelta = 0.0f; @@ -109,7 +64,7 @@ namespace SandboxEditor const bool finishedProcessingEvents = event.m_priority == InteractionPriority; const auto state = event.m_inputChannel.GetState(); - if (IsMouseMove(event.m_inputChannel)) + if (Helpers::IsMouseMove(event.m_inputChannel)) { // Cache the ray trace results when doing manipulator interaction checks, no need to recalculate after if (event.m_priority == ManipulatorPriority) @@ -136,7 +91,7 @@ namespace SandboxEditor eventType = MouseEvent::Move; } - else if (auto mouseButton = GetMouseButton(event.m_inputChannel); mouseButton != MouseButton::None) + else if (auto mouseButton = Helpers::GetMouseButton(event.m_inputChannel); mouseButton != MouseButton::None) { const AZ::u32 mouseButtonValue = static_cast(mouseButton); overrideButton = mouseButton; @@ -178,7 +133,7 @@ namespace SandboxEditor } } } - else if (auto keyboardModifier = GetKeyboardModifier(event.m_inputChannel); keyboardModifier != KeyboardModifier::None) + else if (auto keyboardModifier = Helpers::GetKeyboardModifier(event.m_inputChannel); keyboardModifier != KeyboardModifier::None) { if (state == InputChannel::State::Began || state == InputChannel::State::Updated) { diff --git a/Code/Editor/ViewportManipulatorController.h b/Code/Editor/ViewportManipulatorController.h index b9c359a544..4872d32fd6 100644 --- a/Code/Editor/ViewportManipulatorController.h +++ b/Code/Editor/ViewportManipulatorController.h @@ -35,10 +35,6 @@ namespace SandboxEditor private: bool IsDoubleClick(AzToolsFramework::ViewportInteraction::MouseButton) const; - static AzToolsFramework::ViewportInteraction::MouseButton GetMouseButton(const AzFramework::InputChannel& inputChannel); - static bool IsMouseMove(const AzFramework::InputChannel& inputChannel); - static AzToolsFramework::ViewportInteraction::KeyboardModifier GetKeyboardModifier(const AzFramework::InputChannel& inputChannel); - //! Represents the time and location of a click. struct ClickEvent { diff --git a/Code/Editor/ViewportTitleDlg.cpp b/Code/Editor/ViewportTitleDlg.cpp index 90aa044d25..bbd9eaaa10 100644 --- a/Code/Editor/ViewportTitleDlg.cpp +++ b/Code/Editor/ViewportTitleDlg.cpp @@ -383,12 +383,7 @@ void CViewportTitleDlg::OnInitDialog() bool isPrefabSystemEnabled = false; AzFramework::ApplicationRequests::Bus::BroadcastResult(isPrefabSystemEnabled, &AzFramework::ApplicationRequests::IsPrefabSystemEnabled); - if (isPrefabSystemEnabled) - { - m_prefabViewportFocusPathHandler = new AzToolsFramework::Prefab::PrefabViewportFocusPathHandler(); - m_prefabViewportFocusPathHandler->Initialize(m_ui->m_prefabFocusPath, m_ui->m_prefabFocusBackButton); - } - else + if (!isPrefabSystemEnabled) { m_ui->m_prefabFocusPath->setEnabled(false); m_ui->m_prefabFocusBackButton->setEnabled(false); @@ -397,6 +392,23 @@ void CViewportTitleDlg::OnInitDialog() } } +void CViewportTitleDlg::InitializePrefabViewportFocusPathHandler(AzQtComponents::BreadCrumbs* breadcrumbsWidget, QToolButton* backButton) +{ + if (m_prefabViewportFocusPathHandler != nullptr) + { + return; + } + + bool isPrefabSystemEnabled = false; + AzFramework::ApplicationRequests::Bus::BroadcastResult(isPrefabSystemEnabled, &AzFramework::ApplicationRequests::IsPrefabSystemEnabled); + + if (isPrefabSystemEnabled) + { + m_prefabViewportFocusPathHandler = new AzToolsFramework::Prefab::PrefabViewportFocusPathHandler(); + m_prefabViewportFocusPathHandler->Initialize(breadcrumbsWidget, backButton); + } +} + ////////////////////////////////////////////////////////////////////////// void CViewportTitleDlg::SetTitle(const QString& title) { diff --git a/Code/Editor/ViewportTitleDlg.h b/Code/Editor/ViewportTitleDlg.h index b8da7f20ea..8d8b06b96d 100644 --- a/Code/Editor/ViewportTitleDlg.h +++ b/Code/Editor/ViewportTitleDlg.h @@ -70,6 +70,8 @@ public: QMenu* const GetAspectMenu(); QMenu* const GetResolutionMenu(); + void InitializePrefabViewportFocusPathHandler(AzQtComponents::BreadCrumbs* breadcrumbsWidget, QToolButton* backButton); + Q_SIGNALS: void ActionTriggered(int command); diff --git a/Code/Editor/ViewportTitleDlg.ui b/Code/Editor/ViewportTitleDlg.ui index 7ba6361cf9..1711bdaf90 100644 --- a/Code/Editor/ViewportTitleDlg.ui +++ b/Code/Editor/ViewportTitleDlg.ui @@ -80,6 +80,9 @@ Camera settings + + Camera settings + :/Menu/camera.svg:/Menu/camera.svg @@ -91,6 +94,9 @@ Debug information + + Debug information + :/Menu/debug.svg:/Menu/debug.svg @@ -105,6 +111,9 @@ Toggle viewport helpers + + Toggle viewport helpers + :/Menu/helpers.svg:/Menu/helpers.svg @@ -119,6 +128,9 @@ Viewport resolution + + Viewport resolution + :/Menu/resolution.svg:/Menu/resolution.svg @@ -130,6 +142,9 @@ Other settings + + Other settings + :/Menu/menu.svg:/Menu/menu.svg diff --git a/Code/Framework/AtomCore/AtomCore/Instance/InstanceDatabase.h b/Code/Framework/AtomCore/AtomCore/Instance/InstanceDatabase.h index 4b4ad572c2..de98ce97b9 100644 --- a/Code/Framework/AtomCore/AtomCore/Instance/InstanceDatabase.h +++ b/Code/Framework/AtomCore/AtomCore/Instance/InstanceDatabase.h @@ -17,6 +17,11 @@ #include #include +namespace AZStd +{ + class any; +} + namespace AZ { namespace Data diff --git a/Code/Framework/AzAndroid/java/com/amazon/lumberyard/LumberyardActivity.java b/Code/Framework/AzAndroid/java/com/amazon/lumberyard/LumberyardActivity.java index a234d323eb..846114110f 100644 --- a/Code/Framework/AzAndroid/java/com/amazon/lumberyard/LumberyardActivity.java +++ b/Code/Framework/AzAndroid/java/com/amazon/lumberyard/LumberyardActivity.java @@ -64,7 +64,7 @@ public class LumberyardActivity extends NativeActivity //////////////////////////////////////////////////////////////// // called from the native to get the application package name - // e.g. com.lumberyard.samples for SamplesProject + // e.g. org.o3de.samples for SamplesProject public String GetPackageName() { return getApplicationContext().getPackageName(); diff --git a/Code/Framework/AzCore/AzCore/Asset/AssetCommon.h b/Code/Framework/AzCore/AzCore/Asset/AssetCommon.h index e4d2c7612e..697ca81a49 100644 --- a/Code/Framework/AzCore/AzCore/Asset/AssetCommon.h +++ b/Code/Framework/AzCore/AzCore/Asset/AssetCommon.h @@ -19,7 +19,7 @@ #include #include #include -#include +#include namespace AZ { diff --git a/Code/Framework/AzCore/AzCore/Asset/AssetDataStream.cpp b/Code/Framework/AzCore/AzCore/Asset/AssetDataStream.cpp index 4794b04626..4303963aa8 100644 --- a/Code/Framework/AzCore/AzCore/Asset/AssetDataStream.cpp +++ b/Code/Framework/AzCore/AzCore/Asset/AssetDataStream.cpp @@ -7,11 +7,62 @@ */ #include +#include +#include +#include +#include +#include + +#include +#include namespace AZ::Data { + namespace DataStreamInternal + { + struct AssetDataStreamPrivate + { + //! Optional data buffer that's been directly passed in through Open(), instead of reading data from a file. + AZStd::vector m_preloadedData; + //! The current active streamer read request - tracked in case we need to cancel it prematurely + AZ::IO::FileRequestPtr m_curReadRequest{ nullptr }; + + //! Synchronization for the read request, so that it's possible to block until completion. + AZStd::mutex m_readRequestMutex; + AZStd::condition_variable m_readRequestActive; + + void SetReadRequest(AZ::IO::FileRequestPtr&& req) + { + AZStd::scoped_lock lock(m_readRequestMutex); + // The read request finished, so stop tracking it. + m_curReadRequest = AZStd::move(req); + } + void BlockUntilReadComplete() + { + AZStd::unique_lock lock(m_readRequestMutex); + m_readRequestActive.wait( + lock, + [this] + { + return m_curReadRequest == nullptr; + }); + lock.unlock(); + } + void CancelRequest() + { + AZStd::scoped_lock lock(m_readRequestMutex); + if (m_curReadRequest) + { + auto streamer = Interface::Get(); + m_curReadRequest = streamer->Cancel(m_curReadRequest); + } + } + }; + } // namespace Internal + AssetDataStream::AssetDataStream(AZ::IO::IStreamerTypes::RequestMemoryAllocator* bufferAllocator) - : m_bufferAllocator(bufferAllocator ? bufferAllocator : &m_defaultAllocator) + : m_privateData(AZStd::make_unique()) + , m_bufferAllocator(bufferAllocator ? bufferAllocator : &m_defaultAllocator) { ClearInternalStateData(); } @@ -53,9 +104,9 @@ namespace AZ::Data OpenInternal(data.size(), "(mem buffer)"); // Directly take ownership of the provided buffer - m_preloadedData = AZStd::move(data); - m_buffer = m_preloadedData.data(); - m_loadedSize = m_preloadedData.size(); + m_privateData->m_preloadedData = AZStd::move(data); + m_buffer = m_privateData->m_preloadedData.data(); + m_loadedSize = m_privateData->m_preloadedData.size(); } void AssetDataStream::Open(const AZStd::string& filePath, size_t fileOffset, size_t assetSize, @@ -65,7 +116,7 @@ namespace AZ::Data AZ_PROFILE_FUNCTION(AzCore); AZ_Assert(!m_isOpen, "Attempting to open the stream when it is already open."); - AZ_Assert(!m_curReadRequest, "Queueing an asset stream load while one is still in progress."); + AZ_Assert(!m_privateData->m_curReadRequest, "Queueing an asset stream load while one is still in progress."); AZ_Assert(!filePath.empty(), "AssetDataStream::Open called without a valid file name."); // Initialize the state variables and start tracking the overall load timings @@ -97,11 +148,8 @@ namespace AZ::Data "Buffer for %s was expected to be %zu bytes, but is %zu bytes.", m_filePath.c_str(), m_requestedAssetSize, m_loadedSize); - { - AZStd::scoped_lock lock(m_readRequestMutex); - // The read request finished, so stop tracking it. - m_curReadRequest = nullptr; - } + // The read request finished, so stop tracking it. + m_privateData->SetReadRequest(nullptr); // Call the load callback to start processing the loaded data. if (loadCallback) @@ -115,21 +163,22 @@ namespace AZ::Data } // Notify that the load is complete, in case anyone is using BlockUntilLoadComplete to block. - m_readRequestActive.notify_one(); + m_privateData->m_readRequestActive.notify_one(); }; // Queue the raw file load with the file streamer. auto streamer = AZ::Interface::Get(); - m_curReadRequest = streamer->Read( + m_privateData->m_curReadRequest = + streamer->Read( m_filePath, *m_bufferAllocator, m_requestedAssetSize, deadline, priority, m_fileOffset); m_curDeadline = deadline; m_curPriority = priority; - streamer->SetRequestCompleteCallback(m_curReadRequest, streamerCallback); + streamer->SetRequestCompleteCallback(m_privateData->m_curReadRequest, streamerCallback); - streamer->QueueRequest(m_curReadRequest); + streamer->QueueRequest(m_privateData->m_curReadRequest); } else { @@ -139,19 +188,19 @@ namespace AZ::Data loadCallback(AZ::IO::IStreamerTypes::RequestStatus::Completed); } - m_readRequestActive.notify_one(); + m_privateData->m_readRequestActive.notify_one(); } } void AssetDataStream::Reschedule(AZStd::chrono::milliseconds newDeadline, AZ::IO::IStreamerTypes::Priority newPriority) { - if (m_curReadRequest && (newDeadline < m_curDeadline || newPriority > m_curPriority)) + if (m_privateData->m_curReadRequest && (newDeadline < m_curDeadline || newPriority > m_curPriority)) { auto deadline = AZStd::GetMin(m_curDeadline, newDeadline); auto priority = AZStd::GetMax(m_curPriority, newPriority); auto streamer = Interface::Get(); - m_curReadRequest = streamer->RescheduleRequest(m_curReadRequest, deadline, priority); + m_privateData->m_curReadRequest = streamer->RescheduleRequest(m_privateData->m_curReadRequest, deadline, priority); m_curDeadline = deadline; m_curPriority = priority; } @@ -159,15 +208,13 @@ namespace AZ::Data void AssetDataStream::BlockUntilLoadComplete() { - AZStd::unique_lock lock(m_readRequestMutex); - m_readRequestActive.wait(lock, [this] { return m_curReadRequest == nullptr; }); - lock.unlock(); + m_privateData->BlockUntilReadComplete(); } void AssetDataStream::ClearInternalStateData() { // Clear all our internal state data. - m_preloadedData.resize(0); + m_privateData->m_preloadedData.resize(0); m_buffer = nullptr; m_loadedSize = 0; m_requestedAssetSize = 0; @@ -204,10 +251,10 @@ namespace AZ::Data void AssetDataStream::Close() { AZ_Assert(m_isOpen, "Attempting to close a stream that hasn't been opened."); - AZ_Assert(m_curReadRequest == nullptr, "Attempting to close a stream with a read request in flight."); + AZ_Assert(m_privateData->m_curReadRequest == nullptr, "Attempting to close a stream with a read request in flight."); // Destroy the asset buffer and unlock the allocator, so the allocator itself knows that it is no longer needed. - if (m_buffer != m_preloadedData.data()) + if (m_buffer != m_privateData->m_preloadedData.data()) { m_bufferAllocator->Release(m_buffer); } @@ -221,12 +268,7 @@ namespace AZ::Data void AssetDataStream::RequestCancel() { - AZStd::scoped_lock lock(m_readRequestMutex); - if (m_curReadRequest) - { - auto streamer = Interface::Get(); - m_curReadRequest = streamer->Cancel(m_curReadRequest); - } + m_privateData->CancelRequest(); } void AssetDataStream::Seek(AZ::IO::OffsetType bytes, AZ::IO::GenericStream::SeekMode mode) diff --git a/Code/Framework/AzCore/AzCore/Asset/AssetDataStream.h b/Code/Framework/AzCore/AzCore/Asset/AssetDataStream.h index 79822c8db2..43a4516344 100644 --- a/Code/Framework/AzCore/AzCore/Asset/AssetDataStream.h +++ b/Code/Framework/AzCore/AzCore/Asset/AssetDataStream.h @@ -9,17 +9,26 @@ #include #include -#include -#include -#include -#include -#include +#include +#include + +namespace AZStd +{ + template + class vector; +} namespace AZ::Data { + namespace DataStreamInternal + { + struct AssetDataStreamPrivate; + } + class AssetDataStream : public AZ::IO::GenericStream { public: + using VectorDataSource = AZStd::vector; // The default Generic Stream APIs in this class will only allow for a single sequential pass // through the data, no seeking. Reads will block when pages aren't available yet, and // pages will be marked for recycling once reading has progressed beyond them. @@ -29,10 +38,10 @@ namespace AZ::Data ~AssetDataStream() override; // Open the AssetDataStream and make a copy of the provided memory buffer. - void Open(const AZStd::vector& data); + void Open(const VectorDataSource& data); // Open the AssetDataStream and directly take ownership of a pre-populated memory buffer. - void Open(AZStd::vector&& data); + void Open(VectorDataSource&& data); // Open the AssetDataStream and load it via file streaming using OnCompleteCallback = AZStd::function; @@ -91,6 +100,8 @@ namespace AZ::Data void ClearInternalStateData(); + AZStd::unique_ptr m_privateData; + //! The allocator to use for allocating / deallocating asset buffers AZ::IO::IStreamerTypes::RequestMemoryAllocator* m_bufferAllocator{ nullptr }; @@ -106,9 +117,6 @@ namespace AZ::Data //! The amount of data that's expected to be loaded. size_t m_requestedAssetSize{ 0 }; - //! Optional data buffer that's been directly passed in through Open(), instead of reading data from a file. - AZStd::vector m_preloadedData; - //! The buffer that will hold the raw data after it's loaded from the file. void* m_buffer{ nullptr }; @@ -119,19 +127,12 @@ namespace AZ::Data //! The current offset representing how far we've read into the buffer. size_t m_curOffset{ 0 }; - //! The current active streamer read request - tracked in case we need to cancel it prematurely - AZ::IO::FileRequestPtr m_curReadRequest{ nullptr }; - //! The current request deadline. Used to avoid requesting a reschedule to the same (current) deadline. AZStd::chrono::milliseconds m_curDeadline{ AZ::IO::IStreamerTypes::s_noDeadline }; //! The current request priority. Used to avoid requesting a reschedule to the same (current) priority. AZ::IO::IStreamerTypes::Priority m_curPriority{ AZ::IO::IStreamerTypes::s_priorityMedium }; - //! Synchronization for the read request, so that it's possible to block until completion. - AZStd::mutex m_readRequestMutex; - AZStd::condition_variable m_readRequestActive; - //! Track whether or not the stream is currently open bool m_isOpen{ false }; diff --git a/Code/Framework/AzCore/AzCore/Asset/AssetManager.cpp b/Code/Framework/AzCore/AzCore/Asset/AssetManager.cpp index afe3330bd3..b4b1a0d81c 100644 --- a/Code/Framework/AzCore/AzCore/Asset/AssetManager.cpp +++ b/Code/Framework/AzCore/AzCore/Asset/AssetManager.cpp @@ -10,6 +10,7 @@ #include #include #include +#include #include #include #include diff --git a/Code/Framework/AzCore/AzCore/Asset/AssetManager.h b/Code/Framework/AzCore/AzCore/Asset/AssetManager.h index 9666d434c1..663de2c058 100644 --- a/Code/Framework/AzCore/AzCore/Asset/AssetManager.h +++ b/Code/Framework/AzCore/AzCore/Asset/AssetManager.h @@ -12,7 +12,6 @@ #include #include #include -#include #include #include // used as allocator for most components #include diff --git a/Code/Framework/AzCore/AzCore/Component/Component.cpp b/Code/Framework/AzCore/AzCore/Component/Component.cpp index c9829c6dd8..c11e4ef69f 100644 --- a/Code/Framework/AzCore/AzCore/Component/Component.cpp +++ b/Code/Framework/AzCore/AzCore/Component/Component.cpp @@ -49,7 +49,7 @@ namespace AZ return m_entity->GetId(); } - AZ_Warning("System", false, "Can't get component %p entity ID as it is not attached to an entity yet!", this); + AZ_Warning("System", false, "Can't get component (type: %s, addr: %p) entity ID as it is not attached to an entity yet!", RTTI_GetTypeName(), this); return EntityId(); } @@ -60,7 +60,7 @@ namespace AZ return NamedEntityId(m_entity->GetId(), m_entity->GetName()); } - AZ_Warning("System", false, "Can't get component %p entity ID as it is not attached to an entity yet!", this); + AZ_Warning("System", false, "Can't get component (type: %s, addr: %p) entity ID as it is not attached to an entity yet!", RTTI_GetTypeName(), this); return NamedEntityId(); } diff --git a/Code/Framework/AzCore/AzCore/Component/Entity.cpp b/Code/Framework/AzCore/AzCore/Component/Entity.cpp index c5cda98f2c..db9ead93ad 100644 --- a/Code/Framework/AzCore/AzCore/Component/Entity.cpp +++ b/Code/Framework/AzCore/AzCore/Component/Entity.cpp @@ -230,7 +230,7 @@ namespace AZ EBUS_EVENT_ID(m_id, EntityBus, OnEntityDeactivated, m_id); EBUS_EVENT(EntitySystemBus, OnEntityDeactivated, m_id); - AZ_Assert(m_state == State::Active, "Component should be in Active state to br Deactivated!"); + AZ_Assert(m_state == State::Active, "Component should be in Active state to be Deactivated!"); SetState(State::Deactivating); for (ComponentArrayType::reverse_iterator it = m_components.rbegin(); it != m_components.rend(); ++it) diff --git a/Code/Framework/AzCore/AzCore/DOM/DomPath.cpp b/Code/Framework/AzCore/AzCore/DOM/DomPath.cpp new file mode 100644 index 0000000000..bc50a8513c --- /dev/null +++ b/Code/Framework/AzCore/AzCore/DOM/DomPath.cpp @@ -0,0 +1,478 @@ +/* + * 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 + +namespace AZ::Dom +{ + PathEntry::PathEntry(size_t value) + : m_value(value) + { + } + + PathEntry::PathEntry(AZ::Name value) + : m_value(AZStd::move(value)) + { + } + + PathEntry::PathEntry(AZStd::string_view value) + : m_value(AZ::Name(value)) + { + } + + PathEntry& PathEntry::operator=(size_t value) + { + m_value = value; + return *this; + } + + PathEntry& PathEntry::operator=(AZ::Name value) + { + m_value = AZStd::move(value); + return *this; + } + + PathEntry& PathEntry::operator=(AZStd::string_view value) + { + m_value = AZ::Name(value); + return *this; + } + + bool PathEntry::operator==(const PathEntry& other) const + { + return m_value == other.m_value; + } + + bool PathEntry::operator==(size_t value) const + { + return IsIndex() && GetIndex() == value; + } + + bool PathEntry::operator==(const AZ::Name& key) const + { + return IsKey() && GetKey() == key; + } + + bool PathEntry::operator==(AZStd::string_view key) const + { + return IsKey() && GetKey() == AZ::Name(key); + } + + bool PathEntry::operator!=(const PathEntry& other) const + { + return m_value != other.m_value; + } + + bool PathEntry::operator!=(size_t value) const + { + return !IsIndex() || GetIndex() != value; + } + + bool PathEntry::operator!=(const AZ::Name& key) const + { + return !IsKey() || GetKey() != key; + } + + bool PathEntry::operator!=(AZStd::string_view key) const + { + return !IsKey() || GetKey() != AZ::Name(key); + } + + void PathEntry::SetEndOfArray() + { + m_value = EndOfArrayIndex; + } + + bool PathEntry::IsEndOfArray() const + { + const size_t* result = AZStd::get_if(&m_value); + return result == nullptr ? false : ((*result) == EndOfArrayIndex); + } + + bool PathEntry::IsIndex() const + { + const size_t* result = AZStd::get_if(&m_value); + return result == nullptr ? false : ((*result) != EndOfArrayIndex); + } + + bool PathEntry::IsKey() const + { + return AZStd::holds_alternative(m_value); + } + + size_t PathEntry::GetIndex() const + { + AZ_Assert(IsIndex(), "GetIndex called on PathEntry that is not an index"); + return AZStd::get(m_value); + } + + const AZ::Name& PathEntry::GetKey() const + { + AZ_Assert(IsKey(), "Key called on PathEntry that is not a key"); + return AZStd::get(m_value); + } + + Path::Path(AZStd::initializer_list init) + : m_entries(init) + { + } + + Path::Path(AZStd::string_view pathString) + { + FromString(pathString); + } + + Path Path::operator/(const PathEntry& entry) const + { + Path newPath(*this); + newPath /= entry; + return newPath; + } + + Path Path::operator/(size_t index) const + { + return *this / PathEntry(index); + } + + Path Path::operator/(AZ::Name key) const + { + return *this / PathEntry(key); + } + + Path Path::operator/(AZStd::string_view key) const + { + return *this / PathEntry(key); + } + + Path Path::operator/(const Path& other) const + { + Path newPath(*this); + newPath /= other; + return newPath; + } + + Path& Path::operator/=(const PathEntry& entry) + { + Push(entry); + return *this; + } + + Path& Path::operator/=(size_t index) + { + return *this /= PathEntry(index); + } + + Path& Path::operator/=(AZ::Name key) + { + return *this /= PathEntry(key); + } + + Path& Path::operator/=(AZStd::string_view key) + { + return *this /= PathEntry(key); + } + + Path& Path::operator/=(const Path& other) + { + for (const PathEntry& entry : other) + { + Push(entry); + } + return *this; + } + + bool Path::operator==(const Path& other) const + { + return m_entries == other.m_entries; + } + + const Path::ContainerType& Path::GetEntries() const + { + return m_entries; + } + + void Path::Push(PathEntry entry) + { + m_entries.push_back(AZStd::move(entry)); + } + + void Path::Push(size_t entry) + { + Push(PathEntry(entry)); + } + + void Path::Push(AZ::Name entry) + { + Push(PathEntry(AZStd::move(entry))); + } + + void Path::Push(AZStd::string_view entry) + { + Push(AZ::Name(entry)); + } + + void Path::Pop() + { + m_entries.pop_back(); + } + + void Path::Clear() + { + m_entries.clear(); + } + + PathEntry Path::At(size_t index) const + { + if (index < m_entries.size()) + { + return m_entries[index]; + } + return {}; + } + + size_t Path::Size() const + { + return m_entries.size(); + } + + PathEntry& Path::operator[](size_t index) + { + return m_entries[index]; + } + + const PathEntry& Path::operator[](size_t index) const + { + return m_entries[index]; + } + + Path::ContainerType::iterator Path::begin() + { + return m_entries.begin(); + } + + Path::ContainerType::iterator Path::end() + { + return m_entries.end(); + } + + Path::ContainerType::const_iterator Path::begin() const + { + return m_entries.cbegin(); + } + + Path::ContainerType::const_iterator Path::end() const + { + return m_entries.cend(); + } + + Path::ContainerType::const_iterator Path::cbegin() const + { + return m_entries.cbegin(); + } + + Path::ContainerType::const_iterator Path::cend() const + { + return m_entries.cend(); + } + + size_t Path::size() const + { + return m_entries.size(); + } + + size_t Path::GetStringLength() const + { + size_t size = 0; + for (const PathEntry& entry : m_entries) + { + ++size; + if (entry.IsEndOfArray()) + { + size += 1; + } + else if (entry.IsIndex()) + { + const size_t index = entry.GetIndex(); + const double digitCount = index > 0 ? log10(aznumeric_cast(index + 1)) : 1.0; + size += aznumeric_cast(ceil(digitCount)); + } + else + { + const char* nameBuffer = entry.GetKey().GetCStr(); + for (size_t i = 0; nameBuffer[i]; ++i) + { + if (nameBuffer[i] == EscapeCharacter || nameBuffer[i] == PathSeparator) + { + ++size; + } + ++size; + } + } + } + return size; + } + + void Path::FormatString(char* stringBuffer, size_t bufferSize) const + { + size_t bufferIndex = 0; + + auto putChar = [&](char c) + { + if (bufferIndex == bufferSize) + { + return; + } + stringBuffer[bufferIndex++] = c; + }; + + auto writeToBuffer = [&](const char* key) + { + for (size_t keyIndex = 0; key[keyIndex]; ++keyIndex) + { + const char c = key[keyIndex]; + if (c == EscapeCharacter) + { + putChar(EscapeCharacter); + putChar(TildeSequence); + } + else if (c == PathSeparator) + { + putChar(EscapeCharacter); + putChar(ForwardSlashSequence); + } + else + { + putChar(c); + } + } + }; + + for (const PathEntry& entry : m_entries) + { + putChar(PathSeparator); + if (entry.IsEndOfArray()) + { + putChar(EndOfArrayCharacter); + } + else if (entry.IsIndex()) + { + bufferIndex += azsnprintf(&stringBuffer[bufferIndex], bufferSize - bufferIndex, "%zu", entry.GetIndex()); + } + else + { + writeToBuffer(entry.GetKey().GetCStr()); + } + } + + putChar('\0'); + } + + AZStd::string Path::ToString() const + { + AZStd::string formattedString; + const size_t size = GetStringLength(); + formattedString.resize_no_construct(size); + FormatString(formattedString.data(), size + 1); + return formattedString; + } + + void Path::AppendToString(AZStd::string& output) const + { + const size_t startIndex = output.length(); + const size_t stringLength = GetStringLength(); + output.resize_no_construct(startIndex + stringLength); + FormatString(output.data() + startIndex, stringLength + 1); + } + + void Path::FromString(AZStd::string_view pathString) + { + m_entries.clear(); + if (pathString.empty()) + { + return; + } + + size_t pathEntryCount = 0; + for (size_t i = 1; i <= pathString.size(); ++i) + { + if (pathString[i] == PathSeparator) + { + ++pathEntryCount; + } + } + m_entries.reserve(pathEntryCount); + + // Ignore a preceeding path separator and start processing after it + size_t pathIndex = pathString[0] == PathSeparator ? 1 : 0; + bool isNumber = true; + AZStd::string convertedSection; + for (size_t i = pathIndex; i <= pathString.size(); ++i) + { + if (i == pathString.size() || pathString[i] == PathSeparator) + { + AZStd::string_view section = pathString.substr(pathIndex, i - pathIndex); + if (section.size() == 1 && section[0] == EndOfArrayCharacter) + { + PathEntry entry; + entry.SetEndOfArray(); + m_entries.push_back(AZStd::move(entry)); + } + else if (isNumber && !section.empty()) + { + size_t index = 0; + ConsoleTypeHelpers::StringToValue(index, section); + m_entries.push_back(PathEntry{ index }); + } + else + { + convertedSection.clear(); + size_t lastPos = 0; + size_t posToEscape = section.find(EscapeCharacter); + while (posToEscape != AZStd::string_view::npos) + { + if (convertedSection.empty()) + { + convertedSection.reserve(section.size() - 1); + } + convertedSection += section.substr(lastPos, posToEscape - lastPos); + if (section[posToEscape + 1] == ForwardSlashSequence) + { + convertedSection += '/'; + } + else + { + convertedSection += '~'; + } + + lastPos = posToEscape + 2; + posToEscape = section.find(EscapeCharacter, posToEscape + 2); + } + + if (!convertedSection.empty()) + { + convertedSection += section.substr(lastPos); + m_entries.emplace_back(convertedSection); + } + else + { + m_entries.emplace_back(section); + } + } + pathIndex = i + 1; + isNumber = true; + continue; + } + + const char c = pathString[i]; + isNumber = isNumber && c >= '0' && c <= '9'; + } + } +} // namespace AZ::Dom diff --git a/Code/Framework/AzCore/AzCore/DOM/DomPath.h b/Code/Framework/AzCore/AzCore/DOM/DomPath.h new file mode 100644 index 0000000000..39f7c7da98 --- /dev/null +++ b/Code/Framework/AzCore/AzCore/DOM/DomPath.h @@ -0,0 +1,144 @@ +/* + * 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 + +namespace AZ::Dom +{ + //! Represents the path to a direct descendant of a Value. + //! PathEntry may be one of the following: + //! - Index, a numerical index for indexing within Arrays and Nodes + //! - Key, a name for indexing within Objects and Nodes + //! - EndOfArray, a special-case indicator for representing the end of an array + //! used by the patching system to represent push / pop back operations. + class PathEntry final + { + public: + static constexpr size_t EndOfArrayIndex = size_t(-1); + + PathEntry() = default; + PathEntry(const PathEntry&) = default; + PathEntry(PathEntry&&) = default; + explicit PathEntry(size_t value); + explicit PathEntry(AZ::Name value); + explicit PathEntry(AZStd::string_view value); + + PathEntry& operator=(const PathEntry&) = default; + PathEntry& operator=(PathEntry&&) = default; + PathEntry& operator=(size_t value); + PathEntry& operator=(AZ::Name value); + PathEntry& operator=(AZStd::string_view value); + + bool operator==(const PathEntry& other) const; + bool operator==(size_t index) const; + bool operator==(const AZ::Name& key) const; + bool operator==(AZStd::string_view key) const; + bool operator!=(const PathEntry& other) const; + bool operator!=(size_t index) const; + bool operator!=(const AZ::Name& key) const; + bool operator!=(AZStd::string_view key) const; + + void SetEndOfArray(); + + bool IsEndOfArray() const; + bool IsIndex() const; + bool IsKey() const; + + size_t GetIndex() const; + const AZ::Name& GetKey() const; + + private: + AZStd::variant m_value; + }; + + //! Represents a path, represented as a series of PathEntry values, to a position in a Value. + class Path final + { + public: + using ContainerType = AZStd::vector; + static constexpr char PathSeparator = '/'; + static constexpr char EscapeCharacter = '~'; + static constexpr char TildeSequence = '0'; + static constexpr char ForwardSlashSequence = '1'; + static constexpr char EndOfArrayCharacter = '-'; + + Path() = default; + Path(const Path&) = default; + Path(Path&&) = default; + explicit Path(AZStd::initializer_list init); + //! Creates a Path from a path string, a path string is formatted per the JSON pointer specification + //! and looks like "/path/to/value/0" + explicit Path(AZStd::string_view pathString); + + template + explicit Path(InputIterator first, InputIterator last) + : m_entries(first, last) + { + } + + Path& operator=(const Path&) = default; + Path& operator=(Path&&) = default; + + Path operator/(const PathEntry&) const; + Path operator/(size_t) const; + Path operator/(AZ::Name) const; + Path operator/(AZStd::string_view) const; + Path operator/(const Path&) const; + + Path& operator/=(const PathEntry&); + Path& operator/=(size_t); + Path& operator/=(AZ::Name); + Path& operator/=(AZStd::string_view); + Path& operator/=(const Path&); + + bool operator==(const Path&) const; + + const ContainerType& GetEntries() const; + void Push(PathEntry entry); + void Push(size_t entry); + void Push(AZ::Name entry); + void Push(AZStd::string_view key); + void Pop(); + void Clear(); + PathEntry At(size_t index) const; + size_t Size() const; + + PathEntry& operator[](size_t index); + const PathEntry& operator[](size_t index) const; + + ContainerType::iterator begin(); + ContainerType::iterator end(); + ContainerType::const_iterator begin() const; + ContainerType::const_iterator end() const; + ContainerType::const_iterator cbegin() const; + ContainerType::const_iterator cend() const; + size_t size() const; + + //! Gets the length this path would require, if string-formatted. + //! The length includes the contents of the string but not a null terminator. + size_t GetStringLength() const; + //! Formats a JSON-pointer style path string into the target buffer. + //! This operation will fail if bufferSize < GetStringLength() + 1 + void FormatString(char* stringBuffer, size_t bufferSize) const; + //! Returns a JSON-pointer style path string for this path. + AZStd::string ToString() const; + void AppendToString(AZStd::string& output) const; + //! Reads a JSON-pointer style path from pathString and replaces this path's contents. + //! Paths are accepted in the following forms: + //! "/path/to/foo/0" + //! "path/to/foo/0" + void FromString(AZStd::string_view pathString); + + private: + ContainerType m_entries; + }; +} // namespace AZ::Dom diff --git a/Code/Framework/AzCore/AzCore/DOM/DomValue.cpp b/Code/Framework/AzCore/AzCore/DOM/DomValue.cpp index 10c8e33715..793fadd092 100644 --- a/Code/Framework/AzCore/AzCore/DOM/DomValue.cpp +++ b/Code/Framework/AzCore/AzCore/DOM/DomValue.cpp @@ -6,6 +6,7 @@ * */ +#include #include #include #include @@ -1177,4 +1178,124 @@ namespace AZ::Dom { return m_value; } + + Value& Value::operator[](const PathEntry& entry) + { + if (entry.IsEndOfArray()) + { + Array::ContainerType& array = GetArrayInternal(); + array.push_back(); + return array[array.size() - 1]; + } + return entry.IsIndex() ? operator[](entry.GetIndex()) : operator[](entry.GetKey()); + } + + const Value& Value::operator[](const PathEntry& entry) const + { + return entry.IsIndex() ? operator[](entry.GetIndex()) : operator[](entry.GetKey()); + } + + Value& Value::operator[](const Path& path) + { + Value* value = this; + for (const PathEntry& entry : path) + { + value = &value->operator[](entry); + } + return *value; + } + + const Value& Value::operator[](const Path& path) const + { + const Value* value = this; + for (const PathEntry& entry : path) + { + value = &value->operator[](entry); + } + return *value; + } + + const Value* Value::FindChild(const PathEntry& entry) const + { + if (entry.IsEndOfArray()) + { + return nullptr; + } + else if (entry.IsIndex()) + { + const Array::ContainerType& array = GetArrayInternal(); + const size_t index = entry.GetIndex(); + if (index < array.size()) + { + return &array[index]; + } + } + else + { + const Object::ContainerType& obj = GetObjectInternal(); + auto memberIt = FindMember(entry.GetKey()); + if (memberIt != obj.end()) + { + return &memberIt->second; + } + } + return nullptr; + } + + Value* Value::FindMutableChild(const PathEntry& entry) + { + if (entry.IsEndOfArray()) + { + Array::ContainerType& array = GetArrayInternal(); + array.push_back(); + return &array[array.size() - 1]; + } + else if (entry.IsIndex()) + { + Array::ContainerType& array = GetArrayInternal(); + const size_t index = entry.GetIndex(); + if (index < array.size()) + { + return &array[index]; + } + } + else + { + Object::ContainerType& obj = GetObjectInternal(); + auto memberIt = FindMutableMember(entry.GetKey()); + if (memberIt != obj.end()) + { + return &memberIt->second; + } + } + return nullptr; + } + + const Value* Value::FindChild(const Path& path) const + { + const Value* value = this; + for (const PathEntry& entry : path) + { + value = value->FindChild(entry); + if (value == nullptr) + { + return nullptr; + } + } + return value; + } + + Value* Value::FindMutableChild(const Path& path) + { + Value* value = this; + for (const PathEntry& entry : path) + { + value = value->FindMutableChild(entry); + if (value == nullptr) + { + return nullptr; + } + } + return value; + } } // namespace AZ::Dom diff --git a/Code/Framework/AzCore/AzCore/DOM/DomValue.h b/Code/Framework/AzCore/AzCore/DOM/DomValue.h index d1d3c1745d..be5d855003 100644 --- a/Code/Framework/AzCore/AzCore/DOM/DomValue.h +++ b/Code/Framework/AzCore/AzCore/DOM/DomValue.h @@ -22,6 +22,8 @@ namespace AZ::Dom { + class PathEntry; + class Path; using KeyType = AZ::Name; //! The type of underlying value stored in a value. \see Value @@ -380,6 +382,17 @@ namespace AZ::Dom Visitor::Result Accept(Visitor& visitor, bool copyStrings) const; AZStd::unique_ptr GetWriteHandler(); + // Path API... + Value& operator[](const PathEntry& entry); + const Value& operator[](const PathEntry& entry) const; + Value& operator[](const Path& path); + const Value& operator[](const Path& path) const; + + const Value* FindChild(const PathEntry& entry) const; + Value* FindMutableChild(const PathEntry& entry); + const Value* FindChild(const Path& path) const; + Value* FindMutableChild(const Path& path); + //! Gets the internal value of this Value. Note that this value's types may not correspond one-to-one with the Type enumeration, //! as internally the same type might have different storage mechanisms. Where possible, prefer using the typed API. const ValueType& GetInternalValue() const; diff --git a/Code/Framework/AzCore/AzCore/Debug/Profiler.h b/Code/Framework/AzCore/AzCore/Debug/Profiler.h index 6e86de2e93..6b27b35f53 100644 --- a/Code/Framework/AzCore/AzCore/Debug/Profiler.h +++ b/Code/Framework/AzCore/AzCore/Debug/Profiler.h @@ -10,11 +10,6 @@ #include #include -#ifdef USE_PIX -#include -#include -#endif - #if defined(AZ_PROFILER_MACRO_DISABLE) // by default we never disable the profiler registers as their overhead should be minimal, you can // still do that for your code though. #define AZ_PROFILE_SCOPE(...) diff --git a/Code/Framework/AzCore/AzCore/Debug/Profiler.inl b/Code/Framework/AzCore/AzCore/Debug/Profiler.inl index 74c0f553c4..c820639b09 100644 --- a/Code/Framework/AzCore/AzCore/Debug/Profiler.inl +++ b/Code/Framework/AzCore/AzCore/Debug/Profiler.inl @@ -10,44 +10,48 @@ namespace AZ::Debug { + namespace Platform + { + template + void BeginProfileRegion(Budget* budget, const char* eventName, T const&... args); + void BeginProfileRegion(Budget* budget, const char* eventName); + void EndProfileRegion(Budget* budget); + } // namespace Platform + template void ProfileScope::BeginRegion( [[maybe_unused]] Budget* budget, [[maybe_unused]] const char* eventName, [[maybe_unused]] T const&... args) { - if (!budget) + #if !defined(_RELEASE) + if (budget) { - return; - } -#if !defined(_RELEASE) - // TODO: Verification that the supplied system name corresponds to a known budget -#if defined(USE_PIX) - PIXBeginEvent(PIX_COLOR_INDEX(budget->Crc() & 0xff), eventName, args...); -#endif - budget->BeginProfileRegion(); + Platform::BeginProfileRegion(budget, eventName, args...); - if (auto profiler = AZ::Interface::Get(); profiler) - { - profiler->BeginRegion(budget, eventName); + budget->BeginProfileRegion(); + + if (auto profiler = AZ::Interface::Get(); profiler) + { + profiler->BeginRegion(budget, eventName); + } } -#endif + #endif // #if !defined(_RELEASE) } inline void ProfileScope::EndRegion([[maybe_unused]] Budget* budget) { - if (!budget) + #if !defined(_RELEASE) + if (budget) { - return; + budget->EndProfileRegion(); + + if (auto profiler = AZ::Interface::Get(); profiler) + { + profiler->EndRegion(budget); + } + + Platform::EndProfileRegion(budget); } -#if !defined(_RELEASE) - budget->EndProfileRegion(); -#if defined(USE_PIX) - PIXEndEvent(); -#endif - if (auto profiler = AZ::Interface::Get(); profiler) - { - profiler->EndRegion(budget); - } -#endif + #endif // !defined(_RELEASE) } template @@ -63,3 +67,5 @@ namespace AZ::Debug } } // namespace AZ::Debug + +#include diff --git a/Code/Framework/AzCore/AzCore/IO/IStreamer.h b/Code/Framework/AzCore/AzCore/IO/IStreamer.h index 438384e687..d59ee5007e 100644 --- a/Code/Framework/AzCore/AzCore/IO/IStreamer.h +++ b/Code/Framework/AzCore/AzCore/IO/IStreamer.h @@ -15,14 +15,18 @@ #include #include #include +#include // These Streamer includes need to be moved to Streamer internals/implementation, // and pull out only what we need for visibility at IStreamer.h interface declaration. #include -#include namespace AZ::IO { + class ExternalFileRequest; + class FileRequestHandle; + + using FileRequestPtr = AZStd::intrusive_ptr; /** * Data Streamer Interface */ diff --git a/Code/Framework/AzCore/AzCore/IO/Path/Path.cpp b/Code/Framework/AzCore/AzCore/IO/Path/Path.cpp index 6e4dfdaa63..028ffaf535 100644 --- a/Code/Framework/AzCore/AzCore/IO/Path/Path.cpp +++ b/Code/Framework/AzCore/AzCore/IO/Path/Path.cpp @@ -15,9 +15,9 @@ namespace AZ::IO // Class template instantations template class BasicPath; template class BasicPath; - template class PathIterator; - template class PathIterator; - template class PathIterator; + template class PathIterator; + template class PathIterator; + template class PathIterator; // Swap function instantiations template void swap(Path& lhs, Path& rhs) noexcept; @@ -38,16 +38,16 @@ namespace AZ::IO const typename BasicPath::value_type* rhs); // Iterator compare instantiations - template bool operator==(const PathIterator& lhs, - const PathIterator& rhs); - template bool operator==(const PathIterator& lhs, - const PathIterator& rhs); - template bool operator==(const PathIterator& lhs, - const PathIterator& rhs); - template bool operator!=(const PathIterator& lhs, - const PathIterator& rhs); - template bool operator!=(const PathIterator& lhs, - const PathIterator& rhs); - template bool operator!=(const PathIterator& lhs, - const PathIterator& rhs); + template bool operator==(const PathIterator& lhs, + const PathIterator& rhs); + template bool operator==(const PathIterator& lhs, + const PathIterator& rhs); + template bool operator==(const PathIterator& lhs, + const PathIterator& rhs); + template bool operator!=(const PathIterator& lhs, + const PathIterator& rhs); + template bool operator!=(const PathIterator& lhs, + const PathIterator& rhs); + template bool operator!=(const PathIterator& lhs, + const PathIterator& rhs); } diff --git a/Code/Framework/AzCore/AzCore/IO/Path/Path.h b/Code/Framework/AzCore/AzCore/IO/Path/Path.h index 7f89809294..235310a5da 100644 --- a/Code/Framework/AzCore/AzCore/IO/Path/Path.h +++ b/Code/Framework/AzCore/AzCore/IO/Path/Path.h @@ -43,9 +43,9 @@ namespace AZ::IO public: using string_view_type = AZStd::string_view; using value_type = char; - using const_iterator = const PathIterator; + using const_iterator = PathIterator; using iterator = const_iterator; - friend PathIterator; + friend const_iterator; // constructors and destructor constexpr PathView() = default; @@ -319,9 +319,9 @@ namespace AZ::IO using value_type = typename StringType::value_type; using traits_type = typename StringType::traits_type; using string_view_type = AZStd::string_view; - using const_iterator = const PathIterator; + using const_iterator = PathIterator; using iterator = const_iterator; - friend PathIterator; + friend const_iterator; // constructors and destructor constexpr BasicPath() = default; @@ -692,7 +692,7 @@ namespace AZ::IO friend PathType; using iterator_category = AZStd::bidirectional_iterator_tag; - using value_type = PathType; + using value_type = AZStd::remove_cv_t; using difference_type = ptrdiff_t; using pointer = const value_type*; using reference = const value_type&; @@ -703,8 +703,9 @@ namespace AZ::IO constexpr PathIterator() = default; constexpr PathIterator(const PathIterator&) = default; - + constexpr PathIterator(PathIterator&&) noexcept = default; constexpr PathIterator& operator=(const PathIterator&) = default; + constexpr PathIterator& operator=(PathIterator&&) noexcept = default; constexpr reference operator*() const; @@ -733,10 +734,10 @@ namespace AZ::IO ParserState m_state{ Singular }; }; - template - constexpr bool operator==(const PathIterator& lhs, const PathIterator& rhs); - template - constexpr bool operator!=(const PathIterator& lhs, const PathIterator& rhs); + template + constexpr bool operator==(const PathIterator& lhs, const PathIterator& rhs); + template + constexpr bool operator!=(const PathIterator& lhs, const PathIterator& rhs); } #include diff --git a/Code/Framework/AzCore/AzCore/IO/Path/Path.inl b/Code/Framework/AzCore/AzCore/IO/Path/Path.inl index ab991e1750..bde2353112 100644 --- a/Code/Framework/AzCore/AzCore/IO/Path/Path.inl +++ b/Code/Framework/AzCore/AzCore/IO/Path/Path.inl @@ -399,7 +399,7 @@ namespace AZ::IO constexpr auto PathView::begin() const -> const_iterator { auto pathParser = parser::PathParser::CreateBegin(m_path, m_preferred_separator); - PathIterator it; + const_iterator it; it.m_path_ref = this; it.m_state = static_cast(pathParser.m_parser_state); it.m_path_entry_view = pathParser.m_path_raw_entry; @@ -409,7 +409,7 @@ namespace AZ::IO constexpr auto PathView::end() const -> const_iterator { - PathIterator it; + const_iterator it; it.m_state = const_iterator::AtEnd; it.m_path_ref = this; return it; @@ -1262,7 +1262,7 @@ namespace AZ::IO constexpr auto BasicPath::begin() const -> const_iterator { auto pathParser = parser::PathParser::CreateBegin(m_path, m_preferred_separator); - PathIterator it; + const_iterator it; it.m_path_ref = this; it.m_state = static_cast(pathParser.m_parser_state); it.m_path_entry_view = pathParser.m_path_raw_entry; @@ -1273,7 +1273,7 @@ namespace AZ::IO template constexpr auto BasicPath::end() const -> const_iterator { - PathIterator it; + const_iterator it; it.m_state = const_iterator::AtEnd; it.m_path_ref = this; return it; @@ -1529,16 +1529,16 @@ namespace AZ::IO const typename BasicPath::value_type* rhs); // Iterator compare explicit declarations - extern template bool operator==(const PathIterator& lhs, - const PathIterator& rhs); - extern template bool operator==(const PathIterator& lhs, - const PathIterator& rhs); - extern template bool operator==(const PathIterator& lhs, - const PathIterator& rhs); - extern template bool operator!=(const PathIterator& lhs, - const PathIterator& rhs); - extern template bool operator!=(const PathIterator& lhs, - const PathIterator& rhs); - extern template bool operator!=(const PathIterator& lhs, - const PathIterator& rhs); + extern template bool operator==(const PathIterator& lhs, + const PathIterator& rhs); + extern template bool operator==(const PathIterator& lhs, + const PathIterator& rhs); + extern template bool operator==(const PathIterator& lhs, + const PathIterator& rhs); + extern template bool operator!=(const PathIterator& lhs, + const PathIterator& rhs); + extern template bool operator!=(const PathIterator& lhs, + const PathIterator& rhs); + extern template bool operator!=(const PathIterator& lhs, + const PathIterator& rhs); } diff --git a/Code/Framework/AzCore/AzCore/IO/Path/PathParser.inl b/Code/Framework/AzCore/AzCore/IO/Path/PathParser.inl index b19c518ff9..f8712551b0 100644 --- a/Code/Framework/AzCore/AzCore/IO/Path/PathParser.inl +++ b/Code/Framework/AzCore/AzCore/IO/Path/PathParser.inl @@ -10,6 +10,7 @@ #include #include +#include namespace AZ::IO::Internal { @@ -17,7 +18,7 @@ namespace AZ::IO::Internal { return elem == '/' || elem == '\\'; } - template >> + template >> static constexpr bool HasDrivePrefix(InputIt first, EndIt last) { size_t prefixSize = AZStd::distance(first, last); @@ -46,7 +47,7 @@ namespace AZ::IO::Internal //! Windows root names can have include drive letter within them template constexpr auto ConsumeRootName(InputIt entryBeginIter, InputIt entryEndIter, const char preferredSeparator) - -> AZStd::enable_if_t, InputIt> + -> AZStd::enable_if_t, InputIt> { if (preferredSeparator == PosixPathSeparator) { @@ -147,7 +148,7 @@ namespace AZ::IO::Internal //! If the preferred separator is '/' just checks if the path starts with a '/ //! Otherwise a check for a Windows absolute path occurs //! Windows absolute paths can include a RootName - template >> + template >> static constexpr bool IsAbsolute(InputIt first, EndIt last, const char preferredSeparator) { size_t pathSize = AZStd::distance(first, last); @@ -208,11 +209,11 @@ namespace AZ::IO::parser enum ParserState : uint8_t { // Zero is a special sentinel value used by default constructed iterators. - PS_BeforeBegin = PathIterator::BeforeBegin, - PS_InRootName = PathIterator::InRootName, - PS_InRootDir = PathIterator::InRootDir, - PS_InFilenames = PathIterator::InFilenames, - PS_AtEnd = PathIterator::AtEnd + PS_BeforeBegin = PathView::const_iterator::BeforeBegin, + PS_InRootName = PathView::const_iterator::InRootName, + PS_InRootDir = PathView::const_iterator::InRootDir, + PS_InFilenames = PathView::const_iterator::InFilenames, + PS_AtEnd = PathView::const_iterator::AtEnd }; struct PathParser diff --git a/Code/Framework/AzCore/AzCore/IO/Streamer/BlockCache.cpp b/Code/Framework/AzCore/AzCore/IO/Streamer/BlockCache.cpp index 6c873f3050..ca38414eaa 100644 --- a/Code/Framework/AzCore/AzCore/IO/Streamer/BlockCache.cpp +++ b/Code/Framework/AzCore/AzCore/IO/Streamer/BlockCache.cpp @@ -137,18 +137,18 @@ namespace AZ::IO AZStd::visit([this, request](auto&& args) { using Command = AZStd::decay_t; - if constexpr (AZStd::is_same_v) + if constexpr (AZStd::is_same_v) { ReadFile(request, args); return; } else { - if constexpr (AZStd::is_same_v) + if constexpr (AZStd::is_same_v) { FlushCache(args.m_path); } - else if constexpr (AZStd::is_same_v) + else if constexpr (AZStd::is_same_v) { FlushEntireCache(); } @@ -166,7 +166,7 @@ namespace AZ::IO { Section& delayed = m_delayedSections.front(); AZ_Assert(delayed.m_parent, "Delayed section doesn't have a reference to the original request."); - auto data = AZStd::get_if(&delayed.m_parent->GetCommand()); + auto data = AZStd::get_if(&delayed.m_parent->GetCommand()); AZ_Assert(data, "A request in the delayed queue of the BlockCache didn't have a parent with read data."); // This call can add the same section to the back of the queue if there's not // enough space. Because of this the entry needs to be removed from the delayed @@ -233,7 +233,7 @@ namespace AZ::IO } } - void BlockCache::ReadFile(FileRequest* request, FileRequest::ReadData& data) + void BlockCache::ReadFile(FileRequest* request, Requests::ReadData& data) { if (!m_next) { @@ -250,7 +250,7 @@ namespace AZ::IO m_numMetaDataRetrievalInProgress--; if (fileSizeRequest.GetStatus() == IStreamerTypes::RequestStatus::Completed) { - auto& requestInfo = AZStd::get(fileSizeRequest.GetCommand()); + auto& requestInfo = AZStd::get(fileSizeRequest.GetCommand()); if (requestInfo.m_found) { ContinueReadFile(request, requestInfo.m_fileSize); @@ -272,7 +272,7 @@ namespace AZ::IO Section main; Section epilog; - auto& data = AZStd::get(request->GetCommand()); + auto& data = AZStd::get(request->GetCommand()); if (!SplitRequest(prolog, main, epilog, data.m_path, fileLength, data.m_offset, data.m_size, reinterpret_cast(data.m_output))) diff --git a/Code/Framework/AzCore/AzCore/IO/Streamer/BlockCache.h b/Code/Framework/AzCore/AzCore/IO/Streamer/BlockCache.h index 90fb7ea193..68aa2da689 100644 --- a/Code/Framework/AzCore/AzCore/IO/Streamer/BlockCache.h +++ b/Code/Framework/AzCore/AzCore/IO/Streamer/BlockCache.h @@ -21,6 +21,12 @@ namespace AZ::IO { + class RequestPath; + namespace Requests + { + struct ReadData; + } + struct BlockCacheConfig final : public IStreamerStackConfig { @@ -109,7 +115,7 @@ namespace AZ::IO using TimePoint = AZStd::chrono::system_clock::time_point; - void ReadFile(FileRequest* request, FileRequest::ReadData& data); + void ReadFile(FileRequest* request, Requests::ReadData& data); void ContinueReadFile(FileRequest* request, u64 fileLength); CacheResult ReadFromCache(FileRequest* request, Section& section, const RequestPath& filePath); CacheResult ReadFromCache(FileRequest* request, Section& section, u32 cacheBlock); diff --git a/Code/Framework/AzCore/AzCore/IO/Streamer/DedicatedCache.cpp b/Code/Framework/AzCore/AzCore/IO/Streamer/DedicatedCache.cpp index b80a1ea724..f155d26eef 100644 --- a/Code/Framework/AzCore/AzCore/IO/Streamer/DedicatedCache.cpp +++ b/Code/Framework/AzCore/AzCore/IO/Streamer/DedicatedCache.cpp @@ -101,12 +101,12 @@ namespace AZ::IO AZStd::visit([this, request](auto&& args) { using Command = AZStd::decay_t; - if constexpr (AZStd::is_same_v) + if constexpr (AZStd::is_same_v) { args.m_range = FileRange::CreateRangeForEntireFile(); m_context->PushPreparedRequest(request); } - else if constexpr (AZStd::is_same_v) + else if constexpr (AZStd::is_same_v) { args.m_range = FileRange::CreateRangeForEntireFile(); m_context->PushPreparedRequest(request); @@ -125,28 +125,28 @@ namespace AZ::IO AZStd::visit([this, request](auto&& args) { using Command = AZStd::decay_t; - if constexpr (AZStd::is_same_v) + if constexpr (AZStd::is_same_v) { ReadFile(request, args); return; } - else if constexpr (AZStd::is_same_v) + else if constexpr (AZStd::is_same_v) { CreateDedicatedCache(request, args); return; } - else if constexpr (AZStd::is_same_v) + else if constexpr (AZStd::is_same_v) { DestroyDedicatedCache(request, args); return; } else { - if constexpr (AZStd::is_same_v) + if constexpr (AZStd::is_same_v) { FlushCache(args.m_path); } - else if constexpr (AZStd::is_same_v) + else if constexpr (AZStd::is_same_v) { FlushEntireCache(); } @@ -200,7 +200,7 @@ namespace AZ::IO } } - void DedicatedCache::ReadFile(FileRequest* request, FileRequest::ReadData& data) + void DedicatedCache::ReadFile(FileRequest* request, Requests::ReadData& data) { size_t index = FindCache(data.m_path, data.m_offset); if (index == s_fileNotFound) @@ -255,7 +255,7 @@ namespace AZ::IO StreamStackEntry::CollectStatistics(statistics); } - void DedicatedCache::CreateDedicatedCache(FileRequest* request, FileRequest::CreateDedicatedCacheData& data) + void DedicatedCache::CreateDedicatedCache(FileRequest* request, Requests::CreateDedicatedCacheData& data) { size_t index = FindCache(data.m_path, data.m_range); if (index == s_fileNotFound) @@ -276,7 +276,7 @@ namespace AZ::IO m_context->MarkRequestAsCompleted(request); } - void DedicatedCache::DestroyDedicatedCache(FileRequest* request, FileRequest::DestroyDedicatedCacheData& data) + void DedicatedCache::DestroyDedicatedCache(FileRequest* request, Requests::DestroyDedicatedCacheData& data) { size_t index = FindCache(data.m_path, data.m_range); if (index != s_fileNotFound) diff --git a/Code/Framework/AzCore/AzCore/IO/Streamer/DedicatedCache.h b/Code/Framework/AzCore/AzCore/IO/Streamer/DedicatedCache.h index 0ef2d879d3..85aa29a051 100644 --- a/Code/Framework/AzCore/AzCore/IO/Streamer/DedicatedCache.h +++ b/Code/Framework/AzCore/AzCore/IO/Streamer/DedicatedCache.h @@ -11,15 +11,21 @@ #include #include #include -#include #include +#include #include -#include #include +#include #include namespace AZ::IO { + namespace Requests + { + struct CreateDedicatedCacheData; + struct DestroyDedicatedCacheData; + } // namespace Requests + struct DedicatedCacheConfig final : public IStreamerStackConfig { @@ -56,16 +62,19 @@ namespace AZ::IO void UpdateStatus(Status& status) const override; - void UpdateCompletionEstimates(AZStd::chrono::system_clock::time_point now, AZStd::vector& internalPending, - StreamerContext::PreparedQueue::iterator pendingBegin, StreamerContext::PreparedQueue::iterator pendingEnd) override; + void UpdateCompletionEstimates( + AZStd::chrono::system_clock::time_point now, + AZStd::vector& internalPending, + StreamerContext::PreparedQueue::iterator pendingBegin, + StreamerContext::PreparedQueue::iterator pendingEnd) override; void CollectStatistics(AZStd::vector& statistics) const override; private: - void CreateDedicatedCache(FileRequest* request, FileRequest::CreateDedicatedCacheData& data); - void DestroyDedicatedCache(FileRequest* request, FileRequest::DestroyDedicatedCacheData& data); + void CreateDedicatedCache(FileRequest* request, Requests::CreateDedicatedCacheData& data); + void DestroyDedicatedCache(FileRequest* request, Requests::DestroyDedicatedCacheData& data); - void ReadFile(FileRequest* request, FileRequest::ReadData& data); + void ReadFile(FileRequest* request, Requests::ReadData& data); size_t FindCache(const RequestPath& filename, FileRange range); size_t FindCache(const RequestPath& filename, u64 offset); diff --git a/Code/Framework/AzCore/AzCore/IO/Streamer/FileRequest.cpp b/Code/Framework/AzCore/AzCore/IO/Streamer/FileRequest.cpp index fc05b77b36..13c01b2efc 100644 --- a/Code/Framework/AzCore/AzCore/IO/Streamer/FileRequest.cpp +++ b/Code/Framework/AzCore/AzCore/IO/Streamer/FileRequest.cpp @@ -12,22 +12,30 @@ #include #include -namespace AZ::IO +// +// Command structures. +// + +namespace AZ::IO::Requests { - // - // Command structures. - // + ReadData::ReadData(void* output, u64 outputSize, const RequestPath& path, u64 offset, u64 size, bool sharedRead) + : m_path(path) + , m_output(output) + , m_outputSize(outputSize) + , m_offset(offset) + , m_size(size) + , m_sharedRead(sharedRead) + { + } - FileRequest::ExternalRequestData::ExternalRequestData(FileRequestPtr&& request) - : m_request(AZStd::move(request)) - {} - - FileRequest::RequestPathStoreData::RequestPathStoreData(RequestPath path) - : m_path(AZStd::move(path)) - {} - - FileRequest::ReadRequestData::ReadRequestData(RequestPath path, void* output, u64 outputSize, u64 offset, u64 size, - AZStd::chrono::system_clock::time_point deadline, IStreamerTypes::Priority priority) + ReadRequestData::ReadRequestData( + RequestPath path, + void* output, + u64 outputSize, + u64 offset, + u64 size, + AZStd::chrono::system_clock::time_point deadline, + IStreamerTypes::Priority priority) : m_path(AZStd::move(path)) , m_allocator(nullptr) , m_deadline(deadline) @@ -37,10 +45,16 @@ namespace AZ::IO , m_size(size) , m_priority(priority) , m_memoryType(IStreamerTypes::MemoryType::ReadWrite) // Only generic memory can be assigned externally. - {} + { + } - FileRequest::ReadRequestData::ReadRequestData(RequestPath path, IStreamerTypes::RequestMemoryAllocator* allocator, - u64 offset, u64 size, AZStd::chrono::system_clock::time_point deadline, IStreamerTypes::Priority priority) + ReadRequestData::ReadRequestData( + RequestPath path, + IStreamerTypes::RequestMemoryAllocator* allocator, + u64 offset, + u64 size, + AZStd::chrono::system_clock::time_point deadline, + IStreamerTypes::Priority priority) : m_path(AZStd::move(path)) , m_allocator(allocator) , m_deadline(deadline) @@ -50,9 +64,10 @@ namespace AZ::IO , m_size(size) , m_priority(priority) , m_memoryType(IStreamerTypes::MemoryType::ReadWrite) // Only generic memory can be assigned externally. - {} + { + } - FileRequest::ReadRequestData::~ReadRequestData() + ReadRequestData::~ReadRequestData() { if (m_allocator != nullptr) { @@ -64,65 +79,80 @@ namespace AZ::IO } } - FileRequest::ReadData::ReadData(void* output, u64 outputSize, const RequestPath& path, u64 offset, u64 size, bool sharedRead) - : m_output(output) - , m_outputSize(outputSize) - , m_path(path) - , m_offset(offset) - , m_size(size) - , m_sharedRead(sharedRead) - {} + CreateDedicatedCacheData::CreateDedicatedCacheData(RequestPath path, const FileRange& range) + : m_path(AZStd::move(path)) + , m_range(range) + { + } - FileRequest::CompressedReadData::CompressedReadData(CompressionInfo&& compressionInfo, void* output, u64 readOffset, u64 readSize) + DestroyDedicatedCacheData::DestroyDedicatedCacheData(RequestPath path, const FileRange& range) + : m_path(AZStd::move(path)) + , m_range(range) + { + } + + ExternalRequestData::ExternalRequestData(FileRequestPtr&& request) + : m_request(AZStd::move(request)) + { + } + + RequestPathStoreData::RequestPathStoreData(RequestPath path) + : m_path(AZStd::move(path)) + { + } + + CompressedReadData::CompressedReadData(CompressionInfo&& compressionInfo, void* output, u64 readOffset, u64 readSize) : m_compressionInfo(AZStd::move(compressionInfo)) , m_output(output) , m_readOffset(readOffset) , m_readSize(readSize) - {} + { + } - FileRequest::FileExistsCheckData::FileExistsCheckData(const RequestPath& path) + FileExistsCheckData::FileExistsCheckData(const RequestPath& path) : m_path(path) - {} + { + } - FileRequest::FileMetaDataRetrievalData::FileMetaDataRetrievalData(const RequestPath& path) + FileMetaDataRetrievalData::FileMetaDataRetrievalData(const RequestPath& path) : m_path(path) - {} + { + } - FileRequest::CancelData::CancelData(FileRequestPtr target) + CancelData::CancelData(FileRequestPtr target) : m_target(AZStd::move(target)) - {} + { + } - FileRequest::FlushData::FlushData(RequestPath path) + FlushData::FlushData(RequestPath path) : m_path(AZStd::move(path)) - {} + { + } - FileRequest::RescheduleData::RescheduleData(FileRequestPtr target, AZStd::chrono::system_clock::time_point newDeadline, + RescheduleData::RescheduleData( + FileRequestPtr target, + AZStd::chrono::system_clock::time_point newDeadline, IStreamerTypes::Priority newPriority) : m_target(AZStd::move(target)) , m_newDeadline(newDeadline) , m_newPriority(newPriority) - {} + { + } - FileRequest::CreateDedicatedCacheData::CreateDedicatedCacheData(RequestPath path, const FileRange& range) - : m_path(AZStd::move(path)) - , m_range(range) - {} - - FileRequest::DestroyDedicatedCacheData::DestroyDedicatedCacheData(RequestPath path, const FileRange& range) - : m_path(AZStd::move(path)) - , m_range(range) - {} - - FileRequest::ReportData::ReportData(ReportType reportType) + ReportData::ReportData(ReportType reportType) : m_reportType(reportType) - {} + { + } - FileRequest::CustomData::CustomData(AZStd::any data, bool failWhenUnhandled) + CustomData::CustomData(AZStd::any data, bool failWhenUnhandled) : m_data(AZStd::move(data)) , m_failWhenUnhandled(failWhenUnhandled) - {} - + { + } +} // namespace AZ::IO::Requests +namespace AZ::IO +{ // // FileRequest // @@ -145,14 +175,14 @@ namespace AZ::IO m_parent = request->m_request.m_parent; request->m_request.m_parent = this; m_dependencies++; - m_command.emplace(AZStd::move(request)); + m_command.emplace(AZStd::move(request)); } void FileRequest::CreateRequestPathStore(FileRequest* parent, RequestPath path) { AZ_Assert(AZStd::holds_alternative(m_command), "Attempting to set FileRequest to 'CreateRequestPathStore', but another task was already assigned."); - m_command.emplace(AZStd::move(path)); + m_command.emplace(AZStd::move(path)); SetOptionalParent(parent); } @@ -161,7 +191,7 @@ namespace AZ::IO { AZ_Assert(AZStd::holds_alternative(m_command), "Attempting to set FileRequest to 'ReadRequest', but another task was already assigned."); - m_command.emplace(AZStd::move(path), output, outputSize, offset, size, deadline, priority); + m_command.emplace(AZStd::move(path), output, outputSize, offset, size, deadline, priority); } void FileRequest::CreateReadRequest(RequestPath path, IStreamerTypes::RequestMemoryAllocator* allocator, u64 offset, u64 size, @@ -169,7 +199,7 @@ namespace AZ::IO { AZ_Assert(AZStd::holds_alternative(m_command), "Attempting to set FileRequest to 'ReadRequest', but another task was already assigned."); - m_command.emplace(AZStd::move(path), allocator, offset, size, deadline, priority); + m_command.emplace(AZStd::move(path), allocator, offset, size, deadline, priority); } void FileRequest::CreateRead(FileRequest* parent, void* output, u64 outputSize, const RequestPath& path, @@ -177,7 +207,7 @@ namespace AZ::IO { AZ_Assert(AZStd::holds_alternative(m_command), "Attempting to set FileRequest to 'Read', but another task was already assigned."); - m_command.emplace(output, outputSize, AZStd::move(path), offset, size, sharedRead); + m_command.emplace(output, outputSize, AZStd::move(path), offset, size, sharedRead); SetOptionalParent(parent); } @@ -192,7 +222,7 @@ namespace AZ::IO { AZ_Assert(AZStd::holds_alternative(m_command), "Attempting to set FileRequest to 'CompressedRead', but another task was already assigned."); - m_command.emplace(AZStd::move(compressionInfo), output, readOffset, readSize); + m_command.emplace(AZStd::move(compressionInfo), output, readOffset, readSize); SetOptionalParent(parent); } @@ -200,7 +230,7 @@ namespace AZ::IO { AZ_Assert(AZStd::holds_alternative(m_command), "Attempting to set FileRequest to 'Wait', but another task was already assigned."); - m_command.emplace(); + m_command.emplace(); SetOptionalParent(parent); } @@ -208,21 +238,21 @@ namespace AZ::IO { AZ_Assert(AZStd::holds_alternative(m_command), "Attempting to set FileRequest to 'FileExistsCheck', but another task was already assigned."); - m_command.emplace(path); + m_command.emplace(path); } void FileRequest::CreateFileMetaDataRetrieval(const RequestPath& path) { AZ_Assert(AZStd::holds_alternative(m_command), "Attempting to set FileRequest to 'FileMetaDataRetrieval', but another task was already assigned."); - m_command.emplace(path); + m_command.emplace(path); } void FileRequest::CreateCancel(FileRequestPtr target) { AZ_Assert(AZStd::holds_alternative(m_command), "Attempting to set FileRequest to 'Cancel', but another task was already assigned."); - m_command.emplace(AZStd::move(target)); + m_command.emplace(AZStd::move(target)); } void FileRequest::CreateReschedule(FileRequestPtr target, AZStd::chrono::system_clock::time_point newDeadline, @@ -230,28 +260,28 @@ namespace AZ::IO { AZ_Assert(AZStd::holds_alternative(m_command), "Attempting to set FileRequest to 'Reschedule', but another task was already assigned."); - m_command.emplace(AZStd::move(target), newDeadline, newPriority); + m_command.emplace(AZStd::move(target), newDeadline, newPriority); } void FileRequest::CreateFlush(RequestPath path) { AZ_Assert(AZStd::holds_alternative(m_command), "Attempting to set FileRequest to 'Flush', but another task was already assigned."); - m_command.emplace(AZStd::move(path)); + m_command.emplace(AZStd::move(path)); } void FileRequest::CreateFlushAll() { AZ_Assert(AZStd::holds_alternative(m_command), "Attempting to set FileRequest to 'FlushAll', but another task was already assigned."); - m_command.emplace(); + m_command.emplace(); } void FileRequest::CreateDedicatedCacheCreation(RequestPath path, const FileRange& range, FileRequest* parent) { AZ_Assert(AZStd::holds_alternative(m_command), "Attempting to set FileRequest to 'CreateDedicateCache', but another task was already assigned."); - m_command.emplace(AZStd::move(path), range); + m_command.emplace(AZStd::move(path), range); SetOptionalParent(parent); } @@ -259,22 +289,22 @@ namespace AZ::IO { AZ_Assert(AZStd::holds_alternative(m_command), "Attempting to set FileRequest to 'DestroyDedicateCache', but another task was already assigned."); - m_command.emplace(AZStd::move(path), range); + m_command.emplace(AZStd::move(path), range); SetOptionalParent(parent); } - void FileRequest::CreateReport(ReportData::ReportType reportType) + void FileRequest::CreateReport(Requests::ReportType reportType) { AZ_Assert(AZStd::holds_alternative(m_command), "Attempting to set FileRequest to 'Report', but another task was already assigned."); - m_command.emplace(reportType); + m_command.emplace(reportType); } void FileRequest::CreateCustom(AZStd::any data, bool failWhenUnhandled, FileRequest* parent) { AZ_Assert(AZStd::holds_alternative(m_command), "Attempting to set FileRequest to 'Custom', but another task was already assigned."); - m_command.emplace(AZStd::move(data), failWhenUnhandled); + m_command.emplace(AZStd::move(data), failWhenUnhandled); SetOptionalParent(parent); } @@ -361,7 +391,7 @@ namespace AZ::IO "Request does not contain a valid command. It may have been reset already or was never assigned a command."); return true; } - else if constexpr (AZStd::is_same_v) + else if constexpr (AZStd::is_same_v) { return args.m_failWhenUnhandled; } @@ -398,7 +428,7 @@ namespace AZ::IO const FileRequest* current = this; while (current) { - auto* link = AZStd::get_if(¤t->m_command); + auto* link = AZStd::get_if(¤t->m_command); if (!link) { current = current->m_parent; diff --git a/Code/Framework/AzCore/AzCore/IO/Streamer/FileRequest.h b/Code/Framework/AzCore/AzCore/IO/Streamer/FileRequest.h index dd4dad2387..7f5874c95d 100644 --- a/Code/Framework/AzCore/AzCore/IO/Streamer/FileRequest.h +++ b/Code/Framework/AzCore/AzCore/IO/Streamer/FileRequest.h @@ -27,7 +27,252 @@ namespace AZ::IO class ExternalFileRequest; using FileRequestPtr = AZStd::intrusive_ptr; +} // namespace AZ::IO +namespace AZ::IO::Requests +{ + //! Request to read data. This is a translated request and holds an absolute path and has been + //! resolved to the archive file if needed. + struct ReadData + { + inline constexpr static IStreamerTypes::Priority s_orderPriority = IStreamerTypes::s_priorityMedium; + inline constexpr static bool s_failWhenUnhandled = true; + + ReadData(void* output, u64 outputSize, const RequestPath& path, u64 offset, u64 size, bool sharedRead); + + const RequestPath& m_path; //!< The path to the file that contains the requested data. + void* m_output; //!< Target output to write the read data to. + u64 m_outputSize; //!< Size of memory m_output points to. This needs to be at least as big as m_size, but can be bigger. + u64 m_offset; //!< The offset in bytes into the file. + u64 m_size; //!< The number of bytes to read from the file. + bool m_sharedRead; //!< True if other code will be reading from the file or the stack entry can exclusively lock. + }; + + //! Request to read data. This is an untranslated request and holds a relative path. The Scheduler + //! will translate this to the appropriate ReadData or CompressedReadData. + struct ReadRequestData + { + inline constexpr static IStreamerTypes::Priority s_orderPriority = IStreamerTypes::s_priorityMedium; + inline constexpr static bool s_failWhenUnhandled = true; + + ReadRequestData( + RequestPath path, + void* output, + u64 outputSize, + u64 offset, + u64 size, + AZStd::chrono::system_clock::time_point deadline, + IStreamerTypes::Priority priority); + ReadRequestData( + RequestPath path, + IStreamerTypes::RequestMemoryAllocator* allocator, + u64 offset, + u64 size, + AZStd::chrono::system_clock::time_point deadline, + IStreamerTypes::Priority priority); + ~ReadRequestData(); + + RequestPath m_path; //!< Relative path to the target file. + IStreamerTypes::RequestMemoryAllocator* m_allocator; //!< Allocator used to manage the memory for this request. + AZStd::chrono::system_clock::time_point m_deadline; //!< Time by which this request should have been completed. + void* m_output; //!< The memory address assigned (during processing) to store the read data to. + u64 m_outputSize; //!< The memory size of the addressed used to store the read data. + u64 m_offset; //!< The offset in bytes into the file. + u64 m_size; //!< The number of bytes to read from the file. + IStreamerTypes::Priority m_priority; //!< Priority used for ordering requests. This is used when requests have the same deadline. + IStreamerTypes::MemoryType m_memoryType; //!< The type of memory provided by the allocator if used. + }; + + //! Creates a cache dedicated to a single file. This is best used for files where blocks are read from + //! periodically such as audio banks of video files. + struct CreateDedicatedCacheData + { + inline constexpr static IStreamerTypes::Priority s_orderPriority = IStreamerTypes::s_priorityHigh; + inline constexpr static bool s_failWhenUnhandled = false; + + CreateDedicatedCacheData(RequestPath path, const FileRange& range); + + RequestPath m_path; + FileRange m_range; + }; + + //! Destroys a cache dedicated to a single file that was previously created by CreateDedicatedCache + struct DestroyDedicatedCacheData + { + inline constexpr static IStreamerTypes::Priority s_orderPriority = IStreamerTypes::s_priorityHigh; + inline constexpr static bool s_failWhenUnhandled = false; + + DestroyDedicatedCacheData(RequestPath path, const FileRange& range); + + RequestPath m_path; + FileRange m_range; + }; + + enum class ReportType : int8_t + { + FileLocks + }; + + struct ReportData + { + inline constexpr static IStreamerTypes::Priority s_orderPriority = IStreamerTypes::s_priorityLow; + inline constexpr static bool s_failWhenUnhandled = false; + + explicit ReportData(ReportType reportType); + + ReportType m_reportType; + }; + + //! Stores a reference to the external request so it stays alive while the request is being processed. + //! This is needed because Streamer supports fire-and-forget requests since completion can be handled by + //! registering a callback. + struct ExternalRequestData + { + inline constexpr static IStreamerTypes::Priority s_orderPriority = IStreamerTypes::s_priorityMedium; + inline constexpr static bool s_failWhenUnhandled = true; + + explicit ExternalRequestData(FileRequestPtr&& request); + + FileRequestPtr m_request; //!< The request that was send to Streamer. + }; + + //! Stores an instance of a RequestPath. To reduce copying instances of a RequestPath functions that + //! need a path take them by reference to the original request. In some cases a path originates from + //! within in the stack and temporary storage is needed. This struct allows for that temporary storage + //! so it can be safely referenced later. + struct RequestPathStoreData + { + inline constexpr static IStreamerTypes::Priority s_orderPriority = IStreamerTypes::s_priorityMedium; + inline constexpr static bool s_failWhenUnhandled = true; + + explicit RequestPathStoreData(RequestPath path); + + RequestPath m_path; + }; + + //! Request to read and decompress data. + struct CompressedReadData + { + inline constexpr static IStreamerTypes::Priority s_orderPriority = IStreamerTypes::s_priorityMedium; + inline constexpr static bool s_failWhenUnhandled = true; + + CompressedReadData(CompressionInfo&& compressionInfo, void* output, u64 readOffset, u64 readSize); + + CompressionInfo m_compressionInfo; + void* m_output; //!< Target output to write the read data to. + u64 m_readOffset; //!< The offset into the decompressed to start copying from. + u64 m_readSize; //!< Number of bytes to read from the decompressed file. + }; + + //! Holds the progress of an operation chain until this request is explicitly completed. + struct WaitData + { + inline constexpr static IStreamerTypes::Priority s_orderPriority = IStreamerTypes::s_priorityMedium; + inline constexpr static bool s_failWhenUnhandled = true; + }; + + //! Checks to see if any node in the stack can find a file at the provided path. + struct FileExistsCheckData + { + inline constexpr static IStreamerTypes::Priority s_orderPriority = IStreamerTypes::s_priorityHigh; + inline constexpr static bool s_failWhenUnhandled = false; + + explicit FileExistsCheckData(const RequestPath& path); + + const RequestPath& m_path; + bool m_found{ false }; + }; + + //! Searches for a file in the stack and retrieves the meta data. This may be slower than a file exists + //! check. + struct FileMetaDataRetrievalData + { + inline constexpr static IStreamerTypes::Priority s_orderPriority = IStreamerTypes::s_priorityHigh; + inline constexpr static bool s_failWhenUnhandled = false; + + explicit FileMetaDataRetrievalData(const RequestPath& path); + + const RequestPath& m_path; + u64 m_fileSize{ 0 }; + bool m_found{ false }; + }; + + //! Cancels a request in the stream stack, if possible. + struct CancelData + { + inline constexpr static IStreamerTypes::Priority s_orderPriority = IStreamerTypes::s_priorityHighest; + inline constexpr static bool s_failWhenUnhandled = false; + + explicit CancelData(FileRequestPtr target); + + FileRequestPtr m_target; //!< The request that will be canceled. + }; + + //! Updates the priority and deadline of a request that has not been queued yet. + struct RescheduleData + { + inline constexpr static IStreamerTypes::Priority s_orderPriority = IStreamerTypes::s_priorityHigh; + inline constexpr static bool s_failWhenUnhandled = false; + + RescheduleData(FileRequestPtr target, AZStd::chrono::system_clock::time_point newDeadline, IStreamerTypes::Priority newPriority); + + FileRequestPtr m_target; //!< The request that will be rescheduled. + AZStd::chrono::system_clock::time_point m_newDeadline; //!< The new deadline for the request. + IStreamerTypes::Priority m_newPriority; //!< The new priority for the request. + }; + + //! Flushes all references to the provided file in the streaming stack. + struct FlushData + { + inline constexpr static IStreamerTypes::Priority s_orderPriority = IStreamerTypes::s_priorityHigh; + inline constexpr static bool s_failWhenUnhandled = false; + + explicit FlushData(RequestPath path); + + RequestPath m_path; + }; + + //! Flushes all caches in the streaming stack. + struct FlushAllData + { + inline constexpr static IStreamerTypes::Priority s_orderPriority = IStreamerTypes::s_priorityHigh; + inline constexpr static bool s_failWhenUnhandled = false; + }; + + //! Data for a custom command. This can be used by nodes added extensions that need data that can't be stored + //! in the already provided data. + struct CustomData + { + inline constexpr static IStreamerTypes::Priority s_orderPriority = IStreamerTypes::s_priorityMedium; + + CustomData(AZStd::any data, bool failWhenUnhandled); + + AZStd::any m_data; //!< The data for the custom request. + bool m_failWhenUnhandled; //!< Whether or not the request is marked as failed or success when no node process it. + }; + using CommandVariant = AZStd::variant< + AZStd::monostate, + ExternalRequestData, + RequestPathStoreData, + ReadRequestData, + ReadData, + CompressedReadData, + WaitData, + FileExistsCheckData, + FileMetaDataRetrievalData, + CancelData, + RescheduleData, + FlushData, + FlushAllData, + CreateDedicatedCacheData, + DestroyDedicatedCacheData, + ReportData, + CustomData>; + +} // namespace AZ::IO::Requests + +namespace AZ::IO +{ class FileRequest final { public: @@ -36,218 +281,7 @@ namespace AZ::IO friend class StreamerContext; friend class ExternalFileRequest; - //! Stores a reference to the external request so it stays alive while the request is being processed. - //! This is needed because Streamer supports fire-and-forget requests since completion can be handled by - //! registering a callback. - struct ExternalRequestData - { - inline constexpr static IStreamerTypes::Priority s_orderPriority = IStreamerTypes::s_priorityMedium; - inline constexpr static bool s_failWhenUnhandled = true; - - explicit ExternalRequestData(FileRequestPtr&& request); - - FileRequestPtr m_request; //!< The request that was send to Streamer. - }; - - //! Stores an instance of a RequestPath. To reduce copying instances of a RequestPath functions that - //! need a path take them by reference to the original request. In some cases a path originates from - //! within in the stack and temporary storage is needed. This struct allows for that temporary storage - //! so it can be safely referenced later. - struct RequestPathStoreData - { - inline constexpr static IStreamerTypes::Priority s_orderPriority = IStreamerTypes::s_priorityMedium; - inline constexpr static bool s_failWhenUnhandled = true; - - explicit RequestPathStoreData(RequestPath path); - - RequestPath m_path; - }; - - //! Request to read data. This is an untranslated request and holds a relative path. The Scheduler - //! will translate this to the appropriate ReadData or CompressedReadData. - struct ReadRequestData - { - inline constexpr static IStreamerTypes::Priority s_orderPriority = IStreamerTypes::s_priorityMedium; - inline constexpr static bool s_failWhenUnhandled = true; - - ReadRequestData(RequestPath path, void* output, u64 outputSize, u64 offset, u64 size, - AZStd::chrono::system_clock::time_point deadline, IStreamerTypes::Priority priority); - ReadRequestData(RequestPath path, IStreamerTypes::RequestMemoryAllocator* allocator, u64 offset, u64 size, - AZStd::chrono::system_clock::time_point deadline, IStreamerTypes::Priority priority); - ~ReadRequestData(); - - RequestPath m_path; //!< Relative path to the target file. - IStreamerTypes::RequestMemoryAllocator* m_allocator; //!< Allocator used to manage the memory for this request. - AZStd::chrono::system_clock::time_point m_deadline; //!< Time by which this request should have been completed. - void* m_output; //!< The memory address assigned (during processing) to store the read data to. - u64 m_outputSize; //!< The memory size of the addressed used to store the read data. - u64 m_offset; //!< The offset in bytes into the file. - u64 m_size; //!< The number of bytes to read from the file. - IStreamerTypes::Priority m_priority; //!< Priority used for ordering requests. This is used when requests have the same deadline. - IStreamerTypes::MemoryType m_memoryType; //!< The type of memory provided by the allocator if used. - }; - - //! Request to read data. This is a translated request and holds an absolute path and has been - //! resolved to the archive file if needed. - struct ReadData - { - inline constexpr static IStreamerTypes::Priority s_orderPriority = IStreamerTypes::s_priorityMedium; - inline constexpr static bool s_failWhenUnhandled = true; - - ReadData(void* output, u64 outputSize, const RequestPath& path, u64 offset, u64 size, bool sharedRead); - - const RequestPath& m_path; //!< The path to the file that contains the requested data. - void* m_output; //!< Target output to write the read data to. - u64 m_outputSize; //!< Size of memory m_output points to. This needs to be at least as big as m_size, but can be bigger. - u64 m_offset; //!< The offset in bytes into the file. - u64 m_size; //!< The number of bytes to read from the file. - bool m_sharedRead; //!< True if other code will be reading from the file or the stack entry can exclusively lock. - }; - - //! Request to read and decompress data. - struct CompressedReadData - { - inline constexpr static IStreamerTypes::Priority s_orderPriority = IStreamerTypes::s_priorityMedium; - inline constexpr static bool s_failWhenUnhandled = true; - - CompressedReadData(CompressionInfo&& compressionInfo, void* output, u64 readOffset, u64 readSize); - - CompressionInfo m_compressionInfo; - void* m_output; //!< Target output to write the read data to. - u64 m_readOffset; //!< The offset into the decompressed to start copying from. - u64 m_readSize; //!< Number of bytes to read from the decompressed file. - }; - - //! Holds the progress of an operation chain until this request is explicitly completed. - struct WaitData - { - inline constexpr static IStreamerTypes::Priority s_orderPriority = IStreamerTypes::s_priorityMedium; - inline constexpr static bool s_failWhenUnhandled = true; - }; - - //! Checks to see if any node in the stack can find a file at the provided path. - struct FileExistsCheckData - { - inline constexpr static IStreamerTypes::Priority s_orderPriority = IStreamerTypes::s_priorityHigh; - inline constexpr static bool s_failWhenUnhandled = false; - - explicit FileExistsCheckData(const RequestPath& path); - - const RequestPath& m_path; - bool m_found{ false }; - }; - - //! Searches for a file in the stack and retrieves the meta data. This may be slower than a file exists - //! check. - struct FileMetaDataRetrievalData - { - inline constexpr static IStreamerTypes::Priority s_orderPriority = IStreamerTypes::s_priorityHigh; - inline constexpr static bool s_failWhenUnhandled = false; - - explicit FileMetaDataRetrievalData(const RequestPath& path); - - const RequestPath& m_path; - u64 m_fileSize{ 0 }; - bool m_found{ false }; - }; - - //! Cancels a request in the stream stack, if possible. - struct CancelData - { - inline constexpr static IStreamerTypes::Priority s_orderPriority = IStreamerTypes::s_priorityHighest; - inline constexpr static bool s_failWhenUnhandled = false; - - explicit CancelData(FileRequestPtr target); - - FileRequestPtr m_target; //!< The request that will be canceled. - }; - - //! Updates the priority and deadline of a request that has not been queued yet. - struct RescheduleData - { - inline constexpr static IStreamerTypes::Priority s_orderPriority = IStreamerTypes::s_priorityHigh; - inline constexpr static bool s_failWhenUnhandled = false; - - RescheduleData(FileRequestPtr target, AZStd::chrono::system_clock::time_point newDeadline, IStreamerTypes::Priority newPriority); - - FileRequestPtr m_target; //!< The request that will be rescheduled. - AZStd::chrono::system_clock::time_point m_newDeadline; //!< The new deadline for the request. - IStreamerTypes::Priority m_newPriority; //!< The new priority for the request. - }; - - //! Flushes all references to the provided file in the streaming stack. - struct FlushData - { - inline constexpr static IStreamerTypes::Priority s_orderPriority = IStreamerTypes::s_priorityHigh; - inline constexpr static bool s_failWhenUnhandled = false; - - explicit FlushData(RequestPath path); - - RequestPath m_path; - }; - - //! Flushes all caches in the streaming stack. - struct FlushAllData - { - inline constexpr static IStreamerTypes::Priority s_orderPriority = IStreamerTypes::s_priorityHigh; - inline constexpr static bool s_failWhenUnhandled = false; - }; - - //! Creates a cache dedicated to a single file. This is best used for files where blocks are read from - //! periodically such as audio banks of video files. - struct CreateDedicatedCacheData - { - inline constexpr static IStreamerTypes::Priority s_orderPriority = IStreamerTypes::s_priorityHigh; - inline constexpr static bool s_failWhenUnhandled = false; - - CreateDedicatedCacheData(RequestPath path, const FileRange& range); - - RequestPath m_path; - FileRange m_range; - }; - - //! Destroys a cache dedicated to a single file that was previously created by CreateDedicatedCache - struct DestroyDedicatedCacheData - { - inline constexpr static IStreamerTypes::Priority s_orderPriority = IStreamerTypes::s_priorityHigh; - inline constexpr static bool s_failWhenUnhandled = false; - - DestroyDedicatedCacheData(RequestPath path, const FileRange& range); - - RequestPath m_path; - FileRange m_range; - }; - - struct ReportData - { - inline constexpr static IStreamerTypes::Priority s_orderPriority = IStreamerTypes::s_priorityLow; - inline constexpr static bool s_failWhenUnhandled = false; - - enum class ReportType - { - FileLocks - }; - - explicit ReportData(ReportType reportType); - - ReportType m_reportType; - }; - - //! Data for a custom command. This can be used by nodes added extensions that need data that can't be stored - //! in the already provided data. - struct CustomData - { - inline constexpr static IStreamerTypes::Priority s_orderPriority = IStreamerTypes::s_priorityMedium; - - CustomData(AZStd::any data, bool failWhenUnhandled); - - AZStd::any m_data; //!< The data for the custom request. - bool m_failWhenUnhandled; //!< Whether or not the request is marked as failed or success when no node process it. - }; - - using CommandVariant = AZStd::variant; + using CommandVariant = Requests::CommandVariant; using OnCompletionCallback = AZStd::function; AZ_CLASS_ALLOCATOR(FileRequest, SystemAllocator, 0); @@ -278,7 +312,7 @@ namespace AZ::IO void CreateFlushAll(); void CreateDedicatedCacheCreation(RequestPath path, const FileRange& range = {}, FileRequest* parent = nullptr); void CreateDedicatedCacheDestruction(RequestPath path, const FileRange& range = {}, FileRequest* parent = nullptr); - void CreateReport(ReportData::ReportType reportType); + void CreateReport(Requests::ReportType reportType); void CreateCustom(AZStd::any data, bool failWhenUnhandled = true, FileRequest* parent = nullptr); void SetCompletionCallback(OnCompletionCallback callback); @@ -325,8 +359,17 @@ namespace AZ::IO //! Command and parameters for the request. CommandVariant m_command; - //! Status of the request. - AZStd::atomic m_status{ IStreamerTypes::RequestStatus::Pending }; + //! Estimated time this request will complete. This is an estimation and depends on many + //! factors which can cause it to change drastically from moment to moment. + AZStd::chrono::system_clock::time_point m_estimatedCompletion; + + //! The file request that has a dependency on this one. This can be null if there are no + //! other request depending on this one to complete. + FileRequest* m_parent{ nullptr }; + + + //! Id assigned when the request is added to the pending queue. + size_t m_pendingId{ 0 }; //! Called once the request has completed. This will always be called from the Streamer thread //! and thread safety is the responsibility of called function. When assigning a lambda avoid @@ -336,16 +379,8 @@ namespace AZ::IO //! a longer running task is needed consider using a job to do the work. OnCompletionCallback m_onCompletion; - //! Estimated time this request will complete. This is an estimation and depends on many - //! factors which can cause it to change drastically from moment to moment. - AZStd::chrono::system_clock::time_point m_estimatedCompletion; - - //! The file request that has a dependency on this one. This can be null if there are no - //! other request depending on this one to complete. - FileRequest* m_parent{ nullptr }; - - //! Id assigned when the request is added to the pending queue. - size_t m_pendingId{ 0 }; + //! Status of the request. + AZStd::atomic m_status{ IStreamerTypes::RequestStatus::Pending }; //! The number of dependent file request that need to complete before this one is done. u16 m_dependencies{ 0 }; diff --git a/Code/Framework/AzCore/AzCore/IO/Streamer/FullFileDecompressor.cpp b/Code/Framework/AzCore/AzCore/IO/Streamer/FullFileDecompressor.cpp index 723a5d62c8..5087702c47 100644 --- a/Code/Framework/AzCore/AzCore/IO/Streamer/FullFileDecompressor.cpp +++ b/Code/Framework/AzCore/AzCore/IO/Streamer/FullFileDecompressor.cpp @@ -91,12 +91,12 @@ namespace AZ::IO AZStd::visit([this, request](auto&& args) { using Command = AZStd::decay_t; - if constexpr (AZStd::is_same_v) + if constexpr (AZStd::is_same_v) { PrepareReadRequest(request, args); } - else if constexpr (AZStd::is_same_v || - AZStd::is_same_v) + else if constexpr (AZStd::is_same_v || + AZStd::is_same_v) { PrepareDedicatedCache(request, args.m_path); } @@ -114,11 +114,11 @@ namespace AZ::IO AZStd::visit([this, request](auto&& args) { using Command = AZStd::decay_t; - if constexpr (AZStd::is_same_v) + if constexpr (AZStd::is_same_v) { m_pendingReads.push_back(request); } - else if constexpr (AZStd::is_same_v) + else if constexpr (AZStd::is_same_v) { m_pendingFileExistChecks.push_back(request); } @@ -203,7 +203,7 @@ namespace AZ::IO { FileRequest* compressedRequest = m_processingJobs[i].m_waitRequest->GetParent(); AZ_Assert(compressedRequest, "A wait request attached to FullFileDecompressor was completed but didn't have a parent compressed request."); - auto data = AZStd::get_if(&compressedRequest->GetCommand()); + auto data = AZStd::get_if(&compressedRequest->GetCommand()); AZ_Assert(data, "Compressed request in the decompression queue in FullFileDecompressor didn't contain compression read data."); size_t bytesToDecompress = data->m_compressionInfo.m_compressedSize; @@ -255,7 +255,7 @@ namespace AZ::IO // Calculate the amount of time it will take to decompress the data. FileRequest* compressedRequest = m_readRequests[i]->GetParent(); - auto data = AZStd::get_if(&compressedRequest->GetCommand()); + auto data = AZStd::get_if(&compressedRequest->GetCommand()); size_t bytesToDecompress = data->m_compressionInfo.m_compressedSize; auto decompressionDuration = AZStd::chrono::microseconds( @@ -290,7 +290,7 @@ namespace AZ::IO void FullFileDecompressor::EstimateCompressedReadRequest(FileRequest* request, AZStd::chrono::microseconds& cumulativeDelay, AZStd::chrono::microseconds decompressionDelay, double totalDecompressionDurationUs, double totalBytesDecompressed) const { - auto data = AZStd::get_if(&request->GetCommand()); + auto data = AZStd::get_if(&request->GetCommand()); if (data) { AZStd::chrono::microseconds processingTime = decompressionDelay; @@ -343,7 +343,7 @@ namespace AZ::IO m_numRunningJobs == 0; } - void FullFileDecompressor::PrepareReadRequest(FileRequest* request, FileRequest::ReadRequestData& data) + void FullFileDecompressor::PrepareReadRequest(FileRequest* request, Requests::ReadRequestData& data) { CompressionInfo info; if (CompressionUtils::FindCompressionInfo(info, data.m_path.GetRelativePath())) @@ -359,7 +359,7 @@ namespace AZ::IO { FileRequest* pathStorageRequest = m_context->GetNewInternalRequest(); pathStorageRequest->CreateRequestPathStore(request, AZStd::move(info.m_archiveFilename)); - auto& pathStorage = AZStd::get(pathStorageRequest->GetCommand()); + auto& pathStorage = AZStd::get(pathStorageRequest->GetCommand()); nextRequest->CreateRead(pathStorageRequest, data.m_output, data.m_outputSize, pathStorage.m_path, info.m_offset + data.m_offset, data.m_size, info.m_isSharedPak); @@ -370,13 +370,13 @@ namespace AZ::IO auto callback = [this, nextRequest](const FileRequest& checkRequest) { AZ_PROFILE_FUNCTION(AzCore); - auto check = AZStd::get_if(&checkRequest.GetCommand()); + auto check = AZStd::get_if(&checkRequest.GetCommand()); AZ_Assert(check, "Callback in FullFileDecompressor::PrepareReadRequest expected FileExistsCheck but got another command."); if (check->m_found) { FileRequest* originalRequest = m_context->RejectRequest(nextRequest); - if (AZStd::holds_alternative(originalRequest->GetCommand())) + if (AZStd::holds_alternative(originalRequest->GetCommand())) { originalRequest = m_context->RejectRequest(originalRequest); } @@ -412,12 +412,12 @@ namespace AZ::IO AZStd::visit([request, &info, nextRequest](auto&& args) { using Command = AZStd::decay_t; - if constexpr (AZStd::is_same_v) + if constexpr (AZStd::is_same_v) { nextRequest->CreateDedicatedCacheCreation(AZStd::move(info.m_archiveFilename), FileRange::CreateRange(info.m_offset, info.m_compressedSize), request); } - else if constexpr (AZStd::is_same_v) + else if constexpr (AZStd::is_same_v) { nextRequest->CreateDedicatedCacheDestruction(AZStd::move(info.m_archiveFilename), FileRange::CreateRange(info.m_offset, info.m_compressedSize), request); @@ -429,7 +429,7 @@ namespace AZ::IO auto callback = [this, nextRequest](const FileRequest& checkRequest) { AZ_PROFILE_FUNCTION(AzCore); - auto check = AZStd::get_if(&checkRequest.GetCommand()); + auto check = AZStd::get_if(&checkRequest.GetCommand()); AZ_Assert(check, "Callback in FullFileDecompressor::PrepareDedicatedCache expected FileExistsCheck but got another command."); if (check->m_found) @@ -461,7 +461,7 @@ namespace AZ::IO void FullFileDecompressor::FileExistsCheck(FileRequest* checkRequest) { - auto& fileCheckRequest = AZStd::get(checkRequest->GetCommand()); + auto& fileCheckRequest = AZStd::get(checkRequest->GetCommand()); CompressionInfo info; if (CompressionUtils::FindCompressionInfo(info, fileCheckRequest.m_path.GetRelativePath())) { @@ -487,7 +487,7 @@ namespace AZ::IO { if (m_readBufferStatus[i] == ReadBufferStatus::Unused) { - auto data = AZStd::get_if(&compressedReadRequest->GetCommand()); + auto data = AZStd::get_if(&compressedReadRequest->GetCommand()); AZ_Assert(data, "Compressed request that's starting a read in FullFileDecompressor didn't contain compression read data."); AZ_Assert(data->m_compressionInfo.m_decompressor, "FileRequest for FullFileDecompressor is missing a decompression callback."); @@ -549,7 +549,7 @@ namespace AZ::IO } else { - auto data = AZStd::get_if(&compressedRequest->GetCommand()); + auto data = AZStd::get_if(&compressedRequest->GetCommand()); AZ_Assert(data, "Compressed request in FullFileDecompressor that finished unsuccessfully didn't contain compression read data."); CompressionInfo& info = data->m_compressionInfo; size_t offsetAdjustment = info.m_offset - AZ_SIZE_ALIGN_DOWN(info.m_offset, aznumeric_cast(m_alignment)); @@ -591,7 +591,7 @@ namespace AZ::IO } FileRequest* waitRequest = m_readRequests[readSlot]; - AZ_Assert(AZStd::holds_alternative(waitRequest->GetCommand()), + AZ_Assert(AZStd::holds_alternative(waitRequest->GetCommand()), "File request waiting for decompression wasn't marked as being a wait operation."); FileRequest* compressedRequest = waitRequest->GetParent(); AZ_Assert(compressedRequest, "Read requests started by FullFileDecompressor is missing a parent request."); @@ -610,7 +610,7 @@ namespace AZ::IO m_readBuffers[readSlot] = nullptr; AZ::Job* decompressionJob; - auto data = AZStd::get_if(&compressedRequest->GetCommand()); + auto data = AZStd::get_if(&compressedRequest->GetCommand()); AZ_Assert(data, "Compressed request in FullFileDecompressor that's starting decompression didn't contain compression read data."); AZ_Assert(data->m_compressionInfo.m_decompressor, "FullFileDecompressor is queuing a decompression job but couldn't find a decompressor."); @@ -664,7 +664,7 @@ namespace AZ::IO FileRequest* compressedRequest = jobInfo.m_waitRequest->GetParent(); AZ_Assert(compressedRequest, "A wait request attached to FullFileDecompressor was completed but didn't have a parent compressed request."); - auto data = AZStd::get_if(&compressedRequest->GetCommand()); + auto data = AZStd::get_if(&compressedRequest->GetCommand()); AZ_Assert(data, "Compressed request in FullFileDecompressor that completed decompression didn't contain compression read data."); CompressionInfo& info = data->m_compressionInfo; size_t offsetAdjustment = info.m_offset - AZ_SIZE_ALIGN_DOWN(info.m_offset, aznumeric_cast(m_alignment)); @@ -694,7 +694,7 @@ namespace AZ::IO FileRequest* compressedRequest = info.m_waitRequest->GetParent(); AZ_Assert(compressedRequest, "A wait request attached to FullFileDecompressor was completed but didn't have a parent compressed request."); - auto request = AZStd::get_if(&compressedRequest->GetCommand()); + auto request = AZStd::get_if(&compressedRequest->GetCommand()); AZ_Assert(request, "Compressed request in FullFileDecompressor that's running full decompression didn't contain compression read data."); CompressionInfo& compressionInfo = request->m_compressionInfo; AZ_Assert(compressionInfo.m_decompressor, "Full decompressor job started, but there's no decompressor callback assigned."); @@ -719,7 +719,7 @@ namespace AZ::IO FileRequest* compressedRequest = info.m_waitRequest->GetParent(); AZ_Assert(compressedRequest, "A wait request attached to FullFileDecompressor was completed but didn't have a parent compressed request."); - auto request = AZStd::get_if(&compressedRequest->GetCommand()); + auto request = AZStd::get_if(&compressedRequest->GetCommand()); AZ_Assert(request, "Compressed request in FullFileDecompressor that's running partial decompression didn't contain compression read data."); CompressionInfo& compressionInfo = request->m_compressionInfo; AZ_Assert(compressionInfo.m_decompressor, "Partial decompressor job started, but there's no decompressor callback assigned."); diff --git a/Code/Framework/AzCore/AzCore/IO/Streamer/FullFileDecompressor.h b/Code/Framework/AzCore/AzCore/IO/Streamer/FullFileDecompressor.h index d9bd68f1a1..cb4226fd7c 100644 --- a/Code/Framework/AzCore/AzCore/IO/Streamer/FullFileDecompressor.h +++ b/Code/Framework/AzCore/AzCore/IO/Streamer/FullFileDecompressor.h @@ -21,6 +21,11 @@ namespace AZ::IO { + namespace Requests + { + struct ReadRequestData; + } + struct FullFileDecompressorConfig final : public IStreamerStackConfig { @@ -87,7 +92,7 @@ namespace AZ::IO bool IsIdle() const; - void PrepareReadRequest(FileRequest* request, FileRequest::ReadRequestData& data); + void PrepareReadRequest(FileRequest* request, Requests::ReadRequestData& data); void PrepareDedicatedCache(FileRequest* request, const RequestPath& path); void FileExistsCheck(FileRequest* checkRequest); diff --git a/Code/Framework/AzCore/AzCore/IO/Streamer/ReadSplitter.cpp b/Code/Framework/AzCore/AzCore/IO/Streamer/ReadSplitter.cpp index a952e31a93..282a1e15c9 100644 --- a/Code/Framework/AzCore/AzCore/IO/Streamer/ReadSplitter.cpp +++ b/Code/Framework/AzCore/AzCore/IO/Streamer/ReadSplitter.cpp @@ -118,7 +118,7 @@ namespace AZ::IO return; } - auto data = AZStd::get_if(&request->GetCommand()); + auto data = AZStd::get_if(&request->GetCommand()); if (data == nullptr) { StreamStackEntry::QueueRequest(request); @@ -156,7 +156,7 @@ namespace AZ::IO void ReadSplitter::QueueAlignedRead(FileRequest* request) { - auto data = AZStd::get_if(&request->GetCommand()); + auto data = AZStd::get_if(&request->GetCommand()); AZ_Assert(data != nullptr, "Provided request to queue by the Read Splitter did not contain a read command."); if (data->m_size <= m_maxReadSize) @@ -187,7 +187,7 @@ namespace AZ::IO bool ReadSplitter::QueueAlignedRead(PendingRead& pending) { - auto data = AZStd::get_if(&pending.m_request->GetCommand()); + auto data = AZStd::get_if(&pending.m_request->GetCommand()); AZ_Assert(data != nullptr, "Provided request to queue by the Read Splitter did not contain a read command."); while (pending.m_readSize > 0) @@ -237,7 +237,7 @@ namespace AZ::IO void ReadSplitter::QueueBufferedRead(FileRequest* request) { - auto data = AZStd::get_if(&request->GetCommand()); + auto data = AZStd::get_if(&request->GetCommand()); AZ_Assert(data != nullptr, "Provided request to queue by the Read Splitter did not contain a read command."); PendingRead pendingRead; @@ -262,7 +262,7 @@ namespace AZ::IO bool ReadSplitter::QueueBufferedRead(PendingRead& pending) { - auto data = AZStd::get_if(&pending.m_request->GetCommand()); + auto data = AZStd::get_if(&pending.m_request->GetCommand()); AZ_Assert(data != nullptr, "Provided request to queue by the Read Splitter did not contain a read command."); while (pending.m_readSize > 0) diff --git a/Code/Framework/AzCore/AzCore/IO/Streamer/Scheduler.cpp b/Code/Framework/AzCore/AzCore/IO/Streamer/Scheduler.cpp index fe1d5a5eda..fba9c3c98a 100644 --- a/Code/Framework/AzCore/AzCore/IO/Streamer/Scheduler.cpp +++ b/Code/Framework/AzCore/AzCore/IO/Streamer/Scheduler.cpp @@ -6,9 +6,11 @@ * */ +#include + #include #include -#include +#include #include #include @@ -35,6 +37,8 @@ namespace AZ::IO m_threadData.m_streamStack = AZStd::move(streamStack); } + Scheduler::~Scheduler() = default; + void Scheduler::Start(const AZStd::thread_desc& threadDesc) { if (!m_isRunning) @@ -222,10 +226,10 @@ namespace AZ::IO { using Command = AZStd::decay_t; if constexpr ( - AZStd::is_same_v || - AZStd::is_same_v) + AZStd::is_same_v || + AZStd::is_same_v) { - auto parentReadRequest = next->GetCommandFromChain(); + auto parentReadRequest = next->GetCommandFromChain(); AZ_Assert(parentReadRequest != nullptr, "The issued read request can't be found for the (compressed) read command."); size_t size = parentReadRequest->m_size; @@ -234,7 +238,7 @@ namespace AZ::IO AZ_Assert(parentReadRequest->m_allocator, "The read request was issued without a memory allocator or valid output address."); u64 recommendedSize = size; - if constexpr (AZStd::is_same_v) + if constexpr (AZStd::is_same_v) { recommendedSize = m_recommendations.CalculateRecommendedMemorySize(size, parentReadRequest->m_offset); } @@ -249,12 +253,12 @@ namespace AZ::IO parentReadRequest->m_output = allocation.m_address; parentReadRequest->m_outputSize = allocation.m_size; parentReadRequest->m_memoryType = allocation.m_type; - if constexpr (AZStd::is_same_v) + if constexpr (AZStd::is_same_v) { args.m_output = parentReadRequest->m_output; args.m_outputSize = allocation.m_size; } - else if constexpr (AZStd::is_same_v) + else if constexpr (AZStd::is_same_v) { args.m_output = parentReadRequest->m_output; } @@ -267,7 +271,7 @@ namespace AZ::IO } #endif - if constexpr (AZStd::is_same_v) + if constexpr (AZStd::is_same_v) { m_threadData.m_lastFilePath = args.m_path; m_threadData.m_lastFileOffset = args.m_offset + args.m_size; @@ -275,7 +279,7 @@ namespace AZ::IO m_processingSize += args.m_size; #endif } - else if constexpr (AZStd::is_same_v) + else if constexpr (AZStd::is_same_v) { const CompressionInfo& info = args.m_compressionInfo; m_threadData.m_lastFilePath = info.m_archiveFilename; @@ -288,15 +292,15 @@ namespace AZ::IO "Streamer queued %zu: %s", next->GetCommand().index(), parentReadRequest->m_path.GetRelativePath()); m_threadData.m_streamStack->QueueRequest(next); } - else if constexpr (AZStd::is_same_v) + else if constexpr (AZStd::is_same_v) { return Thread_ProcessCancelRequest(next, args); } - else if constexpr (AZStd::is_same_v) + else if constexpr (AZStd::is_same_v) { return Thread_ProcessRescheduleRequest(next, args); } - else if constexpr (AZStd::is_same_v || AZStd::is_same_v) + else if constexpr (AZStd::is_same_v || AZStd::is_same_v) { AZ_PROFILE_INTERVAL_START_COLORED(AzCore, next, ProfilerColor, "Streamer queued %zu", next->GetCommand().index()); @@ -345,7 +349,7 @@ namespace AZ::IO #endif { using Command = AZStd::decay_t; - if constexpr (AZStd::is_same_v) + if constexpr (AZStd::is_same_v) { if (args.m_output == nullptr && args.m_allocator != nullptr) { @@ -393,7 +397,7 @@ namespace AZ::IO } } - void Scheduler::Thread_ProcessCancelRequest(FileRequest* request, FileRequest::CancelData& data) + void Scheduler::Thread_ProcessCancelRequest(FileRequest* request, Requests::CancelData& data) { AZ_PROFILE_INTERVAL_START_COLORED(AzCore, request, ProfilerColor, "Streamer queued cancel"); auto& pending = m_context.GetPreparedRequests(); @@ -415,7 +419,7 @@ namespace AZ::IO m_threadData.m_streamStack->QueueRequest(request); } - void Scheduler::Thread_ProcessRescheduleRequest(FileRequest* request, FileRequest::RescheduleData& data) + void Scheduler::Thread_ProcessRescheduleRequest(FileRequest* request, Requests::RescheduleData& data) { AZ_PROFILE_INTERVAL_START_COLORED(AzCore, request, ProfilerColor, "Streamer queued reschedule"); auto& pendingRequests = m_context.GetPreparedRequests(); @@ -424,7 +428,7 @@ namespace AZ::IO if (pending->WorksOn(data.m_target)) { // Read requests are the only requests that use deadlines and dynamic priorities. - auto readRequest = pending->GetCommandFromChain(); + auto readRequest = pending->GetCommandFromChain(); if (readRequest) { readRequest->m_deadline = data.m_newDeadline; @@ -463,8 +467,8 @@ namespace AZ::IO // Order is the same for both requests, so prioritize the request that are at risk of missing // it's deadline. - const FileRequest::ReadRequestData* firstRead = first->GetCommandFromChain(); - const FileRequest::ReadRequestData* secondRead = second->GetCommandFromChain(); + const Requests::ReadRequestData* firstRead = first->GetCommandFromChain(); + const Requests::ReadRequestData* secondRead = second->GetCommandFromChain(); if (firstRead == nullptr || secondRead == nullptr) { @@ -496,11 +500,11 @@ namespace AZ::IO auto sameFile = [this](auto&& args) { using Command = AZStd::decay_t; - if constexpr (AZStd::is_same_v) + if constexpr (AZStd::is_same_v) { return m_threadData.m_lastFilePath == args.m_path; } - else if constexpr (AZStd::is_same_v) + else if constexpr (AZStd::is_same_v) { return m_threadData.m_lastFilePath == args.m_compressionInfo.m_archiveFilename; } @@ -517,11 +521,11 @@ namespace AZ::IO auto offset = [](auto&& args) -> s64 { using Command = AZStd::decay_t; - if constexpr (AZStd::is_same_v) + if constexpr (AZStd::is_same_v) { return aznumeric_caster(args.m_offset); } - else if constexpr (AZStd::is_same_v) + else if constexpr (AZStd::is_same_v) { return aznumeric_caster(args.m_compressionInfo.m_offset); } diff --git a/Code/Framework/AzCore/AzCore/IO/Streamer/Scheduler.h b/Code/Framework/AzCore/AzCore/IO/Streamer/Scheduler.h index 053a57d332..502002fd27 100644 --- a/Code/Framework/AzCore/AzCore/IO/Streamer/Scheduler.h +++ b/Code/Framework/AzCore/AzCore/IO/Streamer/Scheduler.h @@ -8,6 +8,7 @@ #pragma once +#include #include #include #include @@ -24,11 +25,19 @@ namespace AZ::IO { class FileRequest; + namespace Requests + { + struct CancelData; + struct RescheduleData; + } // namespace Requests + class Scheduler final { public: explicit Scheduler(AZStd::shared_ptr streamStack, u64 memoryAlignment = AZCORE_GLOBAL_NEW_ALIGNMENT, u64 sizeAlignment = 1, u64 granularity = 1_mib); + ~Scheduler(); + void Start(const AZStd::thread_desc& threadDesc); void Stop(); @@ -61,14 +70,14 @@ namespace AZ::IO bool Thread_ExecuteRequests(); bool Thread_PrepareRequests(AZStd::vector& outstandingRequests); void Thread_ProcessTillIdle(); - void Thread_ProcessCancelRequest(FileRequest* request, FileRequest::CancelData& data); - void Thread_ProcessRescheduleRequest(FileRequest* request, FileRequest::RescheduleData& data); + void Thread_ProcessCancelRequest(FileRequest* request, Requests::CancelData& data); + void Thread_ProcessRescheduleRequest(FileRequest* request, Requests::RescheduleData& data); enum class Order { - FirstRequest, //< The first request is the most important to process next. - SecondRequest, //< The second request is the most important to process next. - Equal //< Both requests are equally important. + FirstRequest, //!< The first request is the most important to process next. + SecondRequest, //!< The second request is the most important to process next. + Equal //!< Both requests are equally important. }; //! Determine which of the two provided requests is more important to process next. Order Thread_PrioritizeRequests(const FileRequest* first, const FileRequest* second) const; diff --git a/Code/Framework/AzCore/AzCore/IO/Streamer/StorageDrive.cpp b/Code/Framework/AzCore/AzCore/IO/Streamer/StorageDrive.cpp index cfd191b68f..20e08873da 100644 --- a/Code/Framework/AzCore/AzCore/IO/Streamer/StorageDrive.cpp +++ b/Code/Framework/AzCore/AzCore/IO/Streamer/StorageDrive.cpp @@ -60,13 +60,13 @@ namespace AZ::IO AZ_PROFILE_FUNCTION(AzCore); AZ_Assert(request, "PrepareRequest was provided a null request."); - if (AZStd::holds_alternative(request->GetCommand())) + if (AZStd::holds_alternative(request->GetCommand())) { - auto& readRequest = AZStd::get(request->GetCommand()); + auto& readRequest = AZStd::get(request->GetCommand()); FileRequest* read = m_context->GetNewInternalRequest(); - read->CreateRead(request, readRequest.m_output, readRequest.m_outputSize, readRequest.m_path, - readRequest.m_offset, readRequest.m_size); + read->CreateRead( + request, readRequest.m_output, readRequest.m_outputSize, readRequest.m_path, readRequest.m_offset, readRequest.m_size); m_context->PushPreparedRequest(read); return; } @@ -79,29 +79,29 @@ namespace AZ::IO AZStd::visit([this, request](auto&& args) { using Command = AZStd::decay_t; - if constexpr (AZStd::is_same_v || - AZStd::is_same_v || - AZStd::is_same_v) + if constexpr (AZStd::is_same_v || + AZStd::is_same_v || + AZStd::is_same_v) { m_pendingRequests.push_back(request); return; } - else if constexpr (AZStd::is_same_v) + else if constexpr (AZStd::is_same_v) { CancelRequest(request, args.m_target); return; } else { - if constexpr (AZStd::is_same_v) + if constexpr (AZStd::is_same_v) { FlushCache(args.m_path); } - else if constexpr (AZStd::is_same_v) + else if constexpr (AZStd::is_same_v) { FlushEntireCache(); } - else if constexpr (AZStd::is_same_v) + else if constexpr (AZStd::is_same_v) { Report(args); } @@ -118,15 +118,15 @@ namespace AZ::IO AZStd::visit([this, request](auto&& args) { using Command = AZStd::decay_t; - if constexpr (AZStd::is_same_v) + if constexpr (AZStd::is_same_v) { ReadFile(request); } - else if constexpr (AZStd::is_same_v) + else if constexpr (AZStd::is_same_v) { FileExistsRequest(request); } - else if constexpr (AZStd::is_same_v) + else if constexpr (AZStd::is_same_v) { FileMetaDataRetrievalRequest(request); } @@ -199,25 +199,25 @@ namespace AZ::IO AZStd::visit([&](auto&& args) { using Command = AZStd::decay_t; - if constexpr (AZStd::is_same_v) + if constexpr (AZStd::is_same_v) { targetFile = &args.m_path; readSize = args.m_size; offset = args.m_offset; } - else if constexpr (AZStd::is_same_v) + else if constexpr (AZStd::is_same_v) { targetFile = &args.m_compressionInfo.m_archiveFilename; readSize = args.m_compressionInfo.m_compressedSize; offset = args.m_compressionInfo.m_offset; } - else if constexpr (AZStd::is_same_v) + else if constexpr (AZStd::is_same_v) { readSize = 0; AZStd::chrono::microseconds averageTime = m_getFileExistsTimeAverage.CalculateAverage(); startTime += averageTime; } - else if constexpr (AZStd::is_same_v) + else if constexpr (AZStd::is_same_v) { readSize = 0; AZStd::chrono::microseconds averageTime = m_getFileMetaDataTimeAverage.CalculateAverage(); @@ -254,7 +254,7 @@ namespace AZ::IO { AZ_PROFILE_FUNCTION(AzCore); - auto data = AZStd::get_if(&request->GetCommand()); + auto data = AZStd::get_if(&request->GetCommand()); AZ_Assert(data, "FileRequest queued on StorageDrive to be read didn't contain read data."); SystemFile* file = nullptr; @@ -342,7 +342,7 @@ namespace AZ::IO AZ_PROFILE_FUNCTION(AzCore); TIMED_AVERAGE_WINDOW_SCOPE(m_getFileExistsTimeAverage); - auto& fileExists = AZStd::get(request->GetCommand()); + auto& fileExists = AZStd::get(request->GetCommand()); size_t cacheIndex = FindFileInCache(fileExists.m_path); if (cacheIndex != s_fileNotFound) { @@ -360,7 +360,7 @@ namespace AZ::IO AZ_PROFILE_FUNCTION(AzCore); TIMED_AVERAGE_WINDOW_SCOPE(m_getFileMetaDataTimeAverage); - auto& command = AZStd::get(request->GetCommand()); + auto& command = AZStd::get(request->GetCommand()); // If the file is already open, use the file handle which usually is cheaper than asking for the file by name. size_t cacheIndex = FindFileInCache(command.m_path); if (cacheIndex != s_fileNotFound) @@ -446,11 +446,11 @@ namespace AZ::IO } } - void StorageDrive::Report(const FileRequest::ReportData& data) const + void StorageDrive::Report(const Requests::ReportData& data) const { switch (data.m_reportType) { - case FileRequest::ReportData::ReportType::FileLocks: + case Requests::ReportType::FileLocks: for (u32 i = 0; i < m_fileHandles.size(); ++i) { if (m_fileHandles[i] != nullptr) diff --git a/Code/Framework/AzCore/AzCore/IO/Streamer/StorageDrive.h b/Code/Framework/AzCore/AzCore/IO/Streamer/StorageDrive.h index d90b31eeec..25f3d7b353 100644 --- a/Code/Framework/AzCore/AzCore/IO/Streamer/StorageDrive.h +++ b/Code/Framework/AzCore/AzCore/IO/Streamer/StorageDrive.h @@ -8,6 +8,7 @@ #pragma once +#include #include #include #include @@ -16,6 +17,11 @@ #include #include +namespace AZ::IO::Requests +{ + struct ReportData; +} + namespace AZ::IO { struct StorageDriveConfig final : @@ -72,7 +78,7 @@ namespace AZ::IO void EstimateCompletionTimeForRequest(FileRequest* request, AZStd::chrono::system_clock::time_point& startTime, const RequestPath*& activeFile, u64& activeOffset) const; - void Report(const FileRequest::ReportData& data) const; + void Report(const Requests::ReportData& data) const; TimedAverageWindow m_fileOpenCloseTimeAverage; TimedAverageWindow m_getFileExistsTimeAverage; diff --git a/Code/Framework/AzCore/AzCore/IO/Streamer/Streamer.cpp b/Code/Framework/AzCore/AzCore/IO/Streamer/Streamer.cpp index e4976f7d1c..dfc156bbee 100644 --- a/Code/Framework/AzCore/AzCore/IO/Streamer/Streamer.cpp +++ b/Code/Framework/AzCore/AzCore/IO/Streamer/Streamer.cpp @@ -9,6 +9,7 @@ #include #include #include +#include #include #include #include @@ -210,7 +211,7 @@ namespace AZ::IO IStreamerTypes::ClaimMemory claimMemory) const { AZ_Assert(request.m_request, "The request handle provided to Streamer::GetReadRequestResult is invalid."); - auto readRequest = AZStd::get_if(&request.m_request->GetCommand()); + auto readRequest = AZStd::get_if(&request.m_request->GetCommand()); if (readRequest != nullptr) { buffer = readRequest->m_output; @@ -281,14 +282,14 @@ namespace AZ::IO } } - FileRequestPtr Streamer::Report(FileRequest::ReportData::ReportType reportType) + FileRequestPtr Streamer::Report(Requests::ReportType reportType) { FileRequestPtr result = CreateRequest(); Report(result, reportType); return result; } - FileRequestPtr& Streamer::Report(FileRequestPtr& request, FileRequest::ReportData::ReportType reportType) + FileRequestPtr& Streamer::Report(FileRequestPtr& request, Requests::ReportType reportType) { request->m_request.CreateReport(reportType); return request; diff --git a/Code/Framework/AzCore/AzCore/IO/Streamer/Streamer.h b/Code/Framework/AzCore/AzCore/IO/Streamer/Streamer.h index bb363a0c64..7e3dd1a742 100644 --- a/Code/Framework/AzCore/AzCore/IO/Streamer/Streamer.h +++ b/Code/Framework/AzCore/AzCore/IO/Streamer/Streamer.h @@ -20,6 +20,10 @@ namespace AZStd struct thread_desc; } +namespace AZ::IO::Requests +{ + enum class ReportType : int8_t; +} namespace AZ::IO { @@ -185,9 +189,9 @@ namespace AZ::IO void RecordStatistics(); //! Tells AZ::IO::Streamer the report the information for the report to the output. - FileRequestPtr Report(FileRequest::ReportData::ReportType reportType); + FileRequestPtr Report(Requests::ReportType reportType); //! Tells AZ::IO::Streamer the report the information for the report to the output. - FileRequestPtr& Report(FileRequestPtr& request, FileRequest::ReportData::ReportType reportType); + FileRequestPtr& Report(FileRequestPtr& request, Requests::ReportType reportType); Streamer(const AZStd::thread_desc& threadDesc, AZStd::unique_ptr streamStack); diff --git a/Code/Framework/AzCore/AzCore/IO/Streamer/StreamerComponent.cpp b/Code/Framework/AzCore/AzCore/IO/Streamer/StreamerComponent.cpp index 9a465021c2..25fdb9bdfb 100644 --- a/Code/Framework/AzCore/AzCore/IO/Streamer/StreamerComponent.cpp +++ b/Code/Framework/AzCore/AzCore/IO/Streamer/StreamerComponent.cpp @@ -14,6 +14,7 @@ #include #include #include +#include #include #include #include @@ -207,7 +208,7 @@ namespace AZ { if (m_streamer) { - m_streamer->QueueRequest(m_streamer->Report(AZ::IO::FileRequest::ReportData::ReportType::FileLocks)); + m_streamer->QueueRequest(m_streamer->Report(AZ::IO::Requests::ReportType::FileLocks)); } } diff --git a/Code/Framework/AzCore/AzCore/IO/Streamer/StreamerContext.cpp b/Code/Framework/AzCore/AzCore/IO/Streamer/StreamerContext.cpp index 5cd483bc55..a4979320a7 100644 --- a/Code/Framework/AzCore/AzCore/IO/Streamer/StreamerContext.cpp +++ b/Code/Framework/AzCore/AzCore/IO/Streamer/StreamerContext.cpp @@ -22,6 +22,9 @@ namespace AZ static constexpr char LatePredictionName[] = "Early completions"; static constexpr char MissedDeadlinesName[] = "Missed deadlines"; #endif // AZ_STREAMER_ADD_EXTRA_PROFILING_INFO + + StreamerContext::StreamerContext() = default; + StreamerContext::~StreamerContext() { for (FileRequest* entry : m_internalRecycleBin) @@ -204,7 +207,7 @@ namespace AZ m_latePredictionsPercentageStat.GetMostRecentSample()); } } - auto readRequest = AZStd::get_if(&top->GetCommand()); + auto readRequest = AZStd::get_if(&top->GetCommand()); if (readRequest != nullptr) { m_missedDeadlinePercentageStat.PushSample(now < readRequest->m_deadline ? 0.0 : 1.0); @@ -224,7 +227,7 @@ namespace AZ top->m_onCompletion(*top); AZ_PROFILE_INTERVAL_END(AzCore, top); } - + if (parent) { AZ_Assert(parent->m_dependencies > 0, diff --git a/Code/Framework/AzCore/AzCore/IO/Streamer/StreamerContext.h b/Code/Framework/AzCore/AzCore/IO/Streamer/StreamerContext.h index 356eb7ddac..fee8d7b56b 100644 --- a/Code/Framework/AzCore/AzCore/IO/Streamer/StreamerContext.h +++ b/Code/Framework/AzCore/AzCore/IO/Streamer/StreamerContext.h @@ -8,22 +8,27 @@ #pragma once #include -#include #include #include #include -#include -#include -#include #include +#include +#include +#include namespace AZ::IO { + class FileRequest; + class ExternalFileRequest; + + using FileRequestPtr = AZStd::intrusive_ptr; + class StreamerContext { public: using PreparedQueue = AZStd::deque; + StreamerContext(); ~StreamerContext(); //! Gets a new file request, either by creating a new instance or diff --git a/Code/Framework/AzCore/AzCore/Math/Matrix3x4.cpp b/Code/Framework/AzCore/AzCore/Math/Matrix3x4.cpp index 78da9e76d2..23d0eea618 100644 --- a/Code/Framework/AzCore/AzCore/Math/Matrix3x4.cpp +++ b/Code/Framework/AzCore/AzCore/Math/Matrix3x4.cpp @@ -25,7 +25,7 @@ namespace AZ void Matrix3x4SetRowGeneric(Matrix3x4* thisPtr, ScriptDataContext& dc) { - bool rowIsSet = false; + [[maybe_unused]] bool rowIsSet = false; if (dc.GetNumArguments() >= 5) { if (dc.IsNumber(0)) @@ -88,7 +88,7 @@ namespace AZ void Matrix3x4SetColumnGeneric(Matrix3x4* thisPtr, ScriptDataContext& dc) { - bool columnIsSet = false; + [[maybe_unused]] bool columnIsSet = false; if (dc.GetNumArguments() >= 4) { if (dc.IsNumber(0)) @@ -133,7 +133,7 @@ namespace AZ void Matrix3x4SetTranslationGeneric(Matrix3x4* thisPtr, ScriptDataContext& dc) { - bool translationIsSet = false; + [[maybe_unused]] bool translationIsSet = false; if (dc.GetNumArguments() == 3 && dc.IsNumber(0) && diff --git a/Code/Framework/AzCore/AzCore/Math/Uuid.cpp b/Code/Framework/AzCore/AzCore/Math/Uuid.cpp index 410d235a37..b27f1a0943 100644 --- a/Code/Framework/AzCore/AzCore/Math/Uuid.cpp +++ b/Code/Framework/AzCore/AzCore/Math/Uuid.cpp @@ -77,7 +77,7 @@ namespace AZ // check open brace char c = *current++; - bool has_open_brace = false; + [[maybe_unused]] bool has_open_brace = false; if (c == '{') { c = *current++; diff --git a/Code/Framework/AzCore/AzCore/Name/NameDictionary.cpp b/Code/Framework/AzCore/AzCore/Name/NameDictionary.cpp index 1b39eb81bd..2bb4faf1d5 100644 --- a/Code/Framework/AzCore/AzCore/Name/NameDictionary.cpp +++ b/Code/Framework/AzCore/AzCore/Name/NameDictionary.cpp @@ -85,7 +85,7 @@ namespace AZ NameDictionary::~NameDictionary() { - bool leaksDetected = false; + [[maybe_unused]] bool leaksDetected = false; for (const auto& keyValue : m_dictionary) { diff --git a/Code/Framework/AzCore/AzCore/PlatformDef.h b/Code/Framework/AzCore/AzCore/PlatformDef.h index 8609ad5756..8416099f15 100644 --- a/Code/Framework/AzCore/AzCore/PlatformDef.h +++ b/Code/Framework/AzCore/AzCore/PlatformDef.h @@ -248,14 +248,14 @@ #if defined(__has_builtin) #if __has_builtin(__builtin_is_constant_evaluated) #define az_builtin_is_constant_evaluated() __builtin_is_constant_evaluated() - #define az_has_builtin_is_constant_evaluated() true + #define az_has_builtin_is_constant_evaluated true #endif #elif AZ_COMPILER_MSVC >= 1928 #define az_builtin_is_constant_evaluated() __builtin_is_constant_evaluated() - #define az_has_builtin_is_constant_evaluated() true + #define az_has_builtin_is_constant_evaluated true #elif AZ_COMPILER_GCC #define az_builtin_is_constant_evaluated() __builtin_is_constant_evaluated() - #define az_has_builtin_is_constant_evaluated() true + #define az_has_builtin_is_constant_evaluated true #endif #endif @@ -271,7 +271,7 @@ } } #define az_builtin_is_constant_evaluated() AZ::Internal::builtin_is_constant_evaluated() - #define az_has_builtin_is_constant_evaluated() false + #define az_has_builtin_is_constant_evaluated false #endif // define builtin functions used by char_traits class for efficient compile time and runtime diff --git a/Code/Framework/AzCore/AzCore/Serialization/ObjectStream.cpp b/Code/Framework/AzCore/AzCore/Serialization/ObjectStream.cpp index ac44ac150c..6132cf0a56 100644 --- a/Code/Framework/AzCore/AzCore/Serialization/ObjectStream.cpp +++ b/Code/Framework/AzCore/AzCore/Serialization/ObjectStream.cpp @@ -1668,9 +1668,23 @@ namespace AZ SerializeContext::ENUM_ACCESS_FOR_READ, &m_errorLogger ); - if (objectStreamWriteOverrideCB.Invoke(callContext, objectPtr, *classData, classElement)) + if (ObjectStreamWriteOverrideResponse writeResponse; + objectStreamWriteOverrideCB.Read(writeResponse, callContext, objectPtr, *classData, classElement)) { - return false; + switch (writeResponse) + { + case ObjectStreamWriteOverrideResponse::FallbackToDefaultWrite: + break; + case ObjectStreamWriteOverrideResponse::AbortWrite: + m_errorLogger.ReportError(AZStd::string::format("ObjectStream Write Element Override callback has aborted the write for class data %s", + classData->m_name).c_str()); + [[fallthrough]]; + case ObjectStreamWriteOverrideResponse::CompletedWrite: + return false; + default: + AZ_Error("Serialize", false, "Invalid Response %d returned from the ObjectStream Write Element Override callback", static_cast(writeResponse)); + return false; + } } else { diff --git a/Code/Framework/AzCore/AzCore/Serialization/ObjectStream.h b/Code/Framework/AzCore/AzCore/Serialization/ObjectStream.h index 9f9b3fc9f0..1985821c7b 100644 --- a/Code/Framework/AzCore/AzCore/Serialization/ObjectStream.h +++ b/Code/Framework/AzCore/AzCore/Serialization/ObjectStream.h @@ -49,14 +49,24 @@ namespace AZ static const AZ::Crc32 ObjectStreamWriteElementOverride = AZ_CRC("ObjectStreamWriteElementOverride", 0x35eb659f); } + enum class ObjectStreamWriteOverrideResponse + { + CompletedWrite, + FallbackToDefaultWrite, + AbortWrite + }; + AZ_TYPE_INFO_SPECIALIZE(ObjectStreamWriteOverrideResponse, "{BDF960A8-0F18-4E9D-96DA-F800A122C42D}"); + ///< Callback that the object stream invokes to override saving an instance of the registered class ///< @param callContext EnumerateInstanceCallContext which contains the WriteElement BeingElemCB and the CloseElement EndElemCB ///< the callContext parameter can be passed to the SerializeContext::EnumerateInstance to continue object stream writing ///< @param classPtr class type which is of pointer to the type represented by the m_typeId value ///< @param classData reference to this instance Class Data that will be supplied to the callback ///< @param classElement class element pointer which contains information about the element being serialized. - ///< root elements do not not have a valid class element pointer - using ObjectStreamWriteOverrideCB = AZStd::function; AZ_TYPE_INFO_SPECIALIZE(ObjectStreamWriteOverrideCB, "{87B1A36B-8C8A-42B6-A0B5-E770D9FDBAD4}"); diff --git a/Code/Framework/AzCore/AzCore/Serialization/std/VariantReflection.inl b/Code/Framework/AzCore/AzCore/Serialization/std/VariantReflection.inl index 06d4f76c80..33f9995752 100644 --- a/Code/Framework/AzCore/AzCore/Serialization/std/VariantReflection.inl +++ b/Code/Framework/AzCore/AzCore/Serialization/std/VariantReflection.inl @@ -12,6 +12,8 @@ namespace AZ { + enum class ObjectStreamWriteOverrideResponse; + namespace VariantSerializationInternal { template @@ -480,7 +482,7 @@ namespace AZ } } private: - static void ObjectStreamWriter(SerializeContext::EnumerateInstanceCallContext& callContext, const void* variantPtr, + static ObjectStreamWriteOverrideResponse ObjectStreamWriter(SerializeContext::EnumerateInstanceCallContext& callContext, const void* variantPtr, [[maybe_unused]] const SerializeContext::ClassData& variantClassData, const SerializeContext::ClassElement* variantClassElement) { auto alternativeVisitor = [&callContext, variantClassElement](auto&& elementAlt) @@ -503,6 +505,9 @@ namespace AZ }; AZStd::visit(AZStd::move(alternativeVisitor), *reinterpret_cast(variantPtr)); + // To avoid including ObjectStream.h into this file, we static cast the value of 0 + // to an AZ::ObjectStreamWriteElemntResponse which corresponds to the CompletedWrite enum value + return static_cast(0); } VariantSerializationInternal::AZStdVariantContainer m_variantContainer; diff --git a/Code/Framework/AzCore/AzCore/azcore_files.cmake b/Code/Framework/AzCore/AzCore/azcore_files.cmake index 7e3f501d6f..2c49826170 100644 --- a/Code/Framework/AzCore/AzCore/azcore_files.cmake +++ b/Code/Framework/AzCore/AzCore/azcore_files.cmake @@ -116,6 +116,8 @@ set(FILES Debug/TraceReflection.h DOM/DomBackend.cpp DOM/DomBackend.h + DOM/DomPath.cpp + DOM/DomPath.h DOM/DomUtils.cpp DOM/DomUtils.h DOM/DomValue.cpp diff --git a/Code/Framework/AzCore/AzCore/std/azstd_files.cmake b/Code/Framework/AzCore/AzCore/std/azstd_files.cmake index d516a56295..fe169c4964 100644 --- a/Code/Framework/AzCore/AzCore/std/azstd_files.cmake +++ b/Code/Framework/AzCore/AzCore/std/azstd_files.cmake @@ -19,6 +19,7 @@ set(FILES any.h base.h config.h + concepts/concepts.h createdestroy.h docs.h exceptions.h @@ -27,11 +28,14 @@ set(FILES hash.cpp hash.h hash_table.h + iterator/iterator_primitives.h iterator.h limits.h numeric.h math.h optional.h + ranges/iter_move.h + ranges/ranges.h ratio.h reference_wrapper.h sort.h @@ -151,6 +155,7 @@ set(FILES typetraits/alignment_of.h typetraits/config.h typetraits/common_type.h + typetraits/common_reference.h typetraits/conjunction.h typetraits/disjunction.h typetraits/extent.h @@ -217,4 +222,6 @@ set(FILES typetraits/void_t.h typetraits/internal/type_sequence_traits.h typetraits/internal/is_template_copy_constructible.h + utility/declval.h + utility/move.h ) diff --git a/Code/Framework/AzCore/AzCore/std/base.h b/Code/Framework/AzCore/AzCore/std/base.h index 46d1821328..44b11c61ef 100644 --- a/Code/Framework/AzCore/AzCore/std/base.h +++ b/Code/Framework/AzCore/AzCore/std/base.h @@ -30,4 +30,6 @@ namespace AZStd using std::nullptr_t; using sys_time_t = AZ::s64; + + using std::byte; } diff --git a/Code/Framework/AzCore/AzCore/std/concepts/concepts.h b/Code/Framework/AzCore/AzCore/std/concepts/concepts.h new file mode 100644 index 0000000000..420b671f31 --- /dev/null +++ b/Code/Framework/AzCore/AzCore/std/concepts/concepts.h @@ -0,0 +1,840 @@ +/* + * 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace AZStd +{ + // alias std::pointer_traits into the AZStd::namespace + using std::pointer_traits; + + // Alias re-declarations from iterator.h + /// Identifying tag for input iterators. + using input_iterator_tag = std::input_iterator_tag; + /// Identifying tag for output iterators. + using output_iterator_tag = std::output_iterator_tag; + /// Identifying tag for forward iterators. + using forward_iterator_tag = std::forward_iterator_tag; + /// Identifying tag for bidirectional iterators. + using bidirectional_iterator_tag = std::bidirectional_iterator_tag; + /// Identifying tag for random-access iterators. + using random_access_iterator_tag = std::random_access_iterator_tag; + /// Identifying tag for contagious iterators + struct contiguous_iterator_tag; +} + +namespace AZStd::Internal +{ + template + constexpr bool pointer_traits_has_to_address_v = false; + + template + constexpr bool pointer_traits_has_to_address_v::to_address(declval()))>>> > = true; + + + // pointer_traits isn't SFINAE friendly https://cplusplus.github.io/LWG/lwg-active.html#3545 + // So working around that by checking if type T has an element_type alias + template + constexpr bool pointer_traits_valid_and_has_to_address_v = false; + template + constexpr bool pointer_traits_valid_and_has_to_address_v> > + = pointer_traits_has_to_address_v; +} + +namespace AZStd +{ + //! Implements the C++20 to_address function + //! This obtains the address represented by ptr without forming a reference + //! to the pointee type + template + constexpr T* to_address(T* ptr) noexcept + { + static_assert(!AZStd::is_function_v, "Invoking to address on a function pointer is not allowed"); + return ptr; + } + //! Fancy pointer overload which delegates to using a specialization of pointer_traits::to_address + //! if that is a well-formed expression, otherwise it returns ptr->operator->() + //! For example invoking `to_address(AZStd::reverse_iterator(char_ptr))` + //! Returns an element of type const char* + template + constexpr auto to_address(const T& ptr) noexcept + { + if constexpr (AZStd::Internal::pointer_traits_valid_and_has_to_address_v) + { + return pointer_traits::to_address(ptr); + } + else + { + return to_address(ptr.operator->()); + } + } +} + +namespace AZStd::Internal +{ + // Variadic template which maps types to true For SFINAE + template + constexpr bool sfinae_trigger_v = true; + + template + constexpr bool is_class_or_enum = false; + template + constexpr bool is_class_or_enum> || is_enum_v>)>> = true; + + template + constexpr bool assignable_from_impl = false; + template + constexpr bool assignable_from_impl + && common_reference_with&, const remove_reference_t&> + && same_as() = declval()), LHS> >> = true; + + + template + constexpr bool common_with_impl = false; + template + constexpr bool common_with_impl, common_type_t> + && sfinae_trigger_v>(declval()))> + && sfinae_trigger_v>(declval()))> + && common_reference_with, add_lvalue_reference_t> + && common_reference_with>, common_reference_t, add_lvalue_reference_t>> + >> = true; +} + +namespace AZStd +{ + template + /*concept*/ constexpr bool common_with = Internal::common_with_impl; + + template + /*concept*/ constexpr bool assignable_from = Internal::assignable_from_impl; + + template + /*concept*/ constexpr bool constructible_from = destructible && is_constructible_v; + + template + /*concept*/ constexpr bool move_constructible = constructible_from && convertible_to; + + template + /*concept*/ constexpr bool derived_from = is_base_of_v && is_convertible_v; +} + +namespace AZStd::ranges::Internal +{ + template + constexpr bool is_class_or_enum_with_swap_adl = false; + template + constexpr bool is_class_or_enum_with_swap_adl> || is_enum_v> + || is_class_v> || is_enum_v>) + && is_void_v(), declval()))>> + >> = true; + + template + void swap(T&, T&) = delete; + + struct swap_fn + { + template + constexpr auto operator()(T&& t, U&& u) const noexcept(noexcept(swap(AZStd::forward(t), AZStd::forward(u)))) + ->enable_if_t> + { + swap(AZStd::forward(t), AZStd::forward(u)); + } + + // ranges::swap customization point https://eel.is/c++draft/concepts#concept.swappable-2.2 + // Implemented in ranges.h as to prevent circular dependency. + // ranges::swap_ranges depends on the range concepts that can't be defined here + template + constexpr auto operator()(T&& t, U&& u) const noexcept(noexcept((*this)(*t, *u))) + ->enable_if_t + && is_array_v && is_array_v && (extent_v == extent_v) + >; + + template + constexpr auto operator()(T& t1, T& t2) const noexcept(noexcept(is_nothrow_move_constructible_v&& is_nothrow_move_assignable_v)) + ->enable_if_t&& assignable_from> + { + auto temp(AZStd::move(t1)); + t1 = AZStd::move(t2); + t2 = AZStd::move(temp); + } + }; +} + +namespace AZStd::ranges +{ + inline namespace customization_point_object + { + inline constexpr auto swap = Internal::swap_fn{}; + } +} + +namespace AZStd::Internal +{ + template + constexpr bool swappable_impl = false; + template + constexpr bool swappable_impl(), declval()))>> = true; + + template + constexpr bool swappable_with_impl = false; + template + constexpr bool swappable_with_impl + && sfinae_trigger_v< + decltype(AZStd::ranges::swap(declval(), declval())), + decltype(AZStd::ranges::swap(declval(), declval())), + decltype(AZStd::ranges::swap(declval(), declval())), + decltype(AZStd::ranges::swap(declval(), declval()))>>> = true; +} +namespace AZStd +{ + template + /*concept*/ constexpr bool signed_integral = integral && is_signed_v; + template + /*concept*/ constexpr bool unsigned_integral = integral && !signed_integral; + + template + /*concept*/ constexpr bool swappable = Internal::swappable_impl; + + template + /*concept*/ constexpr bool swappable_with = Internal::swappable_with_impl; +} + + +namespace AZStd::Internal +{ + // boolean-testable concept (exposition only in the C++standard) + template + constexpr bool boolean_testable_impl = convertible_to; + + template + constexpr bool boolean_testable = false; + template + constexpr bool boolean_testable && boolean_testable_impl())>>> = true; + + // weakly comparable ==, != + template + constexpr bool weakly_equality_comparable_with = false; + template + constexpr bool weakly_equality_comparable_with&>() == declval&>())> + && boolean_testable&>() != declval&>())> + && boolean_testable&>() == declval&>())> + && boolean_testable&>() != declval&>())> + >> = true; + + // partially ordered <, >, <=, >= + template + constexpr bool partially_ordered_with_impl = false; + template + constexpr bool partially_ordered_with_impl&>() < declval&>())> + && boolean_testable&>() > declval&>())> + && boolean_testable&>() <= declval&>())> + && boolean_testable&>() >= declval&>())> + && boolean_testable&>() < declval&>())> + && boolean_testable&>() > declval&>())> + && boolean_testable&>() <= declval&>())> + && boolean_testable&>() >= declval&>())> + >> = true; +} + +namespace AZStd +{ + template + /*concept*/ constexpr bool equality_comparable = Internal::weakly_equality_comparable_with; +} + +namespace AZStd::Internal +{ + // equally_comparable + partially ordered + template + constexpr bool equally_comparable_with_impl = false; + template + constexpr bool equally_comparable_with_impl + && equality_comparable + && common_reference_with&, const remove_reference_t&> + && equality_comparable&, const remove_reference_t&>> + && Internal::weakly_equality_comparable_with + >> = true; +} + +namespace AZStd +{ + template + /*concept*/ constexpr bool equality_comparable_with = Internal::equally_comparable_with_impl; + + template + /*concept*/ constexpr bool partially_ordered_with = Internal::partially_ordered_with_impl; + + template + /*concept*/ constexpr bool totally_ordered = equality_comparable && partially_ordered_with; +} + +namespace AZStd::Internal +{ + // equally_comparable + partially ordered + template + constexpr bool totally_ordered_with_impl = false; + template + constexpr bool totally_ordered_with_impl&& totally_ordered + && equality_comparable_with + && totally_ordered&, const remove_reference_t&>> + && partially_ordered_with + >> = true; +} + +namespace AZStd +{ + template + /*concept*/ constexpr bool totally_ordered_with = Internal::totally_ordered_with_impl; +} + +namespace AZStd::Internal +{ + template + inline constexpr bool is_default_initializable = false; + template + inline constexpr bool is_default_initializable> = true; + + template + constexpr bool default_initializable_impl = false; + template + constexpr bool default_initializable_impl < T, enable_if_t < constructible_from + && sfinae_trigger_v && Internal::is_default_initializable >> = true; + + template + constexpr bool movable_impl = false; + template + constexpr bool movable_impl && move_constructible && + assignable_from && swappable> > = true; + + template + constexpr bool copy_constructible_impl = false; + template + constexpr bool copy_constructible_impl && + constructible_from && convertible_to && + constructible_from && convertible_to && + constructible_from && convertible_to> > = true; +} + +namespace AZStd +{ + // movable + template + /*concept*/ constexpr bool movable = Internal::movable_impl; + + // default_initializable + template + /*concept*/ constexpr bool default_initializable = Internal::default_initializable_impl; + + // copy constructible + template + /*concept*/ constexpr bool copy_constructible = Internal::copy_constructible_impl; +} + +namespace AZStd::Internal +{ + template + constexpr bool copyable_impl = false; + template + constexpr bool copyable_impl && movable && assignable_from && + assignable_from && assignable_from> > = true; +} + +namespace AZStd +{ + // copyable + template + /*concept*/ constexpr bool copyable = Internal::copyable_impl; + + // semiregular + template + /*concept*/ constexpr bool semiregular = copyable && default_initializable; + + // regular + template + /*concept*/ constexpr bool regular = semiregular && equality_comparable; +} + +// Iterator Concepts +namespace AZStd::Internal +{ + template + constexpr bool is_integer_like = integral && !same_as; + + template + constexpr bool is_signed_integer_like = signed_integral; + + template + constexpr bool weakly_incrementable_impl = false; + template + constexpr bool weakly_incrementable_impl + && is_signed_integer_like> + && same_as()), T&> + && sfinae_trigger_v()++)> >> = true; +} + +namespace AZStd +{ + // models weakly_incrementable concept + template + /*concept*/ constexpr bool weakly_incrementable = Internal::weakly_incrementable_impl; + + // models input_or_output_iterator concept + template + /*concept*/ constexpr bool input_or_output_iterator = !is_void_v + && weakly_incrementable; +} + +namespace AZStd::Internal +{ + template + constexpr bool incrementable_impl = false; + template + constexpr bool incrementable_impl + && weakly_incrementable + && same_as()++), T> >> = true; +} + +namespace AZStd +{ + template + /*concept*/ constexpr bool incrementable = Internal::incrementable_impl; +} + +namespace AZStd +{ + template + /*concept*/ constexpr bool sentinel_for = semiregular && + input_or_output_iterator && + Internal::weakly_equality_comparable_with; + template + inline constexpr bool disable_sized_sentinel_for = false; +} + +namespace AZStd::Internal +{ + template + /*concept*/ constexpr bool sized_sentinel_for_impl = false; + template + /*concept*/ constexpr bool sized_sentinel_for_impl + && !disable_sized_sentinel_for, remove_cv_t> + && same_as() - declval()), iter_difference_t> + && same_as() - declval()), iter_difference_t> >> = true; +} + +namespace AZStd +{ + template + /*concept*/ constexpr bool sized_sentinel_for = Internal::sized_sentinel_for_impl; + + template + struct iterator_traits; +} + +namespace AZStd::Internal +{ + // ITER_CONCEPT(I) general concept + template + constexpr bool use_traits_iterator_concept_for_concept = false; + template + constexpr bool use_traits_iterator_concept_for_concept::iterator_concept>> = true; + + template + constexpr bool use_traits_iterator_category_for_concept = false; + template + constexpr bool use_traits_iterator_category_for_concept::iterator_category>> = !use_traits_iterator_concept_for_concept; + + template + constexpr bool use_random_access_iterator_tag_for_concept = false; + template + constexpr bool use_random_access_iterator_tag_for_concept>> = !use_traits_iterator_concept_for_concept + && !use_traits_iterator_category_for_concept; + + template + struct iter_concept; + + template + struct iter_concept>> + { + using type = typename iterator_traits::iterator_concept; + }; + template + struct iter_concept>> + { + using type = typename iterator_traits::iterator_category; + }; + + template + struct iter_concept>> + { + using type = random_access_iterator_tag; + }; + template + using iter_concept_t = typename iter_concept::type; +} + +namespace AZStd +{ + // indirectly readable + template + /*concept*/ constexpr bool indirectly_readable = Internal::indirectly_readable_impl>; +} + +namespace AZStd::Internal +{ + // model the indirectly writable concept + template + constexpr bool indirectly_writable_impl = false; + + template + constexpr bool indirectly_writable_impl() = declval()), + decltype(*declval() = declval()), + decltype(const_cast&&>(*declval()) = declval()), + decltype(const_cast&&>(*declval()) = declval())> + > = true; +} +namespace AZStd +{ + // indirectly writable + template + /*concept*/ constexpr bool indirectly_writable = Internal::indirectly_writable_impl; + + // indirectly movable + template + /*concept*/ constexpr bool indirectly_movable = indirectly_readable && indirectly_writable>; +} + +namespace AZStd::Internal +{ + template + constexpr bool indirectly_movable_storage_impl = false; + + template + constexpr bool indirectly_movable_storage_impl && + indirectly_writable> && + movable> && + constructible_from, iter_rvalue_reference_t> && + assignable_from&, iter_rvalue_reference_t>> > = true; +} + +namespace AZStd +{ + template + /*concept*/ constexpr bool indirectly_movable_storable = Internal::indirectly_movable_storage_impl; +} + +namespace AZStd::Internal +{ + template + constexpr bool indirectly_copyable_impl = false; + + template + constexpr bool indirectly_copyable_impl && + indirectly_writable>> > = true; +} + +namespace AZStd +{ + // indirectly copyable + template + /*concept*/ constexpr bool indirectly_copyable = Internal::indirectly_copyable_impl; +} +namespace AZStd::Internal +{ + template + constexpr bool indirectly_copyable_storable_impl = false; + + template + constexpr bool indirectly_copyable_storable_impl && + indirectly_writable&> && + indirectly_writable&> && + indirectly_writable&&> && + indirectly_writable&&> && + copyable> && + constructible_from, iter_reference_t> && + assignable_from&, iter_reference_t>> > = true; +} + +namespace AZStd +{ + template + /*concept*/ constexpr bool indirectly_copyable_storable = Internal::indirectly_copyable_storable_impl; +} + +namespace AZStd::ranges::Internal +{ + template + void iter_swap(I1, I2) = delete; + + template + constexpr bool iter_swap_adl = false; + + template + constexpr bool iter_swap_adl(), declval()))>> = true; + + template + constexpr bool is_class_or_enum_with_iter_swap_adl = false; + + template + constexpr bool is_class_or_enum_with_iter_swap_adl + && (is_class_v> || is_enum_v>) + && (is_class_v> || is_enum_v>)>> = true; + + struct iter_swap_fn + { + template + constexpr auto operator()(I1&& i1, I2&& i2) const + ->enable_if_t + > + { + iter_swap(AZStd::forward(i1), AZStd::forward(i2)); + } + template + constexpr auto operator()(I1&& i1, I2&& i2) const + ->enable_if_t + && indirectly_readable + && indirectly_readable + && swappable_with, iter_reference_t> + > + { + ranges::swap(*i1, *i2); + } + + template + constexpr auto operator()(I1&& i1, I2&& i2) const + ->enable_if_t + && indirectly_movable_storable + && indirectly_movable_storable + > + { + *AZStd::forward(i1) = iter_exchange_move(AZStd::forward(i2), AZStd::forward(i1)); + } + + private: + template + static constexpr iter_value_t iter_exchange_move(X&& x, Y&& y) + noexcept(noexcept(iter_value_t(iter_move(x))) && noexcept(*x = iter_move(y))) + { + iter_value_t old_value(iter_move(x)); + *x = iter_move(y); + return old_value; + } + }; +} + +namespace AZStd::ranges +{ + inline namespace customization_point_object + { + inline constexpr Internal::iter_swap_fn iter_swap{}; + } +} + + +namespace AZStd::Internal +{ + template + constexpr bool indirectly_swappable_impl = false; + template + constexpr bool indirectly_swappable_impl&& indirectly_readable + && sfinae_trigger_v< + decltype(AZStd::ranges::iter_swap(declval(), declval())), + decltype(AZStd::ranges::iter_swap(declval(), declval())), + decltype(AZStd::ranges::iter_swap(declval(), declval())), + decltype(AZStd::ranges::iter_swap(declval(), declval()))>>> = true; +} + +namespace AZStd +{ + template + /*concept*/ constexpr bool indirectly_swappable = Internal::indirectly_swappable_impl; +} + +namespace AZStd::Internal +{ + template + constexpr bool input_iterator_impl = false; + template + constexpr bool input_iterator_impl + && derived_from, input_iterator_tag> + && indirectly_readable + >> = true; +} + +namespace AZStd +{ + // input iterator + template + /*concept*/ constexpr bool input_iterator = Internal::input_iterator_impl; +} + +namespace AZStd::Internal +{ + template + constexpr bool output_iterator_impl = false; + template + constexpr bool output_iterator_impl + && indirectly_writable + && sfinae_trigger_v()++ = AZStd::declval())> + >> = true; +} + +namespace AZStd +{ + // output iterator + template + /*concept*/ constexpr bool output_iterator = Internal::output_iterator_impl; +} + +namespace AZStd::Internal +{ + template + constexpr bool forward_iterator_impl = false; + template + constexpr bool forward_iterator_impl + && derived_from, forward_iterator_tag> + && incrementable + && sentinel_for> > = true; +} + +namespace AZStd +{ + // forward_iterator + template + /*concept*/ constexpr bool forward_iterator = Internal::forward_iterator_impl; +} + +namespace AZStd::Internal +{ + template + constexpr bool bidirectional_iterator_impl = false; + template + constexpr bool bidirectional_iterator_impl + && derived_from, bidirectional_iterator_tag> + && same_as()), I&> + && same_as()--), I> >> = true; +} + +namespace AZStd +{ + // bidirectional iterator + template + /*concept*/ constexpr bool bidirectional_iterator = Internal::bidirectional_iterator_impl; +} + +namespace AZStd::Internal +{ + template + constexpr bool random_access_iterator_impl = false; + template + constexpr bool random_access_iterator_impl + && derived_from, random_access_iterator_tag> + && totally_ordered + && sized_sentinel_for + && same_as() += declval>()), I&> + && same_as() + declval>()), I> + && same_as>() + declval()), I> + && same_as() -= declval>()), I&> + && same_as() - declval>()), I> + && same_as()[declval>()]), iter_reference_t>>> + = true; +} + +namespace AZStd +{ + template + /*concept*/ constexpr bool random_access_iterator = Internal::random_access_iterator_impl; +} + +namespace AZStd::Internal +{ + template + constexpr bool contiguous_iterator_impl = false; + template + constexpr bool contiguous_iterator_impl + && derived_from, contiguous_iterator_tag> + && is_lvalue_reference_v> + && indirectly_readable + && same_as, remove_cvref_t>> + > > + = same_as())), add_pointer_t>>; +} + +namespace AZStd +{ + // contiguous iterator + template + /*concept*/ constexpr bool contiguous_iterator = Internal::contiguous_iterator_impl; +} + +namespace AZStd::Internal +{ + // models the predicate concept + template + constexpr bool predicate_impl = false; + template + constexpr bool predicate_impl = Internal::boolean_testable>; +} + +namespace AZStd +{ + // models the predicate concept + template + /*concept*/ constexpr bool predicate = Internal::predicate_impl, F, Args...>; + + // models the relation concept + template + /*concept*/ constexpr bool relation = predicate && predicate + && predicate && predicate; + + // models the equivalence_relation concept + template + /*concept*/ constexpr bool equivalence_relation = relation; + + // models the strict_weak_order concept + // Note: semantically this is different than equivalence_relation + template + /*concept*/ constexpr bool strict_weak_order = relation; +} diff --git a/Code/Framework/AzCore/AzCore/std/containers/deque.h b/Code/Framework/AzCore/AzCore/std/containers/deque.h index 9eed66aeb3..d34bdb6b5a 100644 --- a/Code/Framework/AzCore/AzCore/std/containers/deque.h +++ b/Code/Framework/AzCore/AzCore/std/containers/deque.h @@ -135,9 +135,10 @@ namespace AZStd AZ_FORCE_INLINE this_type& operator--() { --m_offset; return *this; } AZ_FORCE_INLINE this_type operator--(int) { this_type tmp = *this; --m_offset; return tmp; } AZ_FORCE_INLINE this_type& operator+=(difference_type offset) { m_offset += offset; return *this; } - AZ_FORCE_INLINE this_type operator+(difference_type offset) { this_type tmp = *this; tmp += offset; return tmp; } + AZ_FORCE_INLINE this_type operator+(difference_type offset) const { this_type tmp = *this; tmp += offset; return tmp; } + friend AZ_FORCE_INLINE this_type operator+(difference_type offset, const this_type& rhs) { this_type tmp = rhs; tmp += offset; return tmp; } AZ_FORCE_INLINE this_type& operator-=(difference_type offset) { m_offset -= offset; return *this; } - AZ_FORCE_INLINE this_type operator-(difference_type offset) { this_type tmp = *this; tmp -= offset; return tmp; } + AZ_FORCE_INLINE this_type operator-(difference_type offset) const { this_type tmp = *this; tmp -= offset; return tmp; } /// ??? AZ_FORCE_INLINE difference_type operator-(const this_type& rhs) const { @@ -197,9 +198,10 @@ namespace AZStd AZ_FORCE_INLINE this_type& operator--() { --base_type::m_offset; return *this; } AZ_FORCE_INLINE this_type operator--(int) { this_type tmp = *this; --base_type::m_offset; return tmp; } AZ_FORCE_INLINE this_type& operator+=(difference_type offset) { base_type::m_offset += offset; return *this; } - AZ_FORCE_INLINE this_type operator+(difference_type offset) { this_type tmp = *this; tmp += offset; return tmp; } + AZ_FORCE_INLINE this_type operator+(difference_type offset) const { this_type tmp = *this; tmp += offset; return tmp; } + friend AZ_FORCE_INLINE this_type operator+(difference_type offset, const this_type& rhs) { this_type tmp = rhs; tmp += offset; return tmp; } AZ_FORCE_INLINE this_type& operator-=(difference_type offset) { base_type::m_offset -= offset; return *this; } - AZ_FORCE_INLINE this_type operator-(difference_type offset) { this_type tmp = *this; tmp -= offset; return tmp; } + AZ_FORCE_INLINE this_type operator-(difference_type offset) const { this_type tmp = *this; tmp -= offset; return tmp; } AZ_FORCE_INLINE difference_type operator-(const this_type& rhs) const { return rhs.m_offset <= base_type::m_offset ? base_type::m_offset - rhs.m_offset : -(difference_type)(rhs.m_offset - base_type::m_offset); diff --git a/Code/Framework/AzCore/AzCore/std/containers/fixed_vector.h b/Code/Framework/AzCore/AzCore/std/containers/fixed_vector.h index 13f3ef2d7a..22edfbd927 100644 --- a/Code/Framework/AzCore/AzCore/std/containers/fixed_vector.h +++ b/Code/Framework/AzCore/AzCore/std/containers/fixed_vector.h @@ -9,6 +9,7 @@ #include #include +#include #include #include @@ -101,7 +102,7 @@ namespace AZStd::Internal //! Invokes destructor on all elements in range //! No-op on empty container //! Nothing to destroy since the storage is empty. - template >> + template >> static constexpr void unsafe_destroy(InputIt, InputIt) noexcept { } @@ -214,7 +215,7 @@ namespace AZStd::Internal //! Destructs elements in the range [begin, end). //! This does not modify the size of the storage //! This is a no-op for trivial types - template >> + template >> void unsafe_destroy(InputIt, InputIt) noexcept { } @@ -334,7 +335,7 @@ namespace AZStd::Internal //! Destructs elements in the range [begin, end). //! This does not modify the size of the storage //! Invokes the destuctor via the AZStd::destroy method - template >> + template >> void unsafe_destroy(InputIt first, InputIt last) noexcept(is_nothrow_destructible_v) { AZSTD_CONTAINER_ASSERT(first >= data() && first <= data() + size(), "begin iterator is not in range of storage"); @@ -410,7 +411,7 @@ namespace AZStd AZStd::uninitialized_fill_n(data(), numElements, value); } - template >> + template >> fixed_vector(InputIt first, InputIt last) { resize_no_construct(AZStd::distance(first, last)); @@ -615,7 +616,7 @@ namespace AZStd insert(end(), numElements, value); } - template >> + template >> void assign(InputIt first, InputIt last) { clear(); @@ -641,8 +642,18 @@ namespace AZStd return &newElement; } - AZStd::uninitialized_move(insertPosPtr, dataEnd, insertPosPtr + 1); + // We need to move data with care, it is overlapping. + + // first move the last element into the uninitialized position as that will not overlap. + pointer nonOverlap = dataEnd - 1; + AZStd::uninitialized_move(nonOverlap, dataEnd, dataEnd); + + // copy the memory backwards while performing AZStd::move on the existing elements the area with overlapping memory + // to move the elments to the right by 1 + AZStd::move_backward(insertPosPtr, nonOverlap, dataEnd); + // add new elements AZStd::construct_at(insertPosPtr, AZStd::forward(args)...); + resize_no_construct(size() + 1); return iterator(insertPosPtr); } iterator insert(const_iterator insertPos, const_reference value) @@ -707,7 +718,7 @@ namespace AZStd } } - template>> + template>> void insert(const_iterator insertPos, InputIt first, InputIt last) { // specialize for iterator categories. diff --git a/Code/Framework/AzCore/AzCore/std/containers/span.h b/Code/Framework/AzCore/AzCore/std/containers/span.h index fbf5f56870..d0ac704fc3 100644 --- a/Code/Framework/AzCore/AzCore/std/containers/span.h +++ b/Code/Framework/AzCore/AzCore/std/containers/span.h @@ -7,9 +7,37 @@ */ #pragma once -#include -#include #include +#include +#include +#include + +namespace AZStd +{ + inline constexpr size_t dynamic_extent = numeric_limits::max(); + + template + class span; +} + +namespace AZStd::Internal +{ + template + inline constexpr bool is_std_array = false; + + template + inline constexpr bool is_std_array<::AZStd::array> = true; + + template + inline constexpr bool is_std_span = false; + + template + inline constexpr bool is_std_span<::AZStd::span> = true; + + template + inline constexpr bool is_array_convertible = is_convertible_v; + +} namespace AZStd { @@ -33,97 +61,149 @@ namespace AZStd * * Since the span does not copy and store any data, it is only valid as long as the data used to create it is valid. */ - template - class span final + template + class span { public: using element_type = T; using value_type = AZStd::remove_cv_t; - - using pointer = T*; - using const_pointer = const T*; - - using reference = T&; - using const_reference = const T&; - using size_type = AZStd::size_t; using difference_type = AZStd::ptrdiff_t; - using iterator = T*; - using const_iterator = const T*; + using pointer = element_type*; + using const_pointer = const element_type*; + + using reference = element_type&; + using const_reference = const element_type&; + + + using iterator = element_type*; + using const_iterator = const element_type*; using reverse_iterator = AZStd::reverse_iterator; using const_reverse_iterator = AZStd::reverse_iterator; - constexpr span(); + inline static constexpr size_t extent = Extent; + + constexpr span() noexcept = default;; ~span() = default; - constexpr span(pointer s, size_type length); + template && + Internal::is_array_convertible>, T> && + Extent == dynamic_extent>* = nullptr> + constexpr span(It first, size_type length); - constexpr span(pointer first, pointer last); + template && + Internal::is_array_convertible>, T> && + Extent != dynamic_extent, int> = 0> + constexpr explicit span(It first, size_type length); - // We explicitly delete this constructor because it's too easy to accidentally - // create a span to just the first element instead of an entire array. - constexpr span(const_pointer s) = delete; + template && + Internal::is_array_convertible>, T> && + sized_sentinel_for && + Extent == dynamic_extent>* = nullptr> + constexpr span(It first, End last); - template - constexpr span(Container& data); + template && + Internal::is_array_convertible>, T> && + sized_sentinel_for && + Extent != dynamic_extent, int> = 0> + constexpr explicit span(It first, End last); - template - constexpr span(const Container& data); + template> + constexpr span(type_identity_t (&arr)[N]) noexcept; - constexpr span(const span&) = default; + template > + constexpr span(array& data) noexcept; + template > + constexpr span(const array& data) noexcept; - constexpr span(span&& other); + template && + ranges::sized_range && + (ranges::borrowed_range || is_const_v) && + !Internal::is_std_span> && + !Internal::is_std_array> && + !is_array_v> && + Internal::is_array_convertible>, element_type> >> + constexpr span(R&& r); + + template >> + constexpr span(const span& other); + + constexpr span(const span&) noexcept = default; constexpr span& operator=(const span& other) = default; - constexpr span& operator=(span&& other); + // subviews -> https://eel.is/c++draft/views#span.sub + template + constexpr span first() const; + template + constexpr span last() const; + template + constexpr auto subspan() const; - constexpr size_type size() const; + constexpr span first(size_type count) const; + constexpr span last(size_type count) const; + constexpr span subspan(size_type offset, size_type count = dynamic_extent) const; - constexpr bool empty() const; + // observers - https://eel.is/c++draft/views#span.obs + constexpr size_type size() const noexcept; + constexpr size_type size_bytes() const noexcept; - constexpr pointer data(); - constexpr const_pointer data() const; + [[nodiscard]] constexpr bool empty() const noexcept; - constexpr const_reference operator[](size_type index) const; - constexpr reference operator[](size_type index); + // element access - https://eel.is/c++draft/views#span.elem + constexpr reference operator[](size_type index) const; + constexpr reference front() const; + constexpr reference back() const; + constexpr pointer data() const noexcept; - constexpr void erase(); + // iterator support - https://eel.is/c++draft/views#span.iterators + constexpr iterator begin() const noexcept; + constexpr iterator end() const noexcept; - constexpr iterator begin(); - constexpr iterator end(); - constexpr const_iterator begin() const; - constexpr const_iterator end() const; - - constexpr const_iterator cbegin() const; - constexpr const_iterator cend() const; - - constexpr reverse_iterator rbegin(); - constexpr reverse_iterator rend(); - constexpr const_reverse_iterator rbegin() const; - constexpr const_reverse_iterator rend() const; - - constexpr const_reverse_iterator crbegin() const; - constexpr const_reverse_iterator crend() const; - - friend bool operator==(span lhs, span rhs) - { - return lhs.m_begin == rhs.m_begin && lhs.m_end == rhs.m_end; - } - - friend bool operator!=(span lhs, span rhs) { return !(lhs == rhs); } - friend bool operator< (span lhs, span rhs) { return lhs.m_begin < rhs.m_begin || lhs.m_begin == rhs.m_begin && lhs.m_end < rhs.m_end; } - friend bool operator> (span lhs, span rhs) { return lhs.m_begin > rhs.m_begin || lhs.m_begin == rhs.m_begin && lhs.m_end > rhs.m_end; } - friend bool operator<=(span lhs, span rhs) { return lhs == rhs || lhs < rhs; } - friend bool operator>=(span lhs, span rhs) { return lhs == rhs || lhs > rhs; } + constexpr reverse_iterator rbegin() const noexcept; + constexpr reverse_iterator rend() const noexcept; private: - pointer m_begin; - pointer m_end; + pointer m_data{}; + size_type m_size{}; }; + // deduction guides https://eel.is/c++draft/views#span.deduct + template >> + span(It, EndOrSize) -> span>>; + + // array deductions + template + span(T(&)[N]) -> span; + template + span(array&) -> span; + template + span(const array&) -> span; + + template >> + span(R&&) -> span>>; + + // [span.objectrep], views of object representation + template + auto as_bytes(span s) noexcept + -> span; + + template + auto as_writable_bytes(span s) noexcept + -> enable_if_t, span>; + } // namespace AZStd +namespace AZStd::ranges +{ + template + inline constexpr bool enable_view> = true; + template + inline constexpr bool enable_borrowed_range> = true; +} + #include diff --git a/Code/Framework/AzCore/AzCore/std/containers/span.inl b/Code/Framework/AzCore/AzCore/std/containers/span.inl index 2b24a11fc3..765056cb67 100644 --- a/Code/Framework/AzCore/AzCore/std/containers/span.inl +++ b/Code/Framework/AzCore/AzCore/std/containers/span.inl @@ -9,116 +9,206 @@ namespace AZStd { - template - inline constexpr span::span() - : m_begin(nullptr) - , m_end(nullptr) - { } + template + template && + Internal::is_array_convertible>, T> && + Extent == dynamic_extent>*> + inline constexpr span::span(It first, size_type length) + : m_data{ to_address(first) } + , m_size{ length } + {} - template - inline constexpr span::span(pointer s, size_type length) - : m_begin(s) - , m_end(m_begin + length) + template + template && + Internal::is_array_convertible>, T> && + Extent != dynamic_extent, int>> + inline constexpr span::span(It first, size_type length) + : m_data{ to_address(first) } + , m_size{ length } + {} + + template + template && + Internal::is_array_convertible>, T> && + sized_sentinel_for && + Extent == dynamic_extent>*> + inline constexpr span::span(It first, End last) + : m_data{to_address(first)} + , m_size(last - first) + {} + + template + template && + Internal::is_array_convertible>, T> && + sized_sentinel_for && + Extent != dynamic_extent, int>> + inline constexpr span::span(It first, End last) + : m_data{to_address(first)} + , m_size(last - first) + {} + + template + template + inline constexpr span::span(type_identity_t(&arr)[N]) noexcept + : m_data{ arr } + , m_size{ N } + {} + + template + template + inline constexpr span::span(array& arr) noexcept + : m_data{ arr.data() } + , m_size{ arr.size() } + {} + template + template + inline constexpr span::span(const array& arr) noexcept + : m_data{ arr.data() } + , m_size{ arr.size() } + {} + + template + template + inline constexpr span::span(R&& r) + : m_data{ ranges::data(r) } + , m_size{ ranges::size(r) } { - if (length == 0) erase(); + AZ_Assert(Extent == dynamic_extent || Extent == m_size, "The extent of the span is non dynamic," + " therefore the range size must match the extent. Extent=%zu, Range size=%zu", + Extent, ranges::size(r)); } - template - inline constexpr span::span(pointer first, pointer last) - : m_begin(first) - , m_end(last) - { } - - template - template - inline constexpr span::span(Container& data) - : m_begin(data.data()) - , m_end(m_begin + data.size()) - { } - - template - template - inline constexpr span::span(const Container& data) - : m_begin(data.data()) - , m_end(m_begin + data.size()) - { } - - template - inline constexpr span::span(span&& other) - : span(other.m_begin, other.m_end) + template + template + inline constexpr span::span(const span& other) + : m_data{ other.data() } + , m_size{ other.size() } { -#if AZ_DEBUG_BUILD // Clearing the original pointers isn't necessary, but is good for debugging - other.m_begin = nullptr; - other.m_end = nullptr; -#endif + AZ_Assert(Extent == dynamic_extent || Extent == m_size, "The extent of the span is non dynamic," + " therefore the current size of the other span must match the extent. Extent=%zu, Other span size=%zu", + Extent, other.size()); } - template - inline constexpr AZStd::size_t span::size() const { return m_end - m_begin; } - - template - inline constexpr bool span::empty() const { return m_end == m_begin; } - - template - inline constexpr Element* span::data() { return m_begin; } - - template - inline constexpr const Element* span::data() const { return m_begin; } - - template - inline constexpr span& span::operator=(span&& other) + // subviews + template + template + inline constexpr auto span::first() const -> span { - m_begin = other.m_begin; - m_end = other.m_end; -#if AZ_DEBUG_BUILD // Clearing the original pointers isn't necessary, but is good for debugging - other.m_begin = nullptr; - other.m_end = nullptr; -#endif - return *this; + static_assert(Count <= Extent, "Count is larger than the Extent of the span, a subview of the first" + " Count elemnts of the span cannot be returned"); + AZ_Assert(Count <= size(), "Count %zu is larger than span size %zu", Count, size()); + return span{data(), Count}; } - - template - inline constexpr const Element& span::operator[](AZStd::size_t index) const + template + inline constexpr auto span::first(size_type count) const -> span + { + AZ_Assert(count <= size(), "Count %zu is larger than current size of span size %zu", count, size()); + return { data(), count }; + } + + template + template + inline constexpr auto span::last() const -> span + { + static_assert(Count <= Extent, "Count is larger than the Extent of the span, a subview of the last" + " Count elements of the span cannot be returned"); + AZ_Assert(Count <= size(), "Count %zu is larger than span size %zu", Count, size()); + return span{data() + (size() - Count), Count}; + } + template + inline constexpr auto span::last(size_type count) const -> span + { + AZ_Assert(count <= size(), "Count %zu is larger than span size %zu", count, size()); + return { data() + (size() - count), count }; + } + + template + template + inline constexpr auto span::subspan() const + { + static_assert(Offset <= Extent && (Count == dynamic_extent || Count <= Extent - Offset), + "Subspan Offset must <= span Extent and the Count must be either dynamic_extent" + " or <= (span Extent - Offset)"); + AZ_Assert(Offset <= size() && (Count == dynamic_extent || Count <= size() - Offset), + "Either the Subspan Offset %zu is larger than the span size %zu or the Count != dynamic_extent and" + " its value %zu is greater than \"span size - Offset\" %zu", + Offset, size(), Count, size() - Offset); + using return_type = span; + return return_type{ data() + Offset, Count != dynamic_extent ? Count : size() - Offset }; + } + + template + inline constexpr auto span::subspan(size_type offset, size_type count) const -> span + { + AZ_Assert(offset <= size() && (count == dynamic_extent || count <= size() - offset), + "Either the Subspan offset %zu is larger than the span size %zu or the count != dynamic_extent and" + " its value %zu is greater than \"span size - offset\" %zu", + offset, size(), count, size() - offset); + return { data() + offset, count != dynamic_extent ? count : size() - offset }; + } + + + // observers + template + inline constexpr auto span::size() const noexcept -> size_type { return m_size; } + + template + inline constexpr auto span::size_bytes() const noexcept -> size_type { return m_size * sizeof(element_type); } + + template + [[nodiscard]] inline constexpr bool span::empty() const noexcept{ return size() == 0; } + + // element access + template + inline constexpr auto span::operator[](size_type index) const -> reference { AZ_Assert(index < size(), "index value is out of range"); - return m_begin[index]; + return data()[index]; } - template - inline constexpr Element& span::operator[](AZStd::size_t index) + template + inline constexpr auto span::front() const -> reference { - AZ_Assert(index < size(), "index value is out of range"); - return m_begin[index]; + AZ_Assert(!empty(), "span cannot be empty when invoking front"); + return *data(); } - template - inline constexpr void span::erase() { m_begin = m_end = nullptr; } - - template - inline constexpr Element* span::begin() { return m_begin; } - template - inline constexpr Element* span::end() { return m_end; } - template - inline constexpr const Element* span::begin() const { return m_begin; } - template - inline constexpr const Element* span::end() const { return m_end; } + template + inline constexpr auto span::back() const -> reference + { + AZ_Assert(!empty(), "span cannot be empty when invoking back"); + return *(data() + (size() - 1)); + } - template - inline constexpr const Element* span::cbegin() const { return m_begin; } - template - inline constexpr const Element* span::cend() const { return m_end; } + // iterator support + template + inline constexpr auto span::data() const noexcept -> pointer { return m_data; } - template - inline constexpr AZStd::reverse_iterator span::rbegin() { return AZStd::reverse_iterator(m_end); } - template - inline constexpr AZStd::reverse_iterator span::rend() { return AZStd::reverse_iterator(m_begin); } - template - inline constexpr AZStd::reverse_iterator span::rbegin() const { return AZStd::reverse_iterator(m_end); } - template - inline constexpr AZStd::reverse_iterator span::rend() const { return AZStd::reverse_iterator(m_begin); } + template + inline constexpr auto span::begin() const noexcept -> iterator{ return m_data; } + template + inline constexpr auto span::end() const noexcept -> iterator { return m_data + m_size; } - template - inline constexpr AZStd::reverse_iterator span::crbegin() const { return AZStd::reverse_iterator(cend()); } - template - inline constexpr AZStd::reverse_iterator span::crend() const { return AZStd::reverse_iterator(cbegin()); } + template + inline constexpr auto span::rbegin() const noexcept -> reverse_iterator { return AZStd::make_reverse_iterator(end()); } + template + inline constexpr auto span::rend() const noexcept -> reverse_iterator { return AZStd::make_reverse_iterator(begin()); } + + + template + inline auto as_bytes(span s) noexcept + -> span + { + return span( + reinterpret_cast(s.data()), s.size_bytes()); + } + + + template + inline auto as_writable_bytes(span s) noexcept + -> enable_if_t, span> + { + return span( + reinterpret_cast(s.data()), s.size_bytes()); + } } // namespace AZStd diff --git a/Code/Framework/AzCore/AzCore/std/createdestroy.h b/Code/Framework/AzCore/AzCore/std/createdestroy.h index 355374a13a..2f5c7fde92 100644 --- a/Code/Framework/AzCore/AzCore/std/createdestroy.h +++ b/Code/Framework/AzCore/AzCore/std/createdestroy.h @@ -7,22 +7,19 @@ */ #pragma once +#include #include #include #include #include #include #include -#include #include #include #include // AZStd::addressof namespace AZStd { - // alias std::pointer_traits into the AZStd::namespace - using std::pointer_traits; - //! Bring the names of uninitialized_default_construct and //! uninitialized_default_construct_n into the AZStd namespace using std::uninitialized_default_construct; @@ -34,42 +31,6 @@ namespace AZStd using std::uninitialized_value_construct_n; } -namespace AZStd::Internal -{ - template - constexpr bool pointer_traits_has_to_address_v = false; - template - constexpr bool pointer_traits_has_to_address_v::to_address(declval()))>> = true; -} - -namespace AZStd -{ - //! Implements the C++20 to_address function - //! This obtains the address represented by ptr without forming a reference - //! to the pointee type - template - constexpr T* to_address(T* ptr) noexcept - { - static_assert(!AZStd::is_function_v, "Invoking to address on a function pointer is not allowed"); - return ptr; - } - //! Fancy pointer overload which delegates to using a specialization of pointer_traits::to_address - //! if that is a well-formed expression, otherwise it returns ptr->operator->() - //! For example invoking `to_address(AZStd::reverse_iterator(char_ptr))` - //! Returns an element of type const char* - template - constexpr auto to_address(const T& ptr) noexcept - { - if constexpr (AZStd::Internal::pointer_traits_has_to_address_v) - { - return pointer_traits::to_address(ptr); - } - else - { - return AZStd::to_address(ptr.operator->()); - } - } -} namespace AZStd::Internal { /** @@ -81,7 +42,7 @@ namespace AZStd::Internal /** * Type has trivial destructor. We don't call it. */ - template ::value_type, bool = is_trivially_destructible_v> + template , bool = is_trivially_destructible_v> struct destroy { static constexpr void range(InputIterator first, InputIterator last) { (void)first; (void)last; } @@ -163,7 +124,7 @@ namespace AZStd::Internal * Default object construction. */ // placement new isn't a core constant expression therefore it cannot be used in a constexpr function - template::value_type, + template, bool = is_trivially_constructible_v> struct construct { @@ -242,93 +203,125 @@ namespace AZStd::Internal ////////////////////////////////////////////////////////////////////////// // Sequence copy. If we use optimized version we use memcpy. /** - * Helper class to determine if we have apply fast copy. There are 2 conditions + * Class to determine if we have apply fast copy. There are 2 conditions * - trivial copy ctor. - * - all iterators satisfy the C++20 are contiguous iterator concept: pointers or iterator classes with - * the iterator_concept typedef set to contiguous_iterator_tag + * - all iterators satisfy the C++20 are contiguous iterator concept */ + template + constexpr bool indirectly_trivially_copyable = false; + template + constexpr bool indirectly_trivially_copyable>> = is_trivially_copyable_v>; + template - struct is_fast_copy_helper - { - using value_type = typename iterator_traits::value_type; - static constexpr bool value = AZStd::is_trivially_copyable_v - && Internal::satisfies_contiguous_iterator_concept_v - && Internal::satisfies_contiguous_iterator_concept_v; - }; + using is_fast_copy = bool_constant + && contiguous_iterator + && contiguous_iterator + >; - // Use this trait to to determine copy mode, based on the iterator category and object copy properties, - // Use it when when you call uninitialized_copy, Internal::copy, Internal::move, etc. - template< typename InputIterator, typename ResultIterator > - struct is_fast_copy - : public ::AZStd::integral_constant::value> {}; + template + constexpr bool is_fast_copy_v = is_fast_copy::value; + + // is_fast_copy argument is no longer used. template - constexpr ForwardIterator copy(const InputIterator& first, const InputIterator& last, ForwardIterator result, const false_type& /* is_fast_copy() */) + constexpr ForwardIterator copy(InputIterator first, InputIterator last, ForwardIterator result, bool) { - InputIterator iter(first); - for (; iter != last; ++result, ++iter) + if constexpr (is_fast_copy_v) { - *result = *iter; - } + // Specialized copy for contiguous iterators which are trivially copyable + size_t numElements = last - first; + if (numElements > 0) + { +#if az_has_builtin_memcpy + static_assert(sizeof(iter_value_t) == sizeof(iter_value_t), "Size of value types must match for a trivial copy"); + __builtin_memcpy(to_address(result), to_address(first), numElements * sizeof(iter_value_t)); +#else + if (az_builtin_is_constant_evaluated()) + { + for (; first != last; ++result, ++first) + { + *result = *first; + } - return result; + return result; + } + else + { + static_assert(sizeof(iter_value_t) == sizeof(iter_value_t), "Size of value types must match for a trivial copy"); + AZ_Assert((static_cast(&*result) < static_cast(&*first)) + || (static_cast(&*result) >= static_cast(&*first + numElements)), + "AZStd::copy memory overlaps use AZStd::copy_backward!"); + ::memcpy(to_address(result), to_address(first), numElements * sizeof(iter_value_t)); + } +#endif + } + return result + numElements; + } + else + { + for (; first != last; ++result, ++first) + { + *result = *first; + } + + return result; + } } - // Specialized copy for contiguous iterators (pointers) and trivial copy type. - // This overload cannot be constexpr until builtin_memcpy is added to MSVC compilers - template - inline ForwardIterator copy(const InputIterator& first, const InputIterator& last, ForwardIterator result, const true_type& /* is_fast_copy() */) - { - // \todo Make sure memory ranges don't overlap, otherwise people should use move and move_backward. - static_assert(sizeof(typename iterator_traits::value_type) == sizeof(typename iterator_traits::value_type), "Size of value types must match for a trivial copy"); - AZStd::size_t numElements = last - first; - if (numElements > 0) - { - AZ_Assert((static_cast(&*result) < static_cast(&*first)) || (static_cast(&*result) >= static_cast(&*first + numElements)), "AZStd::copy memory overlaps use AZStd::copy_backward!"); - AZ_Assert((static_cast(&*result + numElements) <= static_cast(&*first)) || (static_cast(&*result + numElements) > static_cast(&*first + numElements)), "AZStd::copy memory overlaps use AZStd::copy_backward!"); - /*AZSTD_STL::*/ memcpy(&*result, &*first, numElements * sizeof(typename iterator_traits::value_type)); - } - return result + numElements; - } // Copy backward. template - constexpr BidirectionalIterator2 copy_backward(const BidirectionalIterator1& first, const BidirectionalIterator1& last, BidirectionalIterator2 result, const false_type& /* is_fast_copy() */) + constexpr BidirectionalIterator2 copy_backward(BidirectionalIterator1 first, BidirectionalIterator1 last, BidirectionalIterator2 result, bool) { - BidirectionalIterator1 iter(last); - while (first != iter) + if constexpr (is_fast_copy_v) { - *--result = *--iter; + // Specialized copy for contiguous iterators which are trivially copyable + size_t numElements = last - first; + if (numElements > 0) + { +#if az_has_builtin_memmove + static_assert(sizeof(iter_value_t) == sizeof(iter_value_t), "Size of value types must match for a trivial copy"); + result -= numElements; + __builtin_memmove(to_address(result), to_address(first), numElements * sizeof(iter_value_t)); +#else + if (az_builtin_is_constant_evaluated()) + { + while (first != last) + { + *--result = *--last; + } + + return result; + } + else + { + static_assert(sizeof(iter_value_t) == sizeof(iter_value_t), "Size of value types must match for a trivial copy"); + result -= numElements; + AZ_Assert(((&*result + numElements) <= &*first) || ((&*result + numElements) > (&*first + numElements)), "AZStd::copy_backward memory overlaps use AZStd::copy!"); + ::memmove(&*result, &*first, numElements * sizeof(iter_value_t)); + } +#endif + } + return result; } - - return result; - } - - // Specialized copy for contiguous iterators (pointers) and trivial copy type. - // This overload cannot be constexpr until builtin_memcpy is added to MSVC compilers - template - inline BidirectionalIterator2 copy_backward(const BidirectionalIterator1& first, const BidirectionalIterator1& last, BidirectionalIterator2 result, const true_type& /* is_fast_copy() */) - { - // \todo Make sure memory ranges don't overlap, otherwise people should use move and move_backward. - static_assert(sizeof(typename iterator_traits::value_type) == sizeof(typename iterator_traits::value_type), "Size of value types must match for a trivial copy"); - AZStd::size_t numElements = last - first; - if (numElements > 0) + else { - result -= numElements; - AZ_Assert((&*result < &*first) || (&*result >= (&*first + numElements)), "AZStd::copy_backward memory overlaps use AZStd::copy!"); - AZ_Assert(((&*result + numElements) <= &*first) || ((&*result + numElements) > (&*first + numElements)), "AZStd::copy_backward memory overlaps use AZStd::copy!"); - /*AZSTD_STL::*/ memcpy(&*result, &*first, numElements * sizeof(typename iterator_traits::value_type)); + while (first != last) + { + *--result = *--last; + } + + return result; } - return result; } template - constexpr ForwardIterator reverse_copy(const BidirectionalIterator1& first, const BidirectionalIterator1& last, ForwardIterator dest) + constexpr ForwardIterator reverse_copy(BidirectionalIterator1 first, BidirectionalIterator1 last, ForwardIterator dest) { - BidirectionalIterator1 iter(last); - while (iter != first) + while (last != first) { - *(dest++) = *(--iter); + *(dest++) = *(--last); } return dest; @@ -342,143 +335,209 @@ namespace AZStd * Specialized algorithms 20.4.4. We extend that by adding faster specialized versions when we have trivial assign type. */ template - constexpr ForwardIterator uninitialized_copy(const InputIterator& first, const InputIterator& last, ForwardIterator result, const false_type& /* is_fast_copy() */) + constexpr ForwardIterator uninitialized_copy(InputIterator first, InputIterator last, ForwardIterator result, bool) { - InputIterator iter(first); - for (; iter != last; ++result, ++iter) + // Specialized copy for contiguous iterators which are trivially copyable + if constexpr (Internal::is_fast_copy_v) { - ::new (static_cast(&*result)) typename iterator_traits::value_type(*iter); - } + size_t numElements = last - first; + if (numElements > 0) + { +#if az_has_builtin_memcpy + static_assert(sizeof(iter_value_t) == sizeof(iter_value_t), "Value type sizes must match for a trivial copy"); + __builtin_memcpy(to_address(result), to_address(first), numElements * sizeof(iter_value_t)); +#else + if (az_builtin_is_constant_evaluated()) + { + for (; first != last; ++result, ++first) + { + construct_at(static_cast*>(to_address(result)), *first); + } - return result; + return result; + } + else + { + static_assert(sizeof(iter_value_t) == sizeof(iter_value_t), "Value type sizes must match for a trivial copy"); + ::memcpy(to_address(result), to_address(first), numElements * sizeof(iter_value_t)); + } +#endif + } + return result + numElements; + } + else + { + for (; first != last; ++result, ++first) + { + construct_at(static_cast*>(to_address(result)), *first); + } + + return result; + } } - // Specialized copy for contiguous iterators and trivial copy type. - // This overload cannot be constexpr until builtin_memcpy is added to MSVC compilers - template - inline ForwardIterator uninitialized_copy(const InputIterator& first, const InputIterator& last, ForwardIterator result, const true_type& /* is_fast_copy() */) - { - static_assert(sizeof(typename iterator_traits::value_type) == sizeof(typename iterator_traits::value_type), "Value type sizes must match for a trivial copy"); - AZStd::size_t numElements = last - first; - if (numElements > 0) - { - /*AZSTD_STL::*/ - memcpy(&*result, &*first, numElements * sizeof(typename iterator_traits::value_type)); - } - return result + numElements; - } template - constexpr ForwardIterator uninitialized_copy(const InputIterator& first, const InputIterator& last, ForwardIterator result) + constexpr ForwardIterator uninitialized_copy(InputIterator first, InputIterator last, ForwardIterator result) { - return uninitialized_copy(first, last, result, Internal::is_fast_copy()); + return uninitialized_copy(first, last, result, {}); } // 25.3.1 Copy template constexpr OutputIterator copy(InputIterator first, InputIterator last, OutputIterator result) { - return AZStd::Internal::copy(first, last, result, AZStd::Internal::is_fast_copy()); + return Internal::copy(first, last, result, {}); } template constexpr OutputIterator reverse_copy(BidirectionalIterator first, BidirectionalIterator last, OutputIterator dest) { - return AZStd::Internal::reverse_copy(first, last, dest); + return Internal::reverse_copy(first, last, dest); } template BidirectionalIterator2 copy_backward(BidirectionalIterator1 first, BidirectionalIterator1 last, BidirectionalIterator2 result) { - return AZStd::Internal::copy_backward(first, last, result, AZStd::Internal::is_fast_copy()); + return Internal::copy_backward(first, last, result, {}); } } namespace AZStd::Internal { ////////////////////////////////////////////////////////////////////////// - // Sequence move. If we use optimized version we use memmove. + // Sequence move template - constexpr ForwardIterator move(const InputIterator& first, const InputIterator& last, ForwardIterator result, const false_type& /* is_fast_copy() */) + constexpr ForwardIterator move(InputIterator first, InputIterator last, ForwardIterator result, bool) { - InputIterator iter(first); - for (; iter != last; ++result, ++iter) + // Specialized copy for contiguous iterators which are trivially copyable + if constexpr (is_fast_copy_v) { - *result = AZStd::move(*iter); + size_t numElements = last - first; + if (numElements > 0) + { +#if az_has_builtin_memcpy + static_assert(sizeof(iter_value_t) == sizeof(iter_value_t), "Size of value types must match for a trivial copy"); + __builtin_memcpy(to_address(result), to_address(first), numElements * sizeof(iter_value_t)); +#else + if (az_builtin_is_constant_evaluated()) + { + for (; first != last; ++result, ++first) + { + *result = ::AZStd::move(*first); + } + return result; + } + else + { + static_assert(sizeof(iter_value_t) == sizeof(iter_value_t), "Size of value types must match for a trivial copy"); + AZ_Assert((static_cast(&*result) < static_cast(&*first)) + || (static_cast(&*result) >= static_cast(&*first + numElements)), + "AZStd::move memory overlaps use AZStd::move_backward!"); + ::memcpy(to_address(result), to_address(first), numElements * sizeof(iter_value_t)); + } +#endif + } + return result + numElements; + } + else + { + for (; first != last; ++result, ++first) + { + *result = ::AZStd::move(*first); + } + return result; } - return result; } - // Specialized copy for contiguous iterators (pointers) and trivial copy type. - // This overload cannot be constexpr until builtin_memmove is added to MSVC compilers - template - inline ForwardIterator move(const InputIterator& first, const InputIterator& last, ForwardIterator result, const true_type& /* is_fast_copy() */) - { - static_assert(sizeof(typename iterator_traits::value_type) == sizeof(typename iterator_traits::value_type), "Size of value types must match for a trivial copy"); - AZStd::size_t numElements = last - first; - if (numElements > 0) - { - /*AZSTD_STL::*/ - memmove(&*result, &*first, numElements * sizeof(typename iterator_traits::value_type)); - } - return result + numElements; - } // For generic iterators, move is the same as copy. template - constexpr BidirectionalIterator2 move_backward(const BidirectionalIterator1& first, const BidirectionalIterator1& last, BidirectionalIterator2 result, const false_type& /* is_fast_copy() */) + constexpr BidirectionalIterator2 move_backward(BidirectionalIterator1 first, BidirectionalIterator1 last, BidirectionalIterator2 result, bool) { - BidirectionalIterator1 iter(last); - while (first != iter) + // Specialized copy for contiguous iterators which are trivially copyable + if constexpr (is_fast_copy_v) { - *--result = AZStd::move(*--iter); + size_t numElements = last - first; + if (numElements > 0) + { +#if az_has_builtin_memmove + static_assert(sizeof(iter_value_t) == sizeof(iter_value_t), "Size of value types must match for a trivial copy"); + result -= numElements; + __builtin_memmove(to_address(result), to_address(first), numElements * sizeof(iter_value_t)); +#else + if (az_builtin_is_constant_evaluated()) + { + while (first != last) + { + *--result = ::AZStd::move(*--last); + } + return result; + } + else + { + static_assert(sizeof(iter_value_t) == sizeof(iter_value_t), "Size of value types must match for a trivial copy"); + result -= numElements; + AZ_Assert((static_cast(&*result + numElements) <= static_cast(&*first)) + || (static_cast(&*result + numElements) > static_cast(&*first + numElements)), + "AZStd::move_backward memory overlaps use AZStd::move!"); + ::memmove(to_address(result), to_address(first), numElements * sizeof(iter_value_t)); + } +#endif + } + return result; } - return result; - } - - // Specialized copy for contiguous iterators (pointers) and trivial copy type. - // This overload cannot be constexpr until builtin_memmove is added to MSVC compilers - template - inline BidirectionalIterator2 move_backward(const BidirectionalIterator1& first, const BidirectionalIterator1& last, BidirectionalIterator2 result, const true_type& /* is_fast_copy() */) - { - // \todo Make sure memory ranges don't overlap, otherwise people should use move and move_backward. - static_assert(sizeof(typename iterator_traits::value_type) == sizeof(typename iterator_traits::value_type), "Size of value types must match for a trivial copy"); - AZStd::size_t numElements = last - first; - result -= numElements; - if (numElements > 0) + else { - /*AZSTD_STL::*/ - memmove(&*result, &*first, numElements * sizeof(typename iterator_traits::value_type)); + while (first != last) + { + *--result = ::AZStd::move(*--last); + } + return result; } - return result; } template - constexpr ForwardIterator uninitialized_move(const InputIterator& first, const InputIterator& last, ForwardIterator result, const false_type& /* is_fast_copy() */) + constexpr ForwardIterator uninitialized_move(InputIterator first, InputIterator last, ForwardIterator result, bool) { - InputIterator iter(first); - - for (; iter != last; ++result, ++iter) + // Specialized copy for contiguous iterators which are trivially copyable + if constexpr (is_fast_copy_v) { - ::new (static_cast(&*result)) typename iterator_traits::value_type(AZStd::move(*iter)); - } - return result; - } - // Specialized copy for contiguous iterators and trivial move type. (since the object is POD we will just perform a copy) - // This overload cannot be constexpr until builtin_memcpy is added to MSVC compilers - template - inline ForwardIterator uninitialized_move(const InputIterator& first, const InputIterator& last, ForwardIterator result, const true_type& /* is_fast_copy() */) - { - static_assert(sizeof(typename iterator_traits::value_type) == sizeof(typename iterator_traits::value_type), "Value type sizes must match for a trivial copy"); - AZStd::size_t numElements = last - first; - if (numElements > 0) - { - /*AZSTD_STL::*/ - memcpy(&*result, &*first, numElements * sizeof(typename iterator_traits::value_type)); - } - return result + numElements; - } + size_t numElements = last - first; + if (numElements > 0) + { +#if az_has_builtin_memcpy + static_assert(sizeof(iter_value_t) == sizeof(iter_value_t), "Value type sizes must match for a trivial copy"); + __builtin_memcpy(to_address(result), to_address(first), numElements * sizeof(iter_value_t)); +#else + if (az_builtin_is_constant_evaluated()) + { + for (; first != last; ++result, ++first) + { + construct_at(static_cast*>(to_address(result)), ::AZStd::move(*first)); + } + return result; + } + else + { + static_assert(sizeof(iter_value_t) == sizeof(iter_value_t), "Value type sizes must match for a trivial copy"); + ::memcpy(to_address(result), to_address(first), numElements * sizeof(iter_value_t)); + } +#endif + } + return result + numElements; + } + else + { + for (; first != last; ++result, ++first) + { + construct_at(static_cast*>(to_address(result)), ::AZStd::move(*first)); + } + + return result; + } + } // end of sequence move. ////////////////////////////////////////////////////////////////////////// } @@ -492,19 +551,19 @@ namespace AZStd template ForwardIt uninitialized_move(InputIt first, InputIt last, ForwardIt result) { - return AZStd::Internal::uninitialized_move(first, last, result, AZStd::Internal::is_fast_copy{}); + return AZStd::Internal::uninitialized_move(first, last, result, {}); } // 25.3.2 Move template OutputIterator move(InputIterator first, InputIterator last, OutputIterator result) { - return AZStd::Internal::move(first, last, result, AZStd::Internal::is_fast_copy()); + return AZStd::Internal::move(first, last, result, {}); } template BidirectionalIterator2 move_backward(BidirectionalIterator1 first, BidirectionalIterator1 last, BidirectionalIterator2 result) { - return AZStd::Internal::move_backward(first, last, result, AZStd::Internal::is_fast_copy()); + return AZStd::Internal::move_backward(first, last, result, {}); } } @@ -516,63 +575,77 @@ namespace AZStd::Internal * Helper class to determine if we have apply fast fill. There are 3 conditions * - trivial assign * - size of type == 1 (chars) to use memset - * - contiguous iterators (pointers) + * - contiguous iterators */ + template + constexpr bool indirectly_copy_assignable = false; + template + constexpr bool indirectly_copy_assignable>> = + is_trivially_copy_assignable_v> && sizeof(iter_value_t) == 1; + template - struct is_fast_fill_helper - { - using value_type = typename iterator_traits::value_type; - constexpr static bool value = is_trivially_copy_assignable_v && sizeof(value_type) == 1 - && Internal::satisfies_contiguous_iterator_concept_v; - }; - - // Use this trait to to determine fill mode, based on the iterator, value size, etc. - // Use it when you call uninitialized_fill, uninitialized_fill_n, fill and fill_n. - template< typename Iterator > - struct is_fast_fill - : public ::AZStd::integral_constant::value> - {}; + using is_fast_fill = bool_constant && contiguous_iterator>; + template + constexpr bool is_fast_fill_v = is_fast_fill::value; + // The fast fill trait is no longer used + // It is detected using C++20 concepts now template - constexpr void fill(const ForwardIterator& first, const ForwardIterator& last, const T& value, const false_type& /* is_fast_fill() */) + constexpr void fill(ForwardIterator first, ForwardIterator last, const T& value, bool) { - ForwardIterator iter(first); - for (; iter != last; ++iter) + if constexpr (is_fast_fill_v) { - *iter = value; + size_t numElements = last - first; + if (numElements > 0) + { + if (az_builtin_is_constant_evaluated()) + { + for (; first != last; ++first) + { + *first = value; + } + } + else + { + ::memset(to_address(first), reinterpret_cast(value), numElements); + } + } } - } - // Specialized version for character types where memset can be used - // This overload cannot be constexpr until builtin_memset is added to MSVC compilers - template - inline void fill(const ForwardIterator& first, const ForwardIterator& last, const T& value, const true_type& /* is_fast_fill() */) - { - AZStd::size_t numElements = last - first; - if (numElements > 0) + else { - /*AZSTD_STL::*/ - memset((void*)&*first, *reinterpret_cast(&value), numElements); + for (; first != last; ++first) + { + *first = value; + } } } template - constexpr void fill_n(ForwardIterator first, Size numElements, const T& value, const false_type& /* is_fast_fill() */) + constexpr void fill_n(ForwardIterator first, Size numElements, const T& value, bool) { - for (; numElements--; ++first) + if constexpr (is_fast_fill_v) { - *first = value; + if (numElements) + { + if (az_builtin_is_constant_evaluated()) + { + for (; numElements--; ++first) + { + *first = value; + } + } + else + { + ::memset(to_address(first), reinterpret_cast(value), numElements); + } + } } - } - - // Specialized version for character types where memset can be used to perform the fill - // This overload cannot be constexpr until builtin_memset is added to MSVC compilers - template - inline void fill_n(ForwardIterator first, Size numElements, const T& value, const true_type& /* is_fast_fill() */) - { - if (numElements > 0) + else { - /*AZSTD_STL::*/ - memset(&*first, *reinterpret_cast(&value), numElements); + for (; numElements--; ++first) + { + *first = value; + } } } } @@ -580,78 +653,85 @@ namespace AZStd::Internal namespace AZStd { template - constexpr void fill(const ForwardIterator& first, const ForwardIterator& last, const T& value) + constexpr void fill(ForwardIterator first, ForwardIterator last, const T& value) { - Internal::fill(first, last, value, Internal::is_fast_fill()); + Internal::fill(first, last, value, {}); } - template constexpr void fill_n(ForwardIterator first, Size numElements, const T& value) { - Internal::fill_n(first, numElements, value, Internal::is_fast_fill()); + Internal::fill_n(first, numElements, value, {}); } template - constexpr void uninitialized_fill(const ForwardIterator& first, const ForwardIterator& last, const T& value, const false_type& /* is_fast_fill() */) + constexpr void uninitialized_fill(ForwardIterator first, ForwardIterator last, const T& value, bool) { - ForwardIterator iter(first); - for (; iter != last; ++iter) + if constexpr (Internal::is_fast_fill_v) { - ::new (static_cast(&*iter)) typename iterator_traits::value_type(value); + size_t numElements = last - first; + if (numElements > 0) + { + if (az_builtin_is_constant_evaluated()) + { + for (; first != last; ++first) + { + construct_at(static_cast*>(to_address(first)), value); + } + } + else + { + ::memset(to_address(first), reinterpret_cast(value), numElements); + } + } } - } - - // Specialized overload for types which meet the following criteria. - // 1. Has it's iterator_traits::iterator_concept type set to to contiguous_iterator_tag - // 2. Is trivially assignable - // 3. Has a sizeof(T) == 1 - // In such a case memset can be used to fill in the data - // This overload cannot be constexpr until builtin_memset is added to MSVC compilers - template - inline void uninitialized_fill(const ForwardIterator& first, const ForwardIterator& last, const T& value, const true_type& /* is_fast_fill() */) - { - AZStd::size_t numElements = last - first; - if (numElements > 0) + else { - /*AZSTD_STL::*/ - memset(&*first, *reinterpret_cast(&value), numElements); + for (; first != last; ++first) + { + construct_at(static_cast*>(to_address(first)), value); + } } } template constexpr void uninitialized_fill(ForwardIterator first, Size numElements, const T& value) { - return uninitialized_fill(first, numElements, value, Internal::is_fast_fill()); + return uninitialized_fill(first, numElements, value, {}); } template - constexpr void uninitialized_fill_n(ForwardIterator first, Size numElements, const T& value, const false_type& /* is_fast_fill() */) + constexpr void uninitialized_fill_n(ForwardIterator first, Size numElements, const T& value, bool) { - for (; numElements--; ++first) + if constexpr (Internal::is_fast_fill_v) { - ::new (static_cast(&*first)) typename iterator_traits::value_type(value); + if (numElements > 0) + { + if (az_builtin_is_constant_evaluated()) + { + for (; numElements--; ++first) + { + construct_at(static_cast*>(to_address(first)), value); + } + } + else + { + ::memset(to_address(first), reinterpret_cast(value), numElements); + } + } } - } - - // Specialized overload for types which meet the following criteria. - // 1. Has it's iterator_traits::iterator_concept type set to to contiguous_iterator_tag - // 2. Is trivially assignable - // 3. Has a sizeof(T) == 1 - // In such a case memset can be used to fill in the data - template - inline void uninitialized_fill_n(ForwardIterator first, Size numElements, const T& value, const true_type& /* is_fast_fill() */) - { - if (numElements) + else { - /*AZSTD_STL::*/ - memset(&*first, *reinterpret_cast(&value), numElements); + for (; numElements--; ++first) + { + construct_at(static_cast*>(to_address(first)), value); + } } } template constexpr void uninitialized_fill_n(ForwardIterator first, Size numElements, const T& value) { - return uninitialized_fill_n(first, numElements, value, Internal::is_fast_fill()); + return uninitialized_fill_n(first, numElements, value, {}); } } diff --git a/Code/Framework/AzCore/AzCore/std/function/invoke.h b/Code/Framework/AzCore/AzCore/std/function/invoke.h index 88dbbea218..6dccb43e36 100644 --- a/Code/Framework/AzCore/AzCore/std/function/invoke.h +++ b/Code/Framework/AzCore/AzCore/std/function/invoke.h @@ -38,4 +38,12 @@ namespace AZStd { return Internal::INVOKE(Internal::InvokeTraits::forward(f), Internal::InvokeTraits::forward(args)...); } + + // models the invocable concept + template + /*concept*/ constexpr bool invocable = is_invocable_v; + + // models the regular_invocable concept + template + /*concept*/ constexpr bool regular_invocable = invocable; } diff --git a/Code/Framework/AzCore/AzCore/std/iterator.h b/Code/Framework/AzCore/AzCore/std/iterator.h index 8d0d49b649..5bc653e3b6 100644 --- a/Code/Framework/AzCore/AzCore/std/iterator.h +++ b/Code/Framework/AzCore/AzCore/std/iterator.h @@ -8,19 +8,19 @@ #pragma once #include -#include -#include -#include -#include // use by ConstIteratorCast +#include +#include +#include #include -#include +#include +#include #include namespace AZStd { - // Everything unless specified is based on C++ standard 24 (lib.iterators). + // Everything unless specified is based on C++ standard 20 (lib.iterators). /// Identifying tag for input iterators. using input_iterator_tag = std::input_iterator_tag; @@ -51,16 +51,6 @@ namespace AZStd::Internal typename Iterator::reference> > = true; - - template - inline constexpr bool has_iterator_category_v = false; - template - inline constexpr bool has_iterator_category_v> = true; - template - inline constexpr bool has_iterator_concept_v = false; - template - inline constexpr bool has_iterator_concept_v> = true; - // Iterator iterator_category alias must be one of the iterator category tags template struct iterator_traits_category_tags @@ -98,6 +88,8 @@ namespace AZStd struct iterator_traits : Internal::iterator_traits_type_aliases> { + // Internal type alias meant to indicate that this is the primary template + using _is_primary_template = iterator_traits; }; /** @@ -114,45 +106,6 @@ namespace AZStd using iterator_category = random_access_iterator_tag; using iterator_concept = contiguous_iterator_tag; }; - -} - -namespace AZStd::Internal -{ - // iterator_category tag testers - template >> - inline constexpr bool has_iterator_category_convertible_to_v = false; - template - inline constexpr bool has_iterator_category_convertible_to_v = is_convertible_v::iterator_category, Category>; - - template - inline constexpr bool is_input_iterator_v = has_iterator_category_convertible_to_v; - - template - inline constexpr bool is_forward_iterator_v = has_iterator_category_convertible_to_v; - - template - inline constexpr bool is_bidirectional_iterator_v = has_iterator_category_convertible_to_v; - - template - inline constexpr bool is_random_access_iterator_v = has_iterator_category_convertible_to_v; - - template - inline constexpr bool is_contiguous_iterator_v = has_iterator_category_convertible_to_v; - - template - inline constexpr bool is_exactly_input_iterator_v = has_iterator_category_convertible_to_v && !has_iterator_category_convertible_to_v; - - // iterator concept testers - template - inline constexpr bool derived_from = is_base_of_v && is_convertible_v; - - template >> - inline constexpr bool satisfies_iterator_concept = false; - template - inline constexpr bool satisfies_iterator_concept = derived_from::iterator_concept, Concept>; - template - inline constexpr bool satisfies_contiguous_iterator_concept_v = satisfies_iterator_concept; } namespace AZStd diff --git a/Code/Framework/AzCore/AzCore/std/iterator/iterator_primitives.h b/Code/Framework/AzCore/AzCore/std/iterator/iterator_primitives.h new file mode 100644 index 0000000000..39d89e1f2f --- /dev/null +++ b/Code/Framework/AzCore/AzCore/std/iterator/iterator_primitives.h @@ -0,0 +1,200 @@ +/* + * 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +namespace AZStd +{ + // Bring in std utility functions into AZStd namespace + using std::forward; + + // forward declare iterator_traits to avoid iterator.h include + template + struct iterator_traits; +} + +// C++20 range traits for iteratable types +namespace AZStd::Internal +{ + // Models the can-reference concept which isn't available until C++20 + // template + template + constexpr bool can_reference = true; + template <> + inline constexpr bool can_reference = false; + + // Models the dereferencable concept which isn't available until C++20 + template + /*concept*/ constexpr bool dereferenceable = false; + template + constexpr bool dereferenceable())>>> = true; + + template + constexpr bool is_primary_template_v = false; + template + constexpr bool is_primary_template_v>> = true; + + // indirectly readable traits + template + constexpr bool has_value_type_v = false; + template + constexpr bool has_value_type_v> = true; + template + constexpr bool has_element_type_v = false; + template + constexpr bool has_element_type_v> = true; + + template + struct object_type_value_requires {}; + template + struct object_type_value_requires>> + { + using value_type = remove_cv_t; + }; + template + struct indirectly_readable_requires {}; + template + struct indirectly_readable_requires> + && is_void_v::value_type>> >> + { + // iterator_traits has been been specialized + using value_type = typename iterator_traits::value_type; + }; + + template + struct indirectly_readable_requires> + && is_array_v>> + { + using value_type = remove_cv_t>; + }; + + template + struct indirectly_readable_requires> + && has_value_type_v && !has_element_type_v>> + : object_type_value_requires {}; + + template + struct indirectly_readable_requires> + && has_element_type_v && !has_value_type_v>> + : object_type_value_requires {}; + + template + struct indirectly_readable_requires> + && has_value_type_v&& has_element_type_v + && same_as, remove_cv_t> >> + : object_type_value_requires {}; + + // incrementable traits + template + constexpr bool has_difference_type_v = false; + template + constexpr bool has_difference_type_v> = true; + + template + struct object_type_difference_requires {}; + template + struct object_type_difference_requires>> + { + using difference_type = ptrdiff_t; + }; + + template + struct incrementable_requires {}; + // iterator_traits has been specialized + template + struct incrementable_requires> + && is_void_v::difference_type>> >> + { + using difference_type = typename iterator_traits::difference_type; + }; + template + struct incrementable_requires> + && has_difference_type_v>> + { + using difference_type = typename T::difference_type; + }; + template + struct incrementable_requires> + && !has_difference_type_v + && integral() - declval())> >> + { + using difference_type = make_signed_t() - declval())>; + }; +} + +namespace AZStd +{ + // indirectly_readable_traits for iter_value_t + template + struct indirectly_readable_traits + : Internal::indirectly_readable_requires {}; + template + struct indirectly_readable_traits + : Internal::object_type_value_requires {}; + template + struct indirectly_readable_traits + : indirectly_readable_traits {}; + + template + using iter_value_t = typename indirectly_readable_traits>::value_type; + + template + using iter_reference_t = enable_if_t, decltype(*declval())>; + + // incrementable_traits for iter_difference_t + template + struct incrementable_traits + : Internal::incrementable_requires {}; + template + struct incrementable_traits + : Internal::object_type_difference_requires {}; + template + struct incrementable_traits + : incrementable_traits {}; + + template + using iter_difference_t = typename incrementable_traits>::difference_type; + + template + using iter_rvalue_reference_t = decltype(ranges::iter_move(declval())); + + namespace Internal + { + // model the indirectly readable concept + template + constexpr bool indirectly_readable_impl = false; + + template + constexpr bool indirectly_readable_impl()), iter_reference_t> + && same_as())), iter_rvalue_reference_t> + && common_reference_with&&, iter_value_t&> + && common_reference_with&&, iter_rvalue_reference_t&> + && common_reference_with&&, const iter_value_t&>>> = true; + } + + template + using iter_common_reference_t = enable_if_t, + common_reference_t, iter_value_t&>>; +} diff --git a/Code/Framework/AzCore/AzCore/std/ranges/iter_move.h b/Code/Framework/AzCore/AzCore/std/ranges/iter_move.h new file mode 100644 index 0000000000..a9519f03c5 --- /dev/null +++ b/Code/Framework/AzCore/AzCore/std/ranges/iter_move.h @@ -0,0 +1,81 @@ +/* + * 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 +#include +#include +#include +#include +#include +#include + + +namespace AZStd +{ + // Bring in std utility functions into AZStd namespace + using std::forward; +} + +// C++20 range traits for iteratable types +namespace AZStd::ranges::Internal +{ + void iter_move(); + + template + constexpr bool iter_move_adl = false; + + template + constexpr bool iter_move_adl()))>> = true; + + template + constexpr bool is_class_or_enum_with_iter_move_adl = false; + + template + constexpr bool is_class_or_enum_with_iter_move_adl + && (is_class_v> || is_enum_v>)>> + = true; + + struct iter_move_fn + { + template + constexpr auto operator()(It&& it) const + ->enable_if_t, + decltype(iter_move(AZStd::forward(it)))> + { + return iter_move(AZStd::forward(it)); + } + template + constexpr auto operator()(It&& it) const + ->enable_if_t&& is_lvalue_reference_v(it))>, + decltype(AZStd::move(*AZStd::forward(it)))> + { + return AZStd::move(*AZStd::forward(it)); + } + template + constexpr auto operator()(It&& it) const + ->enable_if_t && !is_lvalue_reference_v(it))>, + decltype(*AZStd::forward(it))> + { + return *AZStd::forward(it); + } + }; +} + +namespace AZStd::ranges +{ + inline namespace customization_point_object + { + inline constexpr auto iter_move = Internal::iter_move_fn{}; + } +} diff --git a/Code/Framework/AzCore/AzCore/std/ranges/ranges.h b/Code/Framework/AzCore/AzCore/std/ranges/ranges.h new file mode 100644 index 0000000000..a3ead81456 --- /dev/null +++ b/Code/Framework/AzCore/AzCore/std/ranges/ranges.h @@ -0,0 +1,1157 @@ +/* + * 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 +#include +#include +#include +#include +#include + +namespace AZStd +{ + // alias std:: reverse_iterator names into AZStd:: + using std::make_reverse_iterator; +} + +namespace AZStd::ranges +{ + // Range variable templates + template + inline constexpr bool enable_borrowed_range = false; + + template + inline constexpr bool disable_sized_range = false; + + namespace Internal + { + // Variadic template which maps types to true For SFINAE + template + constexpr bool sfinae_trigger_v = true; + + template + constexpr bool is_lvalue_or_borrowable = is_lvalue_reference_v || enable_borrowed_range>; + + //! begin + template + constexpr bool has_member_begin = false; + template + constexpr bool has_member_begin().begin())>> = true; + + template + constexpr bool has_unqualified_begin = false; + template + constexpr bool has_unqualified_begin()))>> + = !has_member_begin && AZStd::Internal::is_class_or_enum; + + template + void begin(T&) = delete; + template + void begin(const T&) = delete; + + struct begin_fn + { + template + constexpr auto operator()(T& t) const noexcept -> + enable_if_t && sfinae_trigger_v>, + decltype(t + 0)> + { + return t + 0; + } + + template + constexpr auto operator()(T&& t) const noexcept(noexcept(AZStd::forward(t).begin())) -> + enable_if_t&& is_lvalue_or_borrowable + && !is_array_v&& has_member_begin, + decltype(AZStd::forward(t).begin())> + { + return AZStd::forward(t).begin(); + } + + template + constexpr auto operator()(T&& t) const noexcept(noexcept(begin(AZStd::forward(t)))) -> + enable_if_t&& is_lvalue_or_borrowable + && !is_array_v && has_unqualified_begin, + decltype(begin(AZStd::forward(t)))> + { + return begin(AZStd::forward(t)); + } + }; + } + inline namespace customization_point_object + { + inline constexpr Internal::begin_fn begin{}; + } + + template + using iterator_t = decltype(ranges::begin(declval())); + + namespace Internal + { + template + constexpr bool has_iterator_t = has_member_begin; + + //! end + template + constexpr bool has_member_end = false; + template + constexpr bool has_member_end().end())>> = true; + + template + constexpr bool has_unqualified_end = false; + template + constexpr bool has_unqualified_end()))>> + = !has_member_end && AZStd::Internal::is_class_or_enum; + + template + void end(T&) = delete; + template + void end(const T&) = delete; + + struct end_fn + { + template + constexpr auto operator()(T& t) const noexcept -> + enable_if_t && extent_v != 0, + decltype(t + extent_v)> + { + return t + extent_v; + } + + template + constexpr auto operator()(T&& t) const noexcept(noexcept(AZStd::forward(t).end())) -> + enable_if_t>&& is_lvalue_or_borrowable + && !is_array_v && has_member_end, + decltype(AZStd::forward(t).end())> + { + return AZStd::forward(t).end(); + } + + template + constexpr auto operator()(T&& t) const noexcept(noexcept(end(AZStd::forward(t)))) -> + enable_if_t>&& is_lvalue_or_borrowable + && !is_array_v && has_unqualified_end, + decltype(end(AZStd::forward(t)))> + { + return end(AZStd::forward(t)); + } + }; + } + inline namespace customization_point_object + { + inline constexpr Internal::end_fn end{}; + } + + namespace Internal + { + //! cbegin + struct cbegin_fn + { + template + constexpr auto operator()(T&& t) const noexcept(noexcept(ranges::begin(static_cast(t)))) + ->enable_if_t, decltype(ranges::begin(static_cast(t)))> + { + return ranges::begin(static_cast(t)); + } + + template + constexpr auto operator()(T&& t) const noexcept(noexcept(ranges::begin(static_cast(t)))) -> + enable_if_t, decltype(ranges::begin(static_cast(t)))> + { + return ranges::begin(static_cast(t)); + } + }; + } + inline namespace customization_point_object + { + inline constexpr Internal::cbegin_fn cbegin{}; + } + + namespace Internal + { + //! cend + struct cend_fn + { + template + constexpr auto operator()(T&& t) const noexcept(noexcept(ranges::end(static_cast(t)))) + ->enable_if_t, decltype(ranges::end(static_cast(t)))> + { + return ranges::end(static_cast(t)); + } + + template + constexpr auto operator()(T&& t) const noexcept(noexcept(ranges::end(static_cast(t)))) -> + enable_if_t, decltype(ranges::end(static_cast(t)))> + { + return ranges::end(static_cast(t)); + } + }; + } + inline namespace customization_point_object + { + inline constexpr Internal::cend_fn cend{}; + } + + namespace Internal + { + //! rbegin + template + constexpr bool has_member_rbegin = false; + template + constexpr bool has_member_rbegin().rbegin())>> = true; + + template + constexpr bool has_unqualified_rbegin = false; + template + constexpr bool has_unqualified_rbegin()))>> + = !has_member_rbegin && AZStd::Internal::is_class_or_enum; + + template + constexpr bool has_bidirectional_rbegin = false; + template + constexpr bool has_bidirectional_rbegin())), decltype(ranges::end(declval()))> + && bidirectional_iterator()))> + && bidirectional_iterator()))> + >> = !has_member_rbegin && !has_unqualified_rbegin; + + + template + void rbegin(T&) = delete; + template + void rbegin(const T&) = delete; + + struct rbegin_fn + { + template + constexpr auto operator()(T&& t) const noexcept(noexcept(AZStd::forward(t).rbegin())) -> + enable_if_t && is_lvalue_or_borrowable + && has_member_rbegin, + decltype(AZStd::forward(t).rbegin())> + { + return AZStd::forward(t).rbegin(); + } + + template + constexpr auto operator()(T&& t) const noexcept(noexcept(rbegin(AZStd::forward(t)))) -> + enable_if_t && is_lvalue_or_borrowable + && has_unqualified_rbegin, + decltype(rbegin(AZStd::forward(t)))> + { + return rbegin(AZStd::forward(t)); + } + + template + constexpr auto operator()(T&& t) const noexcept(noexcept(AZStd::make_reverse_iterator(ranges::end(AZStd::forward(t))))) -> + enable_if_t, + decltype(AZStd::make_reverse_iterator(ranges::end(AZStd::forward(t))))> + { + return AZStd::make_reverse_iterator(ranges::end(AZStd::forward(t))); + } + }; + } + + inline namespace customization_point_object + { + inline constexpr Internal::rbegin_fn rbegin{}; + } + + namespace Internal + { + //! rend + template + constexpr bool has_member_rend = false; + template + constexpr bool has_member_rend().rend())>> = true; + + template + constexpr bool has_unqualified_rend = false; + template + constexpr bool has_unqualified_rend()))>> + = !has_member_rend && AZStd::Internal::is_class_or_enum; + + template + constexpr bool has_bidirectional_rend = false; + template + constexpr bool has_bidirectional_rend())), decltype(ranges::end(declval()))> + && bidirectional_iterator()))> + && bidirectional_iterator()))> + >> = !has_member_rend && !has_unqualified_rend; + + template + void rend(T&) = delete; + template + void rend(const T&) = delete; + + struct rend_fn + { + template + constexpr auto operator()(T&& t) const noexcept(noexcept(AZStd::forward(t).rend())) -> + enable_if_t && is_lvalue_or_borrowable + && has_member_rend, + decltype(AZStd::forward(t).rend())> + { + return AZStd::forward(t).rend(); + } + + template + constexpr auto operator()(T&& t) const noexcept(noexcept(rend(AZStd::forward(t)))) -> + enable_if_t && is_lvalue_or_borrowable + && has_unqualified_rend, + decltype(rend(AZStd::forward(t)))> + { + return rend(AZStd::forward(t)); + } + + template + constexpr auto operator()(T&& t) const noexcept(noexcept(AZStd::make_reverse_iterator(ranges::begin(AZStd::forward(t))))) -> + enable_if_t, + decltype(AZStd::make_reverse_iterator(ranges::begin(AZStd::forward(t))))> + { + return AZStd::make_reverse_iterator(ranges::begin(AZStd::forward(t))); + } + }; + } + + inline namespace customization_point_object + { + inline constexpr Internal::rend_fn rend{}; + } + + namespace Internal + { + //! crbegin + struct crbegin_fn + { + template + constexpr auto operator()(T&& t) const noexcept(noexcept(ranges::rbegin(static_cast(t)))) + ->enable_if_t, decltype(ranges::rbegin(static_cast(t)))> + { + return ranges::rbegin(static_cast(t)); + } + + template + constexpr auto operator()(T&& t) const noexcept(noexcept(ranges::rbegin(static_cast(t)))) -> + enable_if_t, decltype(ranges::rbegin(static_cast(t)))> + { + return ranges::rbegin(static_cast(t)); + } + }; + } + inline namespace customization_point_object + { + inline constexpr Internal::crbegin_fn crbegin{}; + } + + namespace Internal + { + //! crend + struct crend_fn + { + template + constexpr auto operator()(T&& t) const noexcept(noexcept(ranges::rend(static_cast(t)))) + ->enable_if_t, decltype(ranges::rend(static_cast(t)))> + { + return ranges::rend(static_cast(t)); + } + + template + constexpr auto operator()(T&& t) const noexcept(noexcept(ranges::rend(static_cast(t)))) -> + enable_if_t, decltype(ranges::rend(static_cast(t)))> + { + return ranges::rend(static_cast(t)); + } + }; + } + inline namespace customization_point_object + { + inline constexpr Internal::crend_fn crend{}; + } + + namespace Internal + { + //! size + template + constexpr bool has_member_size = false; + template + constexpr bool has_member_size().size())>> = true; + + template + constexpr bool has_unqualified_size = false; + template + constexpr bool has_unqualified_size()))>> + = !has_member_size && AZStd::Internal::is_class_or_enum; + + template + constexpr bool has_end_subtract_begin = false; + template + constexpr bool has_end_subtract_begin()) - ranges::begin(declval()))>> + = !has_member_size && !has_unqualified_size; + + template + void size(T&) = delete; + template + void size(const T&) = delete; + + struct size_fn + { + template + constexpr auto operator()(T&) const noexcept -> + enable_if_t && extent_v != 0, + decltype(extent_v)> + { + return extent_v; + } + + template + constexpr auto operator()(T&& t) const noexcept(noexcept(AZStd::forward(t).size())) -> + enable_if_t> && has_member_size + && AZStd::Internal::is_integer_like(t).size())>, + decltype(AZStd::forward(t).size())> + { + return AZStd::forward(t).size(); + } + + template + constexpr auto operator()(T&& t) const noexcept(noexcept(size(AZStd::forward(t)))) -> + enable_if_t> + && has_unqualified_size + && AZStd::Internal::is_integer_like(t)))>, + decltype(size(AZStd::forward(t)))> + { + return size(AZStd::forward(t)); + } + + template + constexpr auto operator()(T&& t) const noexcept(noexcept(ranges::end(AZStd::forward(t)) - ranges::begin(AZStd::forward(t)))) -> + enable_if_t< + has_end_subtract_begin + && sized_sentinel_for(t))), decltype(ranges::begin(AZStd::forward(t)))> + && forward_iterator(t)))>, + AZStd::make_unsigned_t(t)) - ranges::begin(AZStd::forward(t)))>> + { + using size_type = AZStd::make_unsigned_t(t)) - ranges::begin(AZStd::forward(t)))>; + return static_cast(ranges::end(AZStd::forward(t)) - ranges::begin(AZStd::forward(t))); + } + }; + } + inline namespace customization_point_object + { + inline constexpr Internal::size_fn size{}; + } + + namespace Internal + { + //! ssize + struct ssize_fn + { + template + constexpr auto operator()(T&& t) const noexcept(noexcept(ranges::size(t))) -> + enable_if_t<(sizeof(ptrdiff_t) > sizeof(make_signed_t)), ptrdiff_t> + { + return static_cast(ranges::size(t)); + } + + template + constexpr auto operator()(T&& t) const noexcept(noexcept(ranges::size(t))) -> + enable_if_t), make_signed_t> + { + using ssize_type = make_signed_t; + return static_cast(ranges::size(t)); + } + }; + } + inline namespace customization_point_object + { + inline constexpr Internal::ssize_fn ssize{}; + } + + namespace Internal + { + //! empty + template + constexpr bool has_member_empty = false; + template + constexpr bool has_member_empty().empty()), bool>>> = true; + + template + constexpr bool has_size_compare_to_0 = false; + template + constexpr bool has_size_compare_to_0()) == 0), bool> >> + = !has_member_empty; + + template + constexpr bool has_begin_compare_to_end = false; + + template + constexpr bool has_begin_compare_to_end()) == ranges::end(declval())), bool> >> + = !has_member_empty && !has_size_compare_to_0; + + struct empty_fn + { + template + [[nodiscard]] constexpr auto operator()(T&& t) const noexcept(noexcept(AZStd::forward(t).empty())) -> + enable_if_t && has_member_empty, bool> + { + return AZStd::forward(t).empty(); + } + + template + [[nodiscard]] constexpr auto operator()(T&& t) const noexcept(noexcept(ranges::size(AZStd::forward(t)) == 0)) -> + enable_if_t && has_size_compare_to_0, bool> + { + return ranges::size(AZStd::forward(t)) == 0; + } + + template + [[nodiscard]] constexpr auto operator()(T&& t) const noexcept(noexcept(ranges::begin(AZStd::forward(t)) == ranges::end(AZStd::forward(t)))) -> + enable_if_t && has_begin_compare_to_end, bool> + { + return ranges::begin(AZStd::forward(t)) == ranges::end(AZStd::forward(t)); + } + }; + } + inline namespace customization_point_object + { + inline constexpr Internal::empty_fn empty{}; + } + + namespace Internal + { + //! data + template + constexpr bool has_member_data = false; + template + constexpr bool has_member_data().data())>> = true; + + template + constexpr bool has_qualified_ranges_begin = false; + template + constexpr bool has_qualified_ranges_begin()))>> > + = !has_member_data; + + struct data_fn + { + template + constexpr auto operator()(T&& t) const noexcept(noexcept(AZStd::forward(t).data())) -> + enable_if_t && has_member_data, + decltype(AZStd::forward(t).data())> + { + return AZStd::forward(t).data(); + } + + template + constexpr auto operator()(T&& t) const noexcept(noexcept(AZStd::to_address(ranges::begin(AZStd::forward(t))))) -> + enable_if_t && has_qualified_ranges_begin, + decltype(AZStd::to_address(ranges::begin(AZStd::forward(t))))> + { + return AZStd::to_address(ranges::begin(AZStd::forward(t))); + } + }; + } + inline namespace customization_point_object + { + inline constexpr Internal::data_fn data{}; + } + + namespace Internal + { + //! cdata + struct cdata_fn + { + template + constexpr auto operator()(T&& t) const noexcept(noexcept(ranges::data(static_cast(t)))) -> + enable_if_t, decltype(ranges::data(static_cast(t)))> + { + return ranges::data(static_cast(t)); + } + + template + constexpr auto operator()(T&& t) const noexcept(noexcept(ranges::data(static_cast(t)))) -> + enable_if_t, decltype(ranges::data(static_cast(t)))> + { + return ranges::data(static_cast(t)); + } + }; + } + inline namespace customization_point_object + { + inline constexpr Internal::cdata_fn cdata{}; + } +} + +namespace AZStd::ranges +{ + namespace Internal + { + template + constexpr bool range_impl = false; + template + constexpr bool range_impl())), decltype(ranges::end(declval()))>> = true; + } + + // Models range concept + template + /*concept*/ constexpr bool range = Internal::range_impl; + + // sentinal type can now be defined after the range concept has been modeled + template + using sentinel_t = enable_if_t, decltype(ranges::end(declval()))>; + + // Models borrowed range concept + template + /*concept*/ constexpr bool borrowed_range = range + && (is_lvalue_reference_v || enable_borrowed_range>); + + struct dangling + { + constexpr dangling() = default; + template + constexpr dangling(T&&...) noexcept {} + }; + + template + using borrowed_iterator_t = conditional_t, iterator_t, dangling>; + + // Models sized range concept + namespace Internal + { + template + constexpr bool sized_range_impl = false; + template + constexpr bool sized_range_impl + && sfinae_trigger_v()))> >> = true; + } + + template + /*concept*/ constexpr bool sized_range = Internal::sized_range_impl; + + namespace Internal + { + template + constexpr bool output_range_impl = false; + template + constexpr bool output_range_impl>> = range && output_iterator, T>; + } + + template + /*concept*/ constexpr bool output_range = Internal::output_range_impl; + + namespace Internal + { + template + constexpr bool input_range_impl = false; + template + constexpr bool input_range_impl>> = range && input_iterator>; + } + + template + /*concept*/ constexpr bool input_range = Internal::input_range_impl; + + namespace Internal + { + template + constexpr bool forward_range_impl = false; + template + constexpr bool forward_range_impl>> = input_range && forward_iterator>; + } + + template + /*concept*/ constexpr bool forward_range = Internal::forward_range_impl; + + namespace Internal + { + template + constexpr bool bidirectional_range_impl = false; + template + constexpr bool bidirectional_range_impl>> = forward_range && bidirectional_iterator>; + } + + template + /*concept*/ constexpr bool bidirectional_range = Internal::bidirectional_range_impl; + + namespace Internal + { + template + constexpr bool random_access_range_impl = false; + template + constexpr bool random_access_range_impl>> = bidirectional_range && random_access_iterator>; + } + + template + /*concept*/ constexpr bool random_access_range = Internal::random_access_range_impl; + + template + using range_size_t = enable_if_t, decltype(ranges::size(declval()))>; + template + using range_difference_t = enable_if_t, iter_difference_t>>; + template + using range_value_t = enable_if_t, iter_value_t>>; + template + using range_reference_t = enable_if_t, iter_reference_t>>; + template + using range_rvalue_reference_t = enable_if_t, iter_rvalue_reference_t>>; + + + namespace Internal + { + template + constexpr bool contiguous_range_impl = false; + template + constexpr bool contiguous_range_impl + && contiguous_iterator> + && same_as())), add_pointer_t>> >> = true; + } + + template + /*concept*/ constexpr bool contiguous_range = Internal::contiguous_range_impl; + + template + /*concept*/ constexpr bool common_range = range && same_as, sentinel_t>; +} + +namespace AZStd::ranges +{ + // iterator operations + // ranges::advance + namespace Internal + { + struct advance_fn + { + template + constexpr auto operator()(I& i, iter_difference_t n) const -> + enable_if_t> + { + if constexpr (random_access_iterator) + { + i += n; + } + else + { + for (; n > 0; ++i, --n) {} + + // The Precondition is that if I is not a bidirectional iterator, n must be positive + if constexpr (bidirectional_iterator) + { + for (; n < 0; --i, ++n) {} + } + } + } + + template + constexpr auto operator()(I& i, S bound) const -> + enable_if_t&& sentinel_for> + { + if constexpr (assignable_from) + { + i = AZStd::move(bound); + } + else if constexpr (sized_sentinel_for) + { + operator()(i, bound - i); + } + else + { + for (; i != bound; ++i) {} + } + } + + template + constexpr auto operator()(I& i, iter_difference_t n, S bound) const -> + enable_if_t&& sentinel_for, iter_difference_t> + { + if constexpr (sized_sentinel_for) + { + if (const auto dist = bound - i; + (n > 0 && n > dist) || (n < 0 && n < dist)) + { + // advance is limited to the i reach bound + operator()(i, bound); + return n - dist; + } + else if (n != 0) + { + // advance is limited by the value of n + operator()(i, n); + return 0; + } + + return 0; + } + else + { + for (; i != bound && n > 0; ++i, --n) {} + if constexpr (bidirectional_iterator && same_as) + { + for (; i != bound && n < 0; --i, ++n) {} + } + + return n; + } + } + }; + } + + inline namespace customization_point_object + { + inline constexpr Internal::advance_fn advance{}; + } + + // ranges::distance + namespace Internal + { + struct distance_fn + { + template + constexpr auto operator()(I first, S last) const -> + enable_if_t && sentinel_for && !sized_sentinel_for, + iter_difference_t> + { + // Since S is not a sized sentinel, can only increment from first to last + iter_difference_t result{}; + for (; first != last; ++first, ++result) {} + + return result; + } + + template + constexpr auto operator()(const I& first, const S& last) const -> + enable_if_t && sentinel_for && sized_sentinel_for, + iter_difference_t> + { + return last - first; + } + + template + constexpr auto operator()(R&& r) const -> + enable_if_t, range_difference_t> + { + if constexpr (sized_range) + { + return ranges::size(r); + } + else + { + operator()(ranges::begin(r), ranges::end(r)); + } + } + }; + } + + inline namespace customization_point_object + { + inline constexpr Internal::distance_fn distance{}; + } + + // ranges::next + namespace Internal + { + struct next_fn + { + template + constexpr auto operator()(I x) const -> + enable_if_t, I> + { + ++x; + return x; + } + + template + constexpr auto operator()(I x, iter_difference_t n) const -> + enable_if_t, I> + { + ranges::advance(x, n); + return x; + } + + template + constexpr auto operator()(I x, S bound) const -> + enable_if_t&& sentinel_for, I> + { + ranges::advance(x, bound); + return x; + } + + template + constexpr auto operator()(I x, iter_difference_t n, S bound) const -> + enable_if_t&& sentinel_for, I> + { + ranges::advance(x, n, bound); + return x; + } + }; + } + + inline namespace customization_point_object + { + inline constexpr Internal::next_fn next{}; + } + + //ranges::prev + namespace Internal + { + struct prev_fn + { + template + constexpr auto operator()(I x) const -> + enable_if_t, I> + { + --x; + return x; + } + + template + constexpr auto operator()(I x, iter_difference_t n) const -> + enable_if_t, I> + { + ranges::advance(x, -n); + return x; + } + + template + constexpr auto operator()(I x, iter_difference_t n, S bound) const -> + enable_if_t&& sentinel_for, I> + { + ranges::advance(x, -n, bound); + return x; + } + }; + } + + inline namespace customization_point_object + { + inline constexpr Internal::prev_fn prev{}; + } +} + +namespace AZStd::ranges +{ + namespace Internal + { + template + constexpr bool is_initializer_list = false; + template + constexpr bool is_initializer_list> = true; + } + + //! views + // view interface can be used with non-constant class types + template + class view_interface; + template + class view_interface< D, enable_if_t && same_as> >> + { + private: + constexpr D& derived() noexcept + { + return static_cast(*this); + } + constexpr const D& derived() const noexcept + { + return static_cast(*this); + } + + public: + template + constexpr auto empty() -> enable_if_t, bool> + { + return ranges::begin(derived()) == ranges::end(derived()); + } + template + constexpr auto empty() const -> enable_if_t, bool> + { + return ranges::begin(derived()) == ranges::end(derived()); + } + + template ()))>> + constexpr explicit operator bool() const noexcept(noexcept(ranges::empty(derived()))) + { + return !ranges::empty(derived()); + } + + template + constexpr auto data() -> + enable_if_t>, decltype(to_address(ranges::begin(derived())))> + { + return to_address(ranges::begin(derived())); + } + template + constexpr auto data() const -> + enable_if_t>, decltype(to_address(ranges::begin(derived())))> + { + return to_address(ranges::begin(derived())); + } + + template + constexpr auto size() -> + enable_if_t && sized_sentinel_for, iterator_t>, + decltype(ranges::end(derived()) - ranges::begin(derived()))> + { + return ranges::end(derived()) - ranges::begin(derived()); + } + template + constexpr auto size() const -> + enable_if_t&& sized_sentinel_for, iterator_t>, + decltype(ranges::end(derived()) - ranges::begin(derived()))> + { + return ranges::end(derived()) - ranges::begin(derived()); + } + + template + constexpr auto front() -> + enable_if_t, decltype(*ranges::begin(derived()))> + { + return *ranges::begin(derived()); + } + template + constexpr auto front() const -> + enable_if_t, decltype(*ranges::begin(derived()))> + { + return *ranges::begin(derived()); + } + + template + constexpr auto back() -> + enable_if_t && common_range, decltype(*ranges::prev(ranges::end(derived())))> + { + return *ranges::prev(ranges::end(derived())); + } + + template + constexpr auto back() const -> + enable_if_t&& common_range, decltype(*ranges::prev(ranges::end(derived())))> + { + return *ranges::prev(ranges::end(derived())); + } + + template + constexpr auto operator[](range_difference_t n) -> + enable_if_t, decltype(ranges::begin(derived())[n])> + { + return ranges::begin(derived())[n]; + } + template + constexpr auto operator[](range_difference_t n) const -> + enable_if_t, decltype(ranges::begin(derived())[n])> + { + return ranges::begin(derived())[n]; + } + }; + + struct view_base {}; + namespace Internal + { + template + void derived_from_view_interface_template(view_interface&); + template + inline constexpr bool is_derived_from_view_interface = false; + template + inline constexpr bool is_derived_from_view_interface()))> = true; + } + template + inline constexpr bool enable_view = derived_from || Internal::is_derived_from_view_interface; + + template + /*concept*/ constexpr bool view = range && movable && enable_view; + + template + /*concept*/ constexpr bool viewable_range = range && + ((view> && constructible_from, T>) || + (!view> && + (is_lvalue_reference_v || (movable> && !Internal::is_initializer_list)))); +} + + +namespace AZStd::ranges +{ +#if __has_cpp_attribute(no_unique_address) +#define az_no_unique_address [[no_unique_address]] +#else +#define az_no_unique_address +#endif + template + struct in_in_result + { + az_no_unique_address I1 in1; + az_no_unique_address I2 in2; + + template&& convertible_to> > + constexpr operator in_in_result() const& + { + return { in1, in2 }; + } + + template&& convertible_to> > + constexpr operator in_in_result()&& + { + return { AZStd::move(in1), AZStd::move(in2) }; + } + }; + +#undef az_no_unique_address + + template + using swap_ranges_result = in_in_result; + + namespace Internal + { + struct swap_ranges_fn + { + template + constexpr auto operator()(I1 first1, S1 last1, I2 first2, S2 last2) const -> + enable_if_t&& sentinel_for + && input_iterator&& sentinel_for + && indirectly_swappable, + swap_ranges_result> + { + for (; !(first1 == last1 or first2 == last2); ++first1, ++first2) + { + ranges::iter_swap(first1, first2); + } + return { AZStd::move(first1), AZStd::move(first2) }; + } + + template + constexpr auto operator()(R1&& r1, R2&& r2) const -> + enable_if_t&& input_range + && indirectly_swappable, iterator_t>, + swap_ranges_result, borrowed_iterator_t>> + { + return operator()(ranges::begin(r1), ranges::end(r1), + ranges::begin(r2), ranges::end(r2)); + } + }; + } + inline namespace customization_point_object + { + constexpr Internal::swap_ranges_fn swap_ranges{}; + } +} + +namespace AZStd::ranges::Internal +{ + // Implementation of ranges::swap customization point overload which calls ranges::swap_ranges + // Must be done after the ranges::swap_ranges function has been declared + // ranges::swap customization point https://eel.is/c++draft/concepts#concept.swappable-2.2 + template + constexpr auto swap_fn::operator()(T&& t, U&& u) const noexcept(noexcept((*this)(*t, *u))) + ->enable_if_t + && is_array_v && is_array_v && (extent_v == extent_v) + > + { + ranges::swap_ranges(t, u); + } +} diff --git a/Code/Framework/AzCore/AzCore/std/string/fixed_string.h b/Code/Framework/AzCore/AzCore/std/string/fixed_string.h index ea841bc4ca..bbaab391b4 100644 --- a/Code/Framework/AzCore/AzCore/std/string/fixed_string.h +++ b/Code/Framework/AzCore/AzCore/std/string/fixed_string.h @@ -74,7 +74,7 @@ namespace AZStd constexpr basic_fixed_string(const_pointer ptr); // #6 - template && !is_convertible_v>> + template && !is_convertible_v>> constexpr basic_fixed_string(InputIt first, InputIt last); // #7 @@ -146,7 +146,7 @@ namespace AZStd constexpr auto append(size_type count, Element ch) -> basic_fixed_string&; template constexpr auto append(InputIt first, InputIt last) - -> enable_if_t && !is_convertible_v, basic_fixed_string&>; + -> enable_if_t && !is_convertible_v, basic_fixed_string&>; constexpr auto append(AZStd::initializer_list ilist) -> basic_fixed_string&; constexpr auto assign(const basic_fixed_string& rhs) -> basic_fixed_string&; @@ -161,7 +161,7 @@ namespace AZStd constexpr auto assign(size_type count, Element ch) -> basic_fixed_string&; template constexpr auto assign(InputIt first, InputIt last) - ->enable_if_t && !is_convertible_v, basic_fixed_string&>; + ->enable_if_t && !is_convertible_v, basic_fixed_string&>; constexpr auto assign(AZStd::initializer_list ilist) -> basic_fixed_string&; @@ -179,7 +179,7 @@ namespace AZStd constexpr auto insert(const_iterator insertPos, size_type count, Element ch) -> iterator; template constexpr auto insert(const_iterator insertPos, InputIt first, InputIt last) - -> enable_if_t && !is_convertible_v, iterator>; + -> enable_if_t && !is_convertible_v, iterator>; constexpr auto insert(const_iterator insertPos, AZStd::initializer_list ilist) -> iterator; @@ -215,7 +215,7 @@ namespace AZStd constexpr auto replace(const_iterator first, const_iterator last, size_type count, Element ch) -> basic_fixed_string&; template constexpr auto replace(const_iterator first, const_iterator last, InputIt first2, InputIt last2) - -> enable_if_t && !is_convertible_v, basic_fixed_string&>; + -> enable_if_t && !is_convertible_v, basic_fixed_string&>; constexpr auto replace(const_iterator first, const_iterator last, AZStd::initializer_list ilist) -> basic_fixed_string&; constexpr auto at(size_type offset) -> reference; diff --git a/Code/Framework/AzCore/AzCore/std/string/fixed_string.inl b/Code/Framework/AzCore/AzCore/std/string/fixed_string.inl index caa047f3c8..65fc1d88be 100644 --- a/Code/Framework/AzCore/AzCore/std/string/fixed_string.inl +++ b/Code/Framework/AzCore/AzCore/std/string/fixed_string.inl @@ -325,14 +325,14 @@ namespace AZStd template template inline constexpr auto basic_fixed_string::append(InputIt first, InputIt last) - -> enable_if_t && !is_convertible_v, basic_fixed_string&> + -> enable_if_t && !is_convertible_v, basic_fixed_string&> { - if constexpr (Internal::satisfies_contiguous_iterator_concept_v + if constexpr (contiguous_iterator && is_same_v::value_type, value_type>) { return append(AZStd::to_address(first), AZStd::distance(first, last)); } - else if constexpr (Internal::is_forward_iterator_v) + else if constexpr (forward_iterator) { // Input Iterator pointer type doesn't match the const_pointer type // So the elements need to be appended one by one into the buffer @@ -461,14 +461,14 @@ namespace AZStd template template inline constexpr auto basic_fixed_string::assign(InputIt first, InputIt last) - -> enable_if_t && !is_convertible_v, basic_fixed_string&> + -> enable_if_t && !is_convertible_v, basic_fixed_string&> { - if constexpr (Internal::satisfies_contiguous_iterator_concept_v + if constexpr (contiguous_iterator && is_same_v::value_type, value_type>) { return assign(AZStd::to_address(first), AZStd::distance(first, last)); } - else if constexpr (Internal::is_forward_iterator_v) + else if constexpr (forward_iterator) { // Input Iterator pointer type doesn't match the const_pointer type // So the elements need to be assigned one by one into the buffer @@ -627,15 +627,15 @@ namespace AZStd template template inline constexpr auto basic_fixed_string::insert(const_iterator insertPos, - InputIt first, InputIt last)-> enable_if_t && !is_convertible_v, iterator> + InputIt first, InputIt last)-> enable_if_t && !is_convertible_v, iterator> { // insert [_First, _Last) at _Where size_type insertOffset = AZStd::distance(cbegin(), insertPos); - if constexpr (Internal::satisfies_contiguous_iterator_concept_v + if constexpr (contiguous_iterator && is_same_v::value_type, value_type>) { insert(insertOffset, AZStd::to_address(first), AZStd::distance(first, last)); } - else if constexpr (Internal::is_forward_iterator_v) + else if constexpr (forward_iterator) { // Input Iterator pointer type doesn't match the const_pointer type // So the elements need to be inserted one by one into the buffer @@ -927,14 +927,14 @@ namespace AZStd template template inline constexpr auto basic_fixed_string::replace(const_iterator first, const_iterator last, - InputIt replaceFirst, InputIt replaceLast) -> enable_if_t && !is_convertible_v, basic_fixed_string&> + InputIt replaceFirst, InputIt replaceLast) -> enable_if_t && !is_convertible_v, basic_fixed_string&> { // replace [first, last) with [replaceFirst,replaceLast) - if constexpr (Internal::satisfies_contiguous_iterator_concept_v + if constexpr (contiguous_iterator && is_same_v::value_type, value_type>) { return replace(first, last, AZStd::to_address(replaceFirst), AZStd::distance(replaceFirst, replaceLast)); } - else if constexpr (Internal::is_forward_iterator_v) + else if constexpr (forward_iterator) { // Input Iterator pointer type doesn't match the const_pointer type // So the elements need to be appended one by one into the buffer diff --git a/Code/Framework/AzCore/AzCore/std/string/string.h b/Code/Framework/AzCore/AzCore/std/string/string.h index c65d699d15..c2f4a6953e 100644 --- a/Code/Framework/AzCore/AzCore/std/string/string.h +++ b/Code/Framework/AzCore/AzCore/std/string/string.h @@ -114,28 +114,23 @@ namespace AZStd assign(count, ch); } - template && !is_convertible_v>> + template && !is_convertible_v>> inline basic_string(InputIt first, InputIt last, const Allocator& alloc = Allocator()) : m_storage{ skip_element_tag{}, alloc } { // construct from [first, last) assign(first, last); } - inline basic_string(const_pointer first, const_pointer last) - { // construct from [first, last), const pointers - assign(first, last - first); - } - inline basic_string(const this_type& rhs) : m_storage{ skip_element_tag{}, rhs.m_storage.second() } { - assign(rhs, 0, npos); + assign(rhs); } inline basic_string(this_type&& rhs) - : m_storage{ skip_element_tag{}, AZStd::move(rhs.m_storage.second()) } + : m_storage{ skip_element_tag{}, rhs.m_storage.second() } { - assign(AZStd::forward(rhs)); + assign(AZStd::move(rhs)); } inline basic_string(const this_type& rhs, size_type rhsOffset, size_type count = npos) @@ -251,14 +246,14 @@ namespace AZStd template inline auto append(InputIt first, InputIt last) - -> enable_if_t && !is_convertible_v, this_type&> + -> enable_if_t && !is_convertible_v, this_type&> { // append [first, last) - if constexpr (Internal::satisfies_contiguous_iterator_concept_v + if constexpr (contiguous_iterator && is_same_v::value_type, value_type>) { return append(AZStd::to_address(first), AZStd::distance(first, last)); } - else if constexpr (Internal::is_forward_iterator_v) + else if constexpr (forward_iterator) { // Input Iterator pointer type doesn't match the const_pointer type // So the elements need to be appended one by one into the buffer @@ -299,7 +294,7 @@ namespace AZStd inline this_type& assign(const this_type& rhs) { - return assign(rhs, 0, npos); + return this != &rhs ? assign(rhs, 0, npos) : *this; } inline this_type& assign(basic_string_view view) @@ -319,7 +314,8 @@ namespace AZStd pointer rhsData = rhs.data(); // Memmove the right hand side string data if it is using the short string optimization // Otherwise set the pointer to the right hand side - if (rhs.m_storage.first().ShortStringOptimizationActive()) + if (rhs.m_storage.first().ShortStringOptimizationActive() || + (get_allocator() != rhs.get_allocator() && !allocator_traits::propagate_on_container_move_assignment::value)) { Traits::move(data, rhsData, rhs.size() + 1); // string + null-terminator } @@ -395,14 +391,14 @@ namespace AZStd template auto assign(InputIt first, InputIt last) - -> enable_if_t && !is_convertible_v, this_type&> + -> enable_if_t && !is_convertible_v, this_type&> { - if constexpr (Internal::satisfies_contiguous_iterator_concept_v + if constexpr (contiguous_iterator && is_same_v::value_type, value_type>) { return assign(AZStd::to_address(first), AZStd::distance(first, last)); } - else if constexpr (Internal::is_forward_iterator_v) + else if constexpr (forward_iterator) { // forward iterator pointer type doesn't match the const_pointer type // So the elements need to be assigned one by one into the buffer @@ -431,7 +427,7 @@ namespace AZStd inputCopy.push_back(static_cast(*first)); } - return assign(inputCopy.c_str(), inputCopy.size()); + return assign(AZStd::move(inputCopy)); } } inline this_type& insert(size_type offset, const this_type& rhs) { return insert(offset, rhs, 0, npos); } @@ -539,15 +535,15 @@ namespace AZStd template auto insert(const_iterator insertPos, InputIt first, InputIt last) - -> enable_if_t && !is_convertible_v, iterator> + -> enable_if_t && !is_convertible_v, iterator> { // insert [_First, _Last) at _Where size_type insertOffset = AZStd::distance(cbegin(), insertPos); - if constexpr (Internal::satisfies_contiguous_iterator_concept_v + if constexpr (contiguous_iterator && is_same_v::value_type, value_type>) { insert(insertOffset, AZStd::to_address(first), AZStd::distance(first, last)); } - else if constexpr (Internal::is_forward_iterator_v) + else if constexpr (forward_iterator) { // Input Iterator pointer type doesn't match the const_pointer type // So the elements need to be inserted one by one into the buffer @@ -834,14 +830,14 @@ namespace AZStd template inline auto replace(const_iterator first, const_iterator last, InputIt replaceFirst, InputIt replaceLast) - -> enable_if_t && !is_convertible_v, this_type&> + -> enable_if_t && !is_convertible_v, this_type&> { - if constexpr (Internal::satisfies_contiguous_iterator_concept_v + if constexpr (contiguous_iterator && is_same_v::value_type, value_type>) { return replace(first, last, AZStd::to_address(replaceFirst), AZStd::distance(replaceFirst, replaceLast)); } - else if constexpr (Internal::is_forward_iterator_v) + else if constexpr (forward_iterator) { // Input Iterator pointer type doesn't match the const_pointer type // So the elements need to be appended one by one into the buffer @@ -1031,12 +1027,19 @@ namespace AZStd // same allocator, swap storage m_storage.first().swap(rhs.m_storage.first()); } + else if (allocator_traits::propagate_on_container_swap::value) + { + // The allocator propagates on swap, so the allocators can be swapped + m_storage.first().swap(rhs.m_storage.first()); + using AZStd::swap; + swap(m_storage.second(), rhs.m_storage.second()); + } else { // different allocator, do multiple assigns - this_type tmp = *this; - *this = rhs; - rhs = tmp; + this_type tmp = AZStd::move(*this); + *this = AZStd::move(rhs); + rhs = AZStd::move(tmp); } } diff --git a/Code/Framework/AzCore/AzCore/std/string/string_view.h b/Code/Framework/AzCore/AzCore/std/string/string_view.h index 1579e43f4d..c333e2cea1 100644 --- a/Code/Framework/AzCore/AzCore/std/string/string_view.h +++ b/Code/Framework/AzCore/AzCore/std/string/string_view.h @@ -7,6 +7,7 @@ */ #pragma once +#include #include #include #include @@ -613,8 +614,9 @@ namespace AZStd {} template - && is_same_v::value_type, value_type> + contiguous_iterator + && sized_sentinel_for + && is_same_v, value_type> && !is_convertible_v> > constexpr basic_string_view(It first, End last) @@ -961,23 +963,6 @@ namespace AZStd using string_view = basic_string_view; using wstring_view = basic_string_view; - template> - using basic_const_string = basic_string_view; - using const_string = string_view; - using const_wstring = wstring_view; - - template > - constexpr typename basic_string_view::const_iterator begin(basic_string_view sv) - { - return sv.begin(); - } - - template > - constexpr typename basic_string_view::const_iterator end(basic_string_view sv) - { - return sv.end(); - } - inline namespace literals { inline namespace string_view_literals @@ -1024,6 +1009,15 @@ namespace AZStd } // namespace AZStd +namespace AZStd::ranges +{ + template + inline constexpr bool enable_borrowed_range> = true; + + template + inline constexpr bool enable_view> = true; +} + //! Use this macro to simplify safe printing of a string_view which may not be null-terminated. //! Example: AZStd::string::format("Safely formatted: %.*s", AZ_STRING_ARG(myString)); #define AZ_STRING_ARG(str) aznumeric_cast(str.size()), str.data() diff --git a/Code/Framework/AzCore/AzCore/std/typetraits/common_reference.h b/Code/Framework/AzCore/AzCore/std/typetraits/common_reference.h new file mode 100644 index 0000000000..51fd9c1dda --- /dev/null +++ b/Code/Framework/AzCore/AzCore/std/typetraits/common_reference.h @@ -0,0 +1,230 @@ +/* + * 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace AZStd +{ + template class TQual, template class UQual> + struct basic_common_reference + {}; +} + +namespace AZStd::Internal +{ + // const volatile and reference qualifier copy templates + template + struct copy_cv_qual + { + using type = conditional_t, conditional_t, const volatile QualType, const QualType>, + conditional_t, volatile QualType, QualType>>; + }; + + template + using copy_cv_qual_t = typename copy_cv_qual::type; + + static_assert(is_same_v, float>); + static_assert(is_same_v, const float>); + static_assert(is_same_v, volatile float>); + static_assert(is_same_v, const volatile float>); + static_assert(is_same_v, const float>); + static_assert(is_same_v, const float>); + static_assert(is_same_v, const volatile float>); + static_assert(is_same_v, const volatile float>); + static_assert(is_same_v, volatile float>); + static_assert(is_same_v, const volatile float>); + static_assert(is_same_v, volatile float>); + static_assert(is_same_v, const volatile float>); + static_assert(is_same_v, const volatile float>); + static_assert(is_same_v, const volatile float>); + static_assert(is_same_v, const volatile float>); + static_assert(is_same_v, const volatile float>); + + template + struct copy_reference_qual + { + using type = conditional_t, QualType&, + conditional_t, QualType&&, QualType>>; + }; + + template + using copy_reference_qual_t = typename copy_reference_qual::type; + + static_assert(is_same_v, float>); + static_assert(is_same_v, float&>); + static_assert(is_same_v, float&&>); + static_assert(is_same_v, float&>); + static_assert(is_same_v, float&>); + static_assert(is_same_v, float&>); + static_assert(is_same_v, float&&>); + static_assert(is_same_v, float&>); + static_assert(is_same_v, float&&>); + + template + using copy_cvref_qual_t = copy_cv_qual_t, QualType>; + + template + struct copy_qualifiers_from_t + { + template + using templ = copy_cvref_qual_t; + }; + + template + using cond_res = decltype(false ? declval, remove_reference_t>&>() + : declval, remove_reference_t>&>()); + + // common reference helper templates begin + template + struct common_reference_base_reference_test; + + // COMMON_REF is defined within the C++ standard at https://eel.is/c++draft/meta.trans.other#3.5 + template + struct common_reference_base_reference_test&& is_lvalue_reference_v, + void_t> >> + { + // Uses the ternary operator for determining the common type + using type = cond_res; + }; + + template + struct common_reference_base_reference_test&& is_rvalue_reference_v>> + { + using C = remove_reference_t&, remove_reference_t&>::type>; + using type = AZStd::enable_if_t&& is_convertible_v, C>; + }; + + template + struct common_reference_base_reference_test&& is_lvalue_reference_v>> + { + // Turn rvalue references to const lvalue references + using D = typename common_reference_base_reference_test&, remove_reference_t&>::type; + using type = AZStd::enable_if_t, D>; + }; + + template + struct common_reference_base_reference_test&& is_rvalue_reference_v>> + { + // Swap the parameters to call the 3rd specialization for common_reference_base_reference_test + using type = typename common_reference_base_reference_test::type; + }; + + template + constexpr bool has_reference_test = false; + + template + constexpr bool has_reference_test::type>> = true; + + template + struct basic_common_reference_test; + + template + struct basic_common_reference_test, remove_cvref_t, + copy_qualifiers_from_t::template templ, copy_qualifiers_from_t::template templ>::type>> + { + using type = typename basic_common_reference, remove_cvref_t, + copy_qualifiers_from_t::template templ, copy_qualifiers_from_t::template templ>::type; + }; + + template + constexpr bool has_basic_common_reference_test = false; + + template + constexpr bool has_basic_common_reference_test::type>> = true; + + template + constexpr bool has_condition_result_test = false; + + template + constexpr bool has_condition_result_test() : declval())>> = true; + + template + struct common_reference_base_test + {}; + + template + struct common_reference_base_test>> + : common_reference_base_reference_test + {}; + template + struct common_reference_base_test + && has_basic_common_reference_test>> + : basic_common_reference_test + {}; + template + struct common_reference_base_test + && !has_basic_common_reference_test && has_condition_result_test>> + { + using type = decltype(false ? declval() : declval()); + }; + template + struct common_reference_base_test + && !has_basic_common_reference_test && !has_condition_result_test>> + : common_type + {}; + + template + struct common_reference_base + {}; + + template + struct common_reference_base + { + using type = T; + }; + template + struct common_reference_base + : common_reference_base_test + {}; + + template + struct common_reference_base + : common_reference_base::type, V, Rs...> + {}; +} +namespace AZStd +{ + template + struct common_reference + : Internal::common_reference_base + {}; + + template + using common_reference_t = typename common_reference::type; + + // models the common reference concept + namespace Internal + { + template + constexpr bool common_reference_with_impl = false; + template + constexpr bool common_reference_with_impl, common_reference_t> + && convertible_to> + && convertible_to> + >> = true; + } + + template + /*concept*/ constexpr bool common_reference_with = Internal::common_reference_with_impl; +} diff --git a/Code/Framework/AzCore/AzCore/std/typetraits/is_convertible.h b/Code/Framework/AzCore/AzCore/std/typetraits/is_convertible.h index 65f3b9908c..1f2933cecf 100644 --- a/Code/Framework/AzCore/AzCore/std/typetraits/is_convertible.h +++ b/Code/Framework/AzCore/AzCore/std/typetraits/is_convertible.h @@ -8,12 +8,26 @@ #pragma once +#include #include +#include +#include namespace AZStd { using std::is_convertible; + using std::is_convertible_v; + + // models the C++20 convertible_to concept + namespace Internal + { + template + constexpr bool convertible_to_impl = false; + template + constexpr bool convertible_to_impl, void_t(declval()))>>> = true; + } template - constexpr bool is_convertible_v = std::is_convertible_v; + /*concept*/ constexpr bool convertible_to = Internal::convertible_to_impl; } diff --git a/Code/Framework/AzCore/AzCore/std/typetraits/is_destructible.h b/Code/Framework/AzCore/AzCore/std/typetraits/is_destructible.h index ac03f01d3b..39d79781f4 100644 --- a/Code/Framework/AzCore/AzCore/std/typetraits/is_destructible.h +++ b/Code/Framework/AzCore/AzCore/std/typetraits/is_destructible.h @@ -21,4 +21,7 @@ namespace AZStd constexpr bool is_trivially_destructible_v = std::is_trivially_destructible::value; template constexpr bool is_nothrow_destructible_v = std::is_nothrow_destructible::value; + + template + /*concept*/ constexpr bool destructible = is_nothrow_destructible_v; } diff --git a/Code/Framework/AzCore/AzCore/std/typetraits/is_floating_point.h b/Code/Framework/AzCore/AzCore/std/typetraits/is_floating_point.h index 7408866ed7..b973ac714c 100644 --- a/Code/Framework/AzCore/AzCore/std/typetraits/is_floating_point.h +++ b/Code/Framework/AzCore/AzCore/std/typetraits/is_floating_point.h @@ -13,4 +13,7 @@ namespace AZStd { using std::is_floating_point; using std::is_floating_point_v; + + template + /*concept*/ constexpr bool floating_point = is_floating_point_v; } diff --git a/Code/Framework/AzCore/AzCore/std/typetraits/is_integral.h b/Code/Framework/AzCore/AzCore/std/typetraits/is_integral.h index a51e06dc06..eb699aa6d1 100644 --- a/Code/Framework/AzCore/AzCore/std/typetraits/is_integral.h +++ b/Code/Framework/AzCore/AzCore/std/typetraits/is_integral.h @@ -13,4 +13,7 @@ namespace AZStd { using std::is_integral; using std::is_integral_v; + + template + /*concept*/ constexpr bool integral = is_integral_v; } diff --git a/Code/Framework/AzCore/AzCore/std/typetraits/is_same.h b/Code/Framework/AzCore/AzCore/std/typetraits/is_same.h index 858e9b1f52..61037d7549 100644 --- a/Code/Framework/AzCore/AzCore/std/typetraits/is_same.h +++ b/Code/Framework/AzCore/AzCore/std/typetraits/is_same.h @@ -13,4 +13,8 @@ namespace AZStd { using std::is_same; using std::is_same_v; + + // models the same_as concept + template + /*concept*/ constexpr bool same_as = is_same_v; } diff --git a/Code/Framework/AzCore/AzCore/std/typetraits/typetraits.h b/Code/Framework/AzCore/AzCore/std/typetraits/typetraits.h index d29b0c28ee..bf45d15836 100644 --- a/Code/Framework/AzCore/AzCore/std/typetraits/typetraits.h +++ b/Code/Framework/AzCore/AzCore/std/typetraits/typetraits.h @@ -27,6 +27,8 @@ #include #include #include +#include +#include #include #include #include diff --git a/Code/Framework/AzCore/Platform/AppleTV/AzCore/IO/Streamer/StreamerContext_Platform.h b/Code/Framework/AzCore/AzCore/std/utility/declval.h similarity index 76% rename from Code/Framework/AzCore/Platform/AppleTV/AzCore/IO/Streamer/StreamerContext_Platform.h rename to Code/Framework/AzCore/AzCore/std/utility/declval.h index 51d3f54553..c017bb142a 100644 --- a/Code/Framework/AzCore/Platform/AppleTV/AzCore/IO/Streamer/StreamerContext_Platform.h +++ b/Code/Framework/AzCore/AzCore/std/utility/declval.h @@ -7,4 +7,9 @@ */ #pragma once -#include <../Common/Default/AzCore/IO/Streamer/StreamerContext_Default.h> +#include + +namespace AZStd +{ + using std::declval; +} diff --git a/Code/Framework/AzCore/AzCore/std/utility/move.h b/Code/Framework/AzCore/AzCore/std/utility/move.h new file mode 100644 index 0000000000..71f2a49b18 --- /dev/null +++ b/Code/Framework/AzCore/AzCore/std/utility/move.h @@ -0,0 +1,19 @@ +/* + * 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 + +namespace AZStd +{ + // rvalue + // rvalue move + template + constexpr AZStd::remove_reference_t&& move(T&& t) + { + return static_cast&&>(t); + } +} diff --git a/Code/Framework/AzCore/AzCore/std/utils.h b/Code/Framework/AzCore/AzCore/std/utils.h index 4c918250de..d3ead8022b 100644 --- a/Code/Framework/AzCore/AzCore/std/utils.h +++ b/Code/Framework/AzCore/AzCore/std/utils.h @@ -22,22 +22,15 @@ #include #include #include +#include +#include #include namespace AZStd { ////////////////////////////////////////////////////////////////////////// - // rvalue - // rvalue move - template - constexpr AZStd::remove_reference_t&& move(T && t) - { - return static_cast&&>(t); - } - using std::forward; - using std::declval; using std::exchange; template diff --git a/Code/Framework/AzCore/AzCore/Android/APKFileHandler.cpp b/Code/Framework/AzCore/Platform/Android/AzCore/Android/APKFileHandler.cpp similarity index 100% rename from Code/Framework/AzCore/AzCore/Android/APKFileHandler.cpp rename to Code/Framework/AzCore/Platform/Android/AzCore/Android/APKFileHandler.cpp diff --git a/Code/Framework/AzCore/AzCore/Android/APKFileHandler.h b/Code/Framework/AzCore/Platform/Android/AzCore/Android/APKFileHandler.h similarity index 100% rename from Code/Framework/AzCore/AzCore/Android/APKFileHandler.h rename to Code/Framework/AzCore/Platform/Android/AzCore/Android/APKFileHandler.h diff --git a/Code/Framework/AzCore/AzCore/Android/AndroidEnv.cpp b/Code/Framework/AzCore/Platform/Android/AzCore/Android/AndroidEnv.cpp similarity index 100% rename from Code/Framework/AzCore/AzCore/Android/AndroidEnv.cpp rename to Code/Framework/AzCore/Platform/Android/AzCore/Android/AndroidEnv.cpp diff --git a/Code/Framework/AzCore/AzCore/Android/AndroidEnv.h b/Code/Framework/AzCore/Platform/Android/AzCore/Android/AndroidEnv.h similarity index 99% rename from Code/Framework/AzCore/AzCore/Android/AndroidEnv.h rename to Code/Framework/AzCore/Platform/Android/AzCore/Android/AndroidEnv.h index 153a6450e1..d00774b88c 100644 --- a/Code/Framework/AzCore/AzCore/Android/AndroidEnv.h +++ b/Code/Framework/AzCore/Platform/Android/AzCore/Android/AndroidEnv.h @@ -116,7 +116,7 @@ namespace AZ const char* GetObbStoragePath() const { return m_obbStoragePath.c_str(); } //! Get the dot separated package name for the current application. - //! e.g. com.lumberyard.samples for SamplesProject + //! e.g. org.o3de.samples for SamplesProject const char* GetPackageName() const { return m_packageName.c_str(); } //! Get the app version code (android:versionCode in the manifest). diff --git a/Code/Framework/AzCore/AzCore/Android/ApiLevel.h b/Code/Framework/AzCore/Platform/Android/AzCore/Android/ApiLevel.h similarity index 100% rename from Code/Framework/AzCore/AzCore/Android/ApiLevel.h rename to Code/Framework/AzCore/Platform/Android/AzCore/Android/ApiLevel.h diff --git a/Code/Framework/AzCore/AzCore/Android/JNI/Internal/ClassName.h b/Code/Framework/AzCore/Platform/Android/AzCore/Android/JNI/Internal/ClassName.h similarity index 100% rename from Code/Framework/AzCore/AzCore/Android/JNI/Internal/ClassName.h rename to Code/Framework/AzCore/Platform/Android/AzCore/Android/JNI/Internal/ClassName.h diff --git a/Code/Framework/AzCore/AzCore/Android/JNI/Internal/JStringUtils.h b/Code/Framework/AzCore/Platform/Android/AzCore/Android/JNI/Internal/JStringUtils.h similarity index 100% rename from Code/Framework/AzCore/AzCore/Android/JNI/Internal/JStringUtils.h rename to Code/Framework/AzCore/Platform/Android/AzCore/Android/JNI/Internal/JStringUtils.h diff --git a/Code/Framework/AzCore/AzCore/Android/JNI/Internal/JStringUtils_impl.h b/Code/Framework/AzCore/Platform/Android/AzCore/Android/JNI/Internal/JStringUtils_impl.h similarity index 100% rename from Code/Framework/AzCore/AzCore/Android/JNI/Internal/JStringUtils_impl.h rename to Code/Framework/AzCore/Platform/Android/AzCore/Android/JNI/Internal/JStringUtils_impl.h diff --git a/Code/Framework/AzCore/AzCore/Android/JNI/Internal/Object_impl.h b/Code/Framework/AzCore/Platform/Android/AzCore/Android/JNI/Internal/Object_impl.h similarity index 100% rename from Code/Framework/AzCore/AzCore/Android/JNI/Internal/Object_impl.h rename to Code/Framework/AzCore/Platform/Android/AzCore/Android/JNI/Internal/Object_impl.h diff --git a/Code/Framework/AzCore/AzCore/Android/JNI/Internal/Signature_impl.h b/Code/Framework/AzCore/Platform/Android/AzCore/Android/JNI/Internal/Signature_impl.h similarity index 100% rename from Code/Framework/AzCore/AzCore/Android/JNI/Internal/Signature_impl.h rename to Code/Framework/AzCore/Platform/Android/AzCore/Android/JNI/Internal/Signature_impl.h diff --git a/Code/Framework/AzCore/AzCore/Android/JNI/JNI.cpp b/Code/Framework/AzCore/Platform/Android/AzCore/Android/JNI/JNI.cpp similarity index 100% rename from Code/Framework/AzCore/AzCore/Android/JNI/JNI.cpp rename to Code/Framework/AzCore/Platform/Android/AzCore/Android/JNI/JNI.cpp diff --git a/Code/Framework/AzCore/AzCore/Android/JNI/JNI.h b/Code/Framework/AzCore/Platform/Android/AzCore/Android/JNI/JNI.h similarity index 100% rename from Code/Framework/AzCore/AzCore/Android/JNI/JNI.h rename to Code/Framework/AzCore/Platform/Android/AzCore/Android/JNI/JNI.h diff --git a/Code/Framework/AzCore/AzCore/Android/JNI/Object.h b/Code/Framework/AzCore/Platform/Android/AzCore/Android/JNI/Object.h similarity index 100% rename from Code/Framework/AzCore/AzCore/Android/JNI/Object.h rename to Code/Framework/AzCore/Platform/Android/AzCore/Android/JNI/Object.h diff --git a/Code/Framework/AzCore/AzCore/Android/JNI/Object_fwd.h b/Code/Framework/AzCore/Platform/Android/AzCore/Android/JNI/Object_fwd.h similarity index 100% rename from Code/Framework/AzCore/AzCore/Android/JNI/Object_fwd.h rename to Code/Framework/AzCore/Platform/Android/AzCore/Android/JNI/Object_fwd.h diff --git a/Code/Framework/AzCore/AzCore/Android/JNI/Signature.h b/Code/Framework/AzCore/Platform/Android/AzCore/Android/JNI/Signature.h similarity index 100% rename from Code/Framework/AzCore/AzCore/Android/JNI/Signature.h rename to Code/Framework/AzCore/Platform/Android/AzCore/Android/JNI/Signature.h diff --git a/Code/Framework/AzCore/AzCore/Android/JNI/scoped_ref.h b/Code/Framework/AzCore/Platform/Android/AzCore/Android/JNI/scoped_ref.h similarity index 100% rename from Code/Framework/AzCore/AzCore/Android/JNI/scoped_ref.h rename to Code/Framework/AzCore/Platform/Android/AzCore/Android/JNI/scoped_ref.h diff --git a/Code/Framework/AzCore/AzCore/Android/JNI/shared_ref.h b/Code/Framework/AzCore/Platform/Android/AzCore/Android/JNI/shared_ref.h similarity index 100% rename from Code/Framework/AzCore/AzCore/Android/JNI/shared_ref.h rename to Code/Framework/AzCore/Platform/Android/AzCore/Android/JNI/shared_ref.h diff --git a/Code/Framework/AzCore/AzCore/Android/Utils.cpp b/Code/Framework/AzCore/Platform/Android/AzCore/Android/Utils.cpp similarity index 100% rename from Code/Framework/AzCore/AzCore/Android/Utils.cpp rename to Code/Framework/AzCore/Platform/Android/AzCore/Android/Utils.cpp diff --git a/Code/Framework/AzCore/AzCore/Android/Utils.h b/Code/Framework/AzCore/Platform/Android/AzCore/Android/Utils.h similarity index 98% rename from Code/Framework/AzCore/AzCore/Android/Utils.h rename to Code/Framework/AzCore/Platform/Android/AzCore/Android/Utils.h index 08a21e0010..51936e51b6 100644 --- a/Code/Framework/AzCore/AzCore/Android/Utils.h +++ b/Code/Framework/AzCore/Platform/Android/AzCore/Android/Utils.h @@ -52,7 +52,7 @@ namespace AZ const char* GetObbStoragePath(); //! Get the dot separated package name for the current application. - //! e.g. com.o3de.samples for SamplesProject + //! e.g. org.o3de.samples for SamplesProject const char* GetPackageName(); //! Get the app version code (android:versionCode in the manifest). diff --git a/Code/Framework/AzCore/Platform/Android/AzCore/AzCore_Traits_Android.h b/Code/Framework/AzCore/Platform/Android/AzCore/AzCore_Traits_Android.h index e99f29e051..86e89b4a95 100644 --- a/Code/Framework/AzCore/Platform/Android/AzCore/AzCore_Traits_Android.h +++ b/Code/Framework/AzCore/Platform/Android/AzCore/AzCore_Traits_Android.h @@ -86,7 +86,7 @@ #define AZ_TRAIT_SYSTEMFILE_INVALID_HANDLE nullptr #define AZ_TRAIT_SYSTEMFILE_FSYNC_IS_DEFINED 1 #define AZ_TRAIT_SYSTEMFILE_UNIX_LIKE_PLATFORM_IS_WRITEABLE_DEFINED_ELSEWHERE 0 -#define AZ_TRAIT_TEST_ROOT_FOLDER "/sdcard/Android/data/com.lumberyard.tests/files" +#define AZ_TRAIT_TEST_ROOT_FOLDER "/sdcard/Android/data/org.o3de.tests/files" #define AZ_TRAIT_TEST_SUPPORT_DLOPEN 0 #define AZ_TRAIT_TEST_SUPPORT_LOADLIBRARY 0 #define AZ_TRAIT_TEST_SUPPORT_MODULE_LOADING 0 diff --git a/Code/Framework/AzCore/Platform/Android/AzCore/Debug/Profiler_Android.inl b/Code/Framework/AzCore/Platform/Android/AzCore/Debug/Profiler_Android.inl new file mode 100644 index 0000000000..30f18fca6b --- /dev/null +++ b/Code/Framework/AzCore/Platform/Android/AzCore/Debug/Profiler_Android.inl @@ -0,0 +1,37 @@ +/* + * Copyright (c) Contributors to the Open 3D Engine Project. + * For complete copyright and license terms please see the LICENSE at the root of this distribution. + * + * SPDX-License-Identifier: Apache-2.0 OR MIT + * + */ + +#include + +#include + +namespace AZ::Debug::Platform +{ + template + void BeginProfileRegion([[maybe_unused]] Budget* budget, const char* eventName, T const&... args) + { + // ideally this would be smaller but AZ_PROFILE_FUNCTION produces some long event names + using EventNameString = AZStd::fixed_string<512>; + + AZ_PUSH_DISABLE_WARNING(, "-Wformat-security") + EventNameString fullEventName = EventNameString::format(eventName, args...); + AZ_POP_DISABLE_WARNING + + ATrace_beginSection(fullEventName.c_str()); + } + + inline void BeginProfileRegion([[maybe_unused]] Budget* budget, const char* eventName) + { + ATrace_beginSection(eventName); + } + + inline void EndProfileRegion([[maybe_unused]] Budget* budget) + { + ATrace_endSection(); + } +} // namespace AZ::Debug::Platform diff --git a/Code/Framework/AzCore/Platform/Android/AzCore/Debug/Profiler_Platform.inl b/Code/Framework/AzCore/Platform/Android/AzCore/Debug/Profiler_Platform.inl new file mode 100644 index 0000000000..5499a0c573 --- /dev/null +++ b/Code/Framework/AzCore/Platform/Android/AzCore/Debug/Profiler_Platform.inl @@ -0,0 +1,9 @@ +/* + * 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 diff --git a/Code/Framework/AzCore/Platform/Android/platform_android_files.cmake b/Code/Framework/AzCore/Platform/Android/platform_android_files.cmake index 15326a4435..e72ae2a363 100644 --- a/Code/Framework/AzCore/Platform/Android/platform_android_files.cmake +++ b/Code/Framework/AzCore/Platform/Android/platform_android_files.cmake @@ -62,25 +62,27 @@ set(FILES ../Common/UnixLike/AzCore/std/time_UnixLike.cpp AzCore/Utils/Utils_Android.cpp ../Common/Unimplemented/AzCore/Utils/Utils_Unimplemented.cpp - ../../AzCore/Android/AndroidEnv.cpp - ../../AzCore/Android/AndroidEnv.h - ../../AzCore/Android/APKFileHandler.cpp - ../../AzCore/Android/APKFileHandler.h - ../../AzCore/Android/ApiLevel.h - ../../AzCore/Android/Utils.cpp - ../../AzCore/Android/Utils.h - ../../AzCore/Android/JNI/JNI.cpp - ../../AzCore/Android/JNI/JNI.h - ../../AzCore/Android/JNI/Object.h - ../../AzCore/Android/JNI/Object_fwd.h - ../../AzCore/Android/JNI/scoped_ref.h - ../../AzCore/Android/JNI/shared_ref.h - ../../AzCore/Android/JNI/Signature.h - ../../AzCore/Android/JNI/Internal/ClassName.h - ../../AzCore/Android/JNI/Internal/JStringUtils.h - ../../AzCore/Android/JNI/Internal/JStringUtils_impl.h - ../../AzCore/Android/JNI/Internal/Object_impl.h - ../../AzCore/Android/JNI/Internal/Signature_impl.h + AzCore/Android/AndroidEnv.cpp + AzCore/Android/AndroidEnv.h + AzCore/Android/APKFileHandler.cpp + AzCore/Android/APKFileHandler.h + AzCore/Android/ApiLevel.h + AzCore/Android/Utils.cpp + AzCore/Android/Utils.h + AzCore/Android/JNI/JNI.cpp + AzCore/Android/JNI/JNI.h + AzCore/Android/JNI/Object.h + AzCore/Android/JNI/Object_fwd.h + AzCore/Android/JNI/scoped_ref.h + AzCore/Android/JNI/shared_ref.h + AzCore/Android/JNI/Signature.h + AzCore/Android/JNI/Internal/ClassName.h + AzCore/Android/JNI/Internal/JStringUtils.h + AzCore/Android/JNI/Internal/JStringUtils_impl.h + AzCore/Android/JNI/Internal/Object_impl.h + AzCore/Android/JNI/Internal/Signature_impl.h + AzCore/Debug/Profiler_Platform.inl + AzCore/Debug/Profiler_Android.inl ) if (LY_TEST_PROJECT) ly_add_source_properties( diff --git a/Code/Framework/AzCore/Platform/Common/Unimplemented/AzCore/Debug/Profiler_Unimplemented.inl b/Code/Framework/AzCore/Platform/Common/Unimplemented/AzCore/Debug/Profiler_Unimplemented.inl new file mode 100644 index 0000000000..aa796312d7 --- /dev/null +++ b/Code/Framework/AzCore/Platform/Common/Unimplemented/AzCore/Debug/Profiler_Unimplemented.inl @@ -0,0 +1,23 @@ +/* + * 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 + * + */ + +namespace AZ::Debug::Platform +{ + template + void BeginProfileRegion([[maybe_unused]] Budget* budget, [[maybe_unused]] const char* eventName, [[maybe_unused]] T const&... args) + { + } + + inline void BeginProfileRegion([[maybe_unused]] Budget* budget, [[maybe_unused]] const char* eventName) + { + } + + inline void EndProfileRegion([[maybe_unused]] Budget* budget) + { + } +} // namespace AZ::Debug::Platform diff --git a/Code/Framework/AzCore/Platform/Common/WinAPI/AzCore/Debug/Profiler_WinAPI.inl b/Code/Framework/AzCore/Platform/Common/WinAPI/AzCore/Debug/Profiler_WinAPI.inl new file mode 100644 index 0000000000..848460837d --- /dev/null +++ b/Code/Framework/AzCore/Platform/Common/WinAPI/AzCore/Debug/Profiler_WinAPI.inl @@ -0,0 +1,37 @@ +/* + * Copyright (c) Contributors to the Open 3D Engine Project. + * For complete copyright and license terms please see the LICENSE at the root of this distribution. + * + * SPDX-License-Identifier: Apache-2.0 OR MIT + * + */ + +#ifdef USE_PIX + #include + #include +#endif + +namespace AZ::Debug::Platform +{ + template + void BeginProfileRegion([[maybe_unused]] Budget* budget, [[maybe_unused]] const char* eventName, [[maybe_unused]] T const&... args) + { + #ifdef USE_PIX + PIXBeginEvent(PIX_COLOR_INDEX(budget->Crc() & 0xff), eventName, args...); + #endif + } + + inline void BeginProfileRegion([[maybe_unused]] Budget* budget, [[maybe_unused]] const char* eventName) + { + #ifdef USE_PIX + PIXBeginEvent(PIX_COLOR_INDEX(budget->Crc() & 0xff), eventName); + #endif + } + + inline void EndProfileRegion([[maybe_unused]] Budget* budget) + { + #ifdef USE_PIX + PIXEndEvent(); + #endif + } +} // namespace AZ::Debug::Platform diff --git a/Code/Framework/AzCore/Platform/Linux/AzCore/Debug/Profiler_Platform.inl b/Code/Framework/AzCore/Platform/Linux/AzCore/Debug/Profiler_Platform.inl new file mode 100644 index 0000000000..d453d1f645 --- /dev/null +++ b/Code/Framework/AzCore/Platform/Linux/AzCore/Debug/Profiler_Platform.inl @@ -0,0 +1,9 @@ +/* + * 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 <../Common/Unimplemented/AzCore/Debug/Profiler_Unimplemented.inl> diff --git a/Code/Framework/AzCore/Platform/Linux/platform_linux_files.cmake b/Code/Framework/AzCore/Platform/Linux/platform_linux_files.cmake index b54e38032b..ca0ec0d281 100644 --- a/Code/Framework/AzCore/Platform/Linux/platform_linux_files.cmake +++ b/Code/Framework/AzCore/Platform/Linux/platform_linux_files.cmake @@ -66,4 +66,6 @@ set(FILES ../Common/UnixLike/AzCore/std/time_UnixLike.cpp AzCore/Utils/Utils_Linux.cpp ../Common/UnixLike/AzCore/Utils/Utils_UnixLike.cpp + AzCore/Debug/Profiler_Platform.inl + ../Common/Unimplemented/AzCore/Debug/Profiler_Unimplemented.inl ) diff --git a/Code/Framework/AzCore/Platform/Mac/AzCore/Debug/Profiler_Platform.inl b/Code/Framework/AzCore/Platform/Mac/AzCore/Debug/Profiler_Platform.inl new file mode 100644 index 0000000000..d453d1f645 --- /dev/null +++ b/Code/Framework/AzCore/Platform/Mac/AzCore/Debug/Profiler_Platform.inl @@ -0,0 +1,9 @@ +/* + * 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 <../Common/Unimplemented/AzCore/Debug/Profiler_Unimplemented.inl> diff --git a/Code/Framework/AzCore/Platform/Mac/platform_mac_files.cmake b/Code/Framework/AzCore/Platform/Mac/platform_mac_files.cmake index dfb76b6db0..65453ee2a5 100644 --- a/Code/Framework/AzCore/Platform/Mac/platform_mac_files.cmake +++ b/Code/Framework/AzCore/Platform/Mac/platform_mac_files.cmake @@ -69,4 +69,6 @@ set(FILES AzCore/Utils/Utils_Mac.cpp ../Common/Apple/AzCore/Utils/Utils_Apple.cpp ../Common/UnixLike/AzCore/Utils/Utils_UnixLike.cpp + AzCore/Debug/Profiler_Platform.inl + ../Common/Unimplemented/AzCore/Debug/Profiler_Unimplemented.inl ) diff --git a/Code/Framework/AzCore/Platform/Windows/AzCore/Debug/Profiler_Platform.inl b/Code/Framework/AzCore/Platform/Windows/AzCore/Debug/Profiler_Platform.inl new file mode 100644 index 0000000000..4f6460a2a6 --- /dev/null +++ b/Code/Framework/AzCore/Platform/Windows/AzCore/Debug/Profiler_Platform.inl @@ -0,0 +1,9 @@ +/* + * 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 <../Common/WinAPI/AzCore/Debug/Profiler_WinAPI.inl> diff --git a/Code/Framework/AzCore/Platform/Windows/AzCore/IO/Streamer/StorageDrive_Windows.cpp b/Code/Framework/AzCore/Platform/Windows/AzCore/IO/Streamer/StorageDrive_Windows.cpp index feb8bce111..f71418ae8f 100644 --- a/Code/Framework/AzCore/Platform/Windows/AzCore/IO/Streamer/StorageDrive_Windows.cpp +++ b/Code/Framework/AzCore/Platform/Windows/AzCore/IO/Streamer/StorageDrive_Windows.cpp @@ -172,9 +172,9 @@ namespace AZ::IO AZ_PROFILE_FUNCTION(AzCore); AZ_Assert(request, "PrepareRequest was provided a null request."); - if (AZStd::holds_alternative(request->GetCommand())) + if (AZStd::holds_alternative(request->GetCommand())) { - auto& readRequest = AZStd::get(request->GetCommand()); + auto& readRequest = AZStd::get(request->GetCommand()); if (IsServicedByThisDrive(readRequest.m_path.GetAbsolutePath())) { FileRequest* read = m_context->GetNewInternalRequest(); @@ -195,7 +195,7 @@ namespace AZ::IO AZStd::visit([this, request](auto&& args) { using Command = AZStd::decay_t; - if constexpr (AZStd::is_same_v) + if constexpr (AZStd::is_same_v) { if (IsServicedByThisDrive(args.m_path.GetAbsolutePath())) { @@ -203,8 +203,8 @@ namespace AZ::IO return; } } - else if constexpr (AZStd::is_same_v || - AZStd::is_same_v) + else if constexpr (AZStd::is_same_v || + AZStd::is_same_v) { if (IsServicedByThisDrive(args.m_path.GetAbsolutePath())) { @@ -212,7 +212,7 @@ namespace AZ::IO return; } } - else if constexpr (AZStd::is_same_v) + else if constexpr (AZStd::is_same_v) { if (CancelRequest(request, args.m_target)) { @@ -221,15 +221,15 @@ namespace AZ::IO return; } } - else if constexpr (AZStd::is_same_v) + else if constexpr (AZStd::is_same_v) { FlushCache(args.m_path); } - else if constexpr (AZStd::is_same_v) + else if constexpr (AZStd::is_same_v) { FlushEntireCache(); } - else if constexpr (AZStd::is_same_v) + else if constexpr (AZStd::is_same_v) { Report(args); } @@ -254,27 +254,29 @@ namespace AZ::IO else if (!m_pendingRequests.empty()) { FileRequest* request = m_pendingRequests.front(); - hasWorked = AZStd::visit([this, request](auto&& args) - { - using Command = AZStd::decay_t; - if constexpr (AZStd::is_same_v) + hasWorked = AZStd::visit( + [this, request](auto&& args) { - FileExistsRequest(request); - m_pendingRequests.pop_front(); - return true; - } - else if constexpr (AZStd::is_same_v) - { - FileMetaDataRetrievalRequest(request); - m_pendingRequests.pop_front(); - return true; - } - else - { - AZ_Assert(false, "A request was added to StorageDriveWin's pending queue that isn't supported."); - return false; - } - }, request->GetCommand()); + using Command = AZStd::decay_t; + if constexpr (AZStd::is_same_v) + { + FileExistsRequest(request); + m_pendingRequests.pop_front(); + return true; + } + else if constexpr (AZStd::is_same_v) + { + FileMetaDataRetrievalRequest(request); + m_pendingRequests.pop_front(); + return true; + } + else + { + AZ_Assert(false, "A request was added to StorageDriveWin's pending queue that isn't supported."); + return false; + } + }, + request->GetCommand()); } return StreamStackEntry::ExecuteRequests() || hasFinalizedReads || hasWorked; @@ -308,7 +310,7 @@ namespace AZ::IO FileReadInformation& read = m_readSlots_readInfo[i]; u64 totalBytesRead = m_readSizeAverage.GetTotal(); double totalReadTimeUSec = aznumeric_caster(m_readTimeAverage.GetTotal().count()); - auto readCommand = AZStd::get_if(&read.m_request->GetCommand()); + auto readCommand = AZStd::get_if(&read.m_request->GetCommand()); AZ_Assert(readCommand, "Request currently reading doesn't contain a read command."); auto endTime = read.m_startTime + AZStd::chrono::microseconds(aznumeric_cast((readCommand->m_size * totalReadTimeUSec) / totalBytesRead)); earliestSlot = AZStd::min(earliestSlot, endTime); @@ -354,25 +356,25 @@ namespace AZ::IO AZStd::visit([&](auto&& args) { using Command = AZStd::decay_t; - if constexpr (AZStd::is_same_v) + if constexpr (AZStd::is_same_v) { targetFile = &args.m_path; readSize = args.m_size; offset = args.m_offset; } - else if constexpr (AZStd::is_same_v) + else if constexpr (AZStd::is_same_v) { targetFile = &args.m_compressionInfo.m_archiveFilename; readSize = args.m_compressionInfo.m_compressedSize; offset = args.m_compressionInfo.m_offset; } - else if constexpr (AZStd::is_same_v) + else if constexpr (AZStd::is_same_v) { readSize = 0; AZStd::chrono::microseconds getFileExistsTimeAverage = m_getFileExistsTimeAverage.CalculateAverage(); startTime += getFileExistsTimeAverage; } - else if constexpr (AZStd::is_same_v) + else if constexpr (AZStd::is_same_v) { readSize = 0; AZStd::chrono::microseconds getFileExistsTimeAverage = m_getFileMetaDataRetrievalTimeAverage.CalculateAverage(); @@ -411,15 +413,15 @@ namespace AZ::IO AZStd::visit([&, this](auto&& args) { using Command = AZStd::decay_t; - if constexpr (AZStd::is_same_v || - AZStd::is_same_v) + if constexpr (AZStd::is_same_v || + AZStd::is_same_v) { if (IsServicedByThisDrive(args.m_path.GetAbsolutePath())) { EstimateCompletionTimeForRequest(request, startTime, activeFile, activeOffset); } } - else if constexpr (AZStd::is_same_v) + else if constexpr (AZStd::is_same_v) { if (IsServicedByThisDrive(args.m_compressionInfo.m_archiveFilename.GetAbsolutePath())) { @@ -435,7 +437,7 @@ namespace AZ::IO aznumeric_cast(m_pendingRequests.size()) - m_activeReads_Count; } - auto StorageDriveWin::OpenFile(HANDLE& fileHandle, size_t& cacheSlot, FileRequest* request, const FileRequest::ReadData& data) -> OpenFileResult + auto StorageDriveWin::OpenFile(HANDLE& fileHandle, size_t& cacheSlot, FileRequest* request, const Requests::ReadData& data) -> OpenFileResult { HANDLE file = INVALID_HANDLE_VALUE; @@ -553,7 +555,7 @@ namespace AZ::IO return false; } - auto data = AZStd::get_if(&request->GetCommand()); + auto data = AZStd::get_if(&request->GetCommand()); AZ_Assert(data, "Read request in StorageDriveWin doesn't contain read data."); HANDLE file = INVALID_HANDLE_VALUE; @@ -780,7 +782,7 @@ namespace AZ::IO void StorageDriveWin::FileExistsRequest(FileRequest* request) { - auto& fileExists = AZStd::get(request->GetCommand()); + auto& fileExists = AZStd::get(request->GetCommand()); AZ_PROFILE_SCOPE(AzCore, "StorageDriveWin::FileExistsRequest %s : %s", m_name.c_str(), fileExists.m_path.GetRelativePath()); @@ -836,7 +838,7 @@ namespace AZ::IO void StorageDriveWin::FileMetaDataRetrievalRequest(FileRequest* request) { - auto& command = AZStd::get(request->GetCommand()); + auto& command = AZStd::get(request->GetCommand()); AZ_PROFILE_SCOPE(AzCore, "StorageDriveWin::FileMetaDataRetrievalRequest %s : %s", m_name.c_str(), command.m_path.GetRelativePath()); @@ -1005,7 +1007,7 @@ namespace AZ::IO FileReadInformation& fileReadInfo = m_readSlots_readInfo[readSlot]; - auto readCommand = AZStd::get_if(&fileReadInfo.m_request->GetCommand()); + auto readCommand = AZStd::get_if(&fileReadInfo.m_request->GetCommand()); AZ_Assert(readCommand != nullptr, "Request stored with the overlapped I/O call did not contain a read request."); if (fileReadInfo.m_sectorAlignedOutput && !encounteredError) @@ -1147,11 +1149,11 @@ namespace AZ::IO StreamStackEntry::CollectStatistics(statistics); } - void StorageDriveWin::Report(const FileRequest::ReportData& data) const + void StorageDriveWin::Report(const Requests::ReportData& data) const { switch (data.m_reportType) { - case FileRequest::ReportData::ReportType::FileLocks: + case Requests::ReportType::FileLocks: if (m_cachesInitialized) { for (u32 i = 0; i < m_maxFileHandles; ++i) diff --git a/Code/Framework/AzCore/Platform/Windows/AzCore/IO/Streamer/StorageDrive_Windows.h b/Code/Framework/AzCore/Platform/Windows/AzCore/IO/Streamer/StorageDrive_Windows.h index c70eb7804d..5207d094ef 100644 --- a/Code/Framework/AzCore/Platform/Windows/AzCore/IO/Streamer/StorageDrive_Windows.h +++ b/Code/Framework/AzCore/Platform/Windows/AzCore/IO/Streamer/StorageDrive_Windows.h @@ -9,6 +9,7 @@ #pragma once #include +#include #include #include #include @@ -19,6 +20,12 @@ #include #include +namespace AZ::IO::Requests +{ + struct ReadData; + struct ReportData; +} + namespace AZ::IO { class StorageDriveWin @@ -111,7 +118,7 @@ namespace AZ::IO CacheFull }; - OpenFileResult OpenFile(HANDLE& fileHandle, size_t& cacheSlot, FileRequest* request, const FileRequest::ReadData& data); + OpenFileResult OpenFile(HANDLE& fileHandle, size_t& cacheSlot, FileRequest* request, const Requests::ReadData& data); bool ReadRequest(FileRequest* request); bool ReadRequest(FileRequest* request, size_t readSlot); bool CancelRequest(FileRequest* cancelRequest, FileRequestPtr& target); @@ -137,7 +144,7 @@ namespace AZ::IO void FinalizeSingleRequest(FileReadStatus& status, size_t readSlot, DWORD numBytesTransferred, bool isCanceled, bool encounteredError); - void Report(const FileRequest::ReportData& data) const; + void Report(const Requests::ReportData& data) const; TimedAverageWindow m_fileOpenCloseTimeAverage; TimedAverageWindow m_getFileExistsTimeAverage; diff --git a/Code/Framework/AzCore/Platform/Windows/platform_windows_files.cmake b/Code/Framework/AzCore/Platform/Windows/platform_windows_files.cmake index 6386377fcb..55bbebe917 100644 --- a/Code/Framework/AzCore/Platform/Windows/platform_windows_files.cmake +++ b/Code/Framework/AzCore/Platform/Windows/platform_windows_files.cmake @@ -72,4 +72,6 @@ set(FILES AzCore/std/time_Windows.cpp ../Common/WinAPI/AzCore/Utils/Utils_WinAPI.cpp AzCore/Utils/Utils_Windows.cpp + AzCore/Debug/Profiler_Platform.inl + ../Common/WinAPI/AzCore/Debug/Profiler_WinAPI.inl ) diff --git a/Code/Framework/AzCore/Platform/iOS/AzCore/Debug/Profiler_Platform.inl b/Code/Framework/AzCore/Platform/iOS/AzCore/Debug/Profiler_Platform.inl new file mode 100644 index 0000000000..d453d1f645 --- /dev/null +++ b/Code/Framework/AzCore/Platform/iOS/AzCore/Debug/Profiler_Platform.inl @@ -0,0 +1,9 @@ +/* + * 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 <../Common/Unimplemented/AzCore/Debug/Profiler_Unimplemented.inl> diff --git a/Code/Framework/AzCore/Platform/iOS/platform_ios_files.cmake b/Code/Framework/AzCore/Platform/iOS/platform_ios_files.cmake index 81ee9bd09f..6d50d65160 100644 --- a/Code/Framework/AzCore/Platform/iOS/platform_ios_files.cmake +++ b/Code/Framework/AzCore/Platform/iOS/platform_ios_files.cmake @@ -67,4 +67,6 @@ set(FILES AzCore/Utils/Utils_iOS.mm ../Common/Apple/AzCore/Utils/Utils_Apple.cpp ../Common/UnixLike/AzCore/Utils/Utils_UnixLike.cpp + AzCore/Debug/Profiler_Platform.inl + ../Common/Unimplemented/AzCore/Debug/Profiler_Unimplemented.inl ) diff --git a/Code/Framework/AzCore/Tests/AZStd/ConceptsTests.cpp b/Code/Framework/AzCore/Tests/AZStd/ConceptsTests.cpp new file mode 100644 index 0000000000..718edfcde4 --- /dev/null +++ b/Code/Framework/AzCore/Tests/AZStd/ConceptsTests.cpp @@ -0,0 +1,202 @@ +/* + * 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 + +namespace UnitTest +{ + class ConceptsTestFixture + : public ScopedAllocatorSetupFixture + {}; + + TEST_F(ConceptsTestFixture, GeneralConcepts) + { + + // concept same_as + static_assert(AZStd::same_as); + static_assert(!AZStd::same_as); + + // concept derived_from + static_assert(AZStd::derived_from); + static_assert(!AZStd::derived_from); + + // concept convertible_to + static_assert(AZStd::convertible_to); + static_assert(!AZStd::convertible_to); + + + // Test structs to validate common_reference_with and common_with concepts + struct Base {}; + struct TestBase : Base {}; + struct NoMove + { + NoMove(NoMove&&) = delete; + NoMove& operator=(NoMove&&) = delete; + }; + struct NoDestructible + { + ~NoDestructible() = delete; + }; + struct NoDefaultInitializable + { + NoDefaultInitializable(bool); + }; + + struct CopyOnly + { + CopyOnly(const CopyOnly&) = default; + }; + struct MoveOnly + { + MoveOnly(MoveOnly&&) = default; + }; + + struct MoveableButNotCopyable + { + MoveableButNotCopyable(MoveableButNotCopyable&&) = default; + MoveableButNotCopyable& operator=(MoveableButNotCopyable&&) = default; + }; + + // concept common_reference_with + static_assert(AZStd::common_reference_with); + static_assert(AZStd::same_as, const Base&>); + static_assert(!AZStd::common_reference_with); + + // concept common_with + static_assert(AZStd::common_with); + static_assert(!AZStd::common_with); + + // arithmetic concepts + // concept integral + static_assert(AZStd::integral); + static_assert(!AZStd::integral); + + // concept signed_integral + static_assert(AZStd::signed_integral); + static_assert(!AZStd::signed_integral); + static_assert(!AZStd::signed_integral); + + // concept signed_integral + static_assert(AZStd::unsigned_integral); + static_assert(!AZStd::unsigned_integral); + static_assert(!AZStd::unsigned_integral); + + // concept floating_point + static_assert(AZStd::floating_point); + static_assert(!AZStd::floating_point); + + // concept assignable_from + static_assert(AZStd::assignable_from); + static_assert(!AZStd::assignable_from); + + // concept swappable + static_assert(AZStd::swappable); + static_assert(!AZStd::swappable); + static_assert(AZStd::swappable_with); + static_assert(!AZStd::swappable_with); + + // concept destructible + static_assert(AZStd::destructible); + static_assert(!AZStd::destructible); + + // concept constructible_from + static_assert(AZStd::constructible_from); + static_assert(!AZStd::constructible_from); + + // concept default_initializable + static_assert(AZStd::default_initializable); + static_assert(!AZStd::default_initializable); + + // concept move_constructible + static_assert(AZStd::move_constructible); + static_assert(!AZStd::move_constructible); + + // concept copy_constructible + static_assert(AZStd::copy_constructible); + static_assert(!AZStd::copy_constructible); + + // concept equality_comparable + static_assert(AZStd::equality_comparable); + static_assert(!AZStd::equality_comparable); + static_assert(AZStd::equality_comparable_with); + static_assert(!AZStd::equality_comparable_with); + static_assert(!AZStd::equality_comparable_with); + + // concept totally_ordered + static_assert(AZStd::totally_ordered); + static_assert(!AZStd::totally_ordered); + static_assert(AZStd::totally_ordered_with); + static_assert(!AZStd::totally_ordered_with); + static_assert(!AZStd::totally_ordered_with); + + // concept movable + static_assert(AZStd::movable); + static_assert(!AZStd::movable); + + // concept copyable + static_assert(AZStd::copyable); + static_assert(!AZStd::copyable); + + // concept semiregular + static_assert(AZStd::semiregular); + static_assert(!AZStd::semiregular); + + // concept regular + static_assert(AZStd::regular); + static_assert(!AZStd::regular); + + // concept invocable + static_assert(AZStd::invocable); + static_assert(!AZStd::invocable); + + // concept predicate + auto BooleanPredicate = [](double) -> int + { + return 0; + }; + auto BasePredicate = [](int) -> Base + { + return Base{}; + }; + + static_assert(AZStd::predicate); + static_assert(!AZStd::predicate); + static_assert(!AZStd::predicate); + + // concept relation + struct RelationPredicate + { + bool operator()(AZStd::string_view, Base) const; + bool operator()(Base, AZStd::string_view) const; + bool operator()(AZStd::string_view, AZStd::string_view) const; + bool operator()(Base, Base) const; + + // non-complete relation + bool operator()(Base, int) const; + bool operator()(int, Base) const; + }; + + static_assert(AZStd::relation); + static_assert(AZStd::relation); + static_assert(!AZStd::relation); + static_assert(!AZStd::relation); + + //concept equivalence_relation + static_assert(AZStd::equivalence_relation); + static_assert(AZStd::equivalence_relation); + static_assert(!AZStd::equivalence_relation); + static_assert(!AZStd::equivalence_relation); + + //concept strict_weak_order + static_assert(AZStd::strict_weak_order); + static_assert(AZStd::strict_weak_order); + static_assert(!AZStd::strict_weak_order); + static_assert(!AZStd::strict_weak_order); + } +} diff --git a/Code/Framework/AzCore/Tests/AZStd/Iterators.cpp b/Code/Framework/AzCore/Tests/AZStd/Iterators.cpp index 720aa0c7a8..28b596398e 100644 --- a/Code/Framework/AzCore/Tests/AZStd/Iterators.cpp +++ b/Code/Framework/AzCore/Tests/AZStd/Iterators.cpp @@ -6,6 +6,7 @@ * */ #include "UserTypes.h" +#include #include #include #include @@ -13,13 +14,11 @@ #include #include -using namespace AZStd; -using namespace UnitTestInternal; namespace UnitTest { class Iterators - : public AllocatorsFixture + : public ScopedAllocatorSetupFixture { }; @@ -28,30 +27,30 @@ namespace UnitTest { Container int_container = {{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }}; - typename Container::iterator iter_begin = begin(int_container); + typename Container::iterator iter_begin = AZStd::begin(int_container); EXPECT_EQ(*iter_begin, 0); - EXPECT_EQ(*next(iter_begin), 1); - EXPECT_EQ(*next(iter_begin, 2), 2); + EXPECT_EQ(*AZStd::next(iter_begin), 1); + EXPECT_EQ(*AZStd::next(iter_begin, 2), 2); ++iter_begin; EXPECT_EQ(*iter_begin, 1); typename Container::iterator iter_end = end(int_container); EXPECT_EQ(iter_end, int_container.end()); - EXPECT_EQ(*prev(iter_end), 9); - EXPECT_EQ(*prev(iter_end, 2), 8); + EXPECT_EQ(*AZStd::prev(iter_end), 9); + EXPECT_EQ(*AZStd::prev(iter_end, 2), 8); --iter_end; EXPECT_EQ(*iter_end, 9); - typename Container::reverse_iterator iter_rbegin = rbegin(int_container); + typename Container::reverse_iterator iter_rbegin = AZStd::rbegin(int_container); EXPECT_EQ(*iter_rbegin, 9); - EXPECT_EQ(*next(iter_rbegin), 8); - EXPECT_EQ(*next(iter_rbegin, 2), 7); + EXPECT_EQ(*AZStd::next(iter_rbegin), 8); + EXPECT_EQ(*AZStd::next(iter_rbegin, 2), 7); ++iter_rbegin; EXPECT_EQ(*iter_rbegin, 8); - typename Container::reverse_iterator iter_rend = rend(int_container); - EXPECT_EQ(*prev(iter_rend), 0); - EXPECT_EQ(*prev(iter_rend, 2), 1); + typename Container::reverse_iterator iter_rend = AZStd::rend(int_container); + EXPECT_EQ(*AZStd::prev(iter_rend), 0); + EXPECT_EQ(*AZStd::prev(iter_rend, 2), 1); --iter_rend; EXPECT_EQ(*iter_rend, 0); @@ -65,30 +64,30 @@ namespace UnitTest { Container int_container = {{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }}; - typename Container::const_iterator iter_cbegin = cbegin(int_container); + typename Container::const_iterator iter_cbegin = AZStd::cbegin(int_container); EXPECT_EQ(*iter_cbegin, 0); - EXPECT_EQ(*next(iter_cbegin), 1); - EXPECT_EQ(*next(iter_cbegin, 2), 2); + EXPECT_EQ(*AZStd::next(iter_cbegin), 1); + EXPECT_EQ(*AZStd::next(iter_cbegin, 2), 2); ++iter_cbegin; EXPECT_EQ(*iter_cbegin, 1); - typename Container::const_iterator iter_cend = cend(int_container); + typename Container::const_iterator iter_cend = AZStd::cend(int_container); EXPECT_EQ(iter_cend, int_container.cend()); - EXPECT_EQ(*prev(iter_cend), 9); - EXPECT_EQ(*prev(iter_cend, 2), 8); + EXPECT_EQ(*AZStd::prev(iter_cend), 9); + EXPECT_EQ(*AZStd::prev(iter_cend, 2), 8); --iter_cend; EXPECT_EQ(*iter_cend, 9); - typename Container::const_reverse_iterator iter_crbegin = crbegin(int_container); + typename Container::const_reverse_iterator iter_crbegin = AZStd::crbegin(int_container); EXPECT_EQ(*iter_crbegin, 9); - EXPECT_EQ(*next(iter_crbegin), 8); - EXPECT_EQ(*next(iter_crbegin, 2), 7); + EXPECT_EQ(*AZStd::next(iter_crbegin), 8); + EXPECT_EQ(*AZStd::next(iter_crbegin, 2), 7); ++iter_crbegin; EXPECT_EQ(*iter_crbegin, 8); - typename Container::const_reverse_iterator iter_crend = crend(int_container); - EXPECT_EQ(*prev(iter_crend), 0); - EXPECT_EQ(*prev(iter_crend, 2), 1); + typename Container::const_reverse_iterator iter_crend = AZStd::crend(int_container); + EXPECT_EQ(*AZStd::prev(iter_crend), 0); + EXPECT_EQ(*AZStd::prev(iter_crend, 2), 1); --iter_crend; EXPECT_EQ(*iter_crend, 0); } @@ -98,15 +97,15 @@ namespace UnitTest { const ConstContainer const_int_container = {{ 10, 11, 12, 13, 14, 15, 16, 17, 18, 19 }}; - typename ConstContainer::const_iterator const_iter_begin = begin(const_int_container); + typename ConstContainer::const_iterator const_iter_begin = AZStd::begin(const_int_container); EXPECT_EQ(*const_iter_begin, 10); - EXPECT_EQ(*next(const_iter_begin), 11); - EXPECT_EQ(*next(const_iter_begin, 2), 12); + EXPECT_EQ(*AZStd::next(const_iter_begin), 11); + EXPECT_EQ(*AZStd::next(const_iter_begin, 2), 12); - typename ConstContainer::const_iterator const_iter_end = end(const_int_container); + typename ConstContainer::const_iterator const_iter_end = AZStd::end(const_int_container); EXPECT_EQ(const_iter_end, const_int_container.end()); - EXPECT_EQ(*prev(const_iter_end), 19); - EXPECT_EQ(*prev(const_iter_end, 2), 18); + EXPECT_EQ(*AZStd::prev(const_iter_end), 19); + EXPECT_EQ(*AZStd::prev(const_iter_end, 2), 18); } TEST_F(Iterators, FunctionWrappers_MutableContainers) @@ -136,87 +135,78 @@ namespace UnitTest { int int_array[10] = { 20, 21, 22, 23, 24, 25, 26, 27, 28, 29 }; - EXPECT_EQ(*begin(int_array), 20); - EXPECT_EQ(*next(begin(int_array)), 21); - EXPECT_EQ(*next(begin(int_array), 2), 22); + EXPECT_EQ(*AZStd::begin(int_array), 20); + EXPECT_EQ(*AZStd::next(AZStd::begin(int_array)), 21); + EXPECT_EQ(*AZStd::next(AZStd::begin(int_array), 2), 22); - EXPECT_EQ(end(int_array) - AZ_ARRAY_SIZE(int_array), begin(int_array)); - EXPECT_EQ(*prev(end(int_array)), 29); - EXPECT_EQ(*prev(end(int_array), 2), 28); + EXPECT_EQ(AZStd::end(int_array) - AZ_ARRAY_SIZE(int_array), AZStd::begin(int_array)); + EXPECT_EQ(*AZStd::prev(AZStd::end(int_array)), 29); + EXPECT_EQ(*AZStd::prev(AZStd::end(int_array), 2), 28); - EXPECT_EQ(*rbegin(int_array), 29); - EXPECT_EQ(*next(rbegin(int_array)), 28); - EXPECT_EQ(*next(rbegin(int_array), 2), 27); + EXPECT_EQ(*AZStd::rbegin(int_array), 29); + EXPECT_EQ(*AZStd::next(AZStd::rbegin(int_array)), 28); + EXPECT_EQ(*AZStd::next(AZStd::rbegin(int_array), 2), 27); - EXPECT_EQ(*prev(rend(int_array)), 20); - EXPECT_EQ(*prev(rend(int_array), 2), 21); + EXPECT_EQ(*AZStd::prev(AZStd::rend(int_array)), 20); + EXPECT_EQ(*AZStd::prev(AZStd::rend(int_array), 2), 21); - EXPECT_EQ(*crbegin(int_array), 29); - EXPECT_EQ(*next(crbegin(int_array)), 28); - EXPECT_EQ(*next(crbegin(int_array), 2), 27); + EXPECT_EQ(*AZStd::crbegin(int_array), 29); + EXPECT_EQ(*AZStd::next(AZStd::crbegin(int_array)), 28); + EXPECT_EQ(*AZStd::next(AZStd::crbegin(int_array), 2), 27); - EXPECT_EQ(*prev(crend(int_array)), 20); - EXPECT_EQ(*prev(crend(int_array), 2), 21); + EXPECT_EQ(*AZStd::prev(AZStd::crend(int_array)), 20); + EXPECT_EQ(*AZStd::prev(AZStd::crend(int_array), 2), 21); //verify we can successfully modify the value in a non-const iterator - *begin(int_array) = -42; - EXPECT_EQ(*begin(int_array), -42); + *AZStd::begin(int_array) = -42; + EXPECT_EQ(*AZStd::begin(int_array), -42); } TEST_F(Iterators, FunctionWrappers_ConstRawArray) { const int const_int_array[10] = { 30, 31, 32, 33, 34, 35, 36, 37, 38, 39 }; - EXPECT_EQ(*cbegin(const_int_array), 30); - EXPECT_EQ(*next(cbegin(const_int_array)), 31); - EXPECT_EQ(*next(cbegin(const_int_array), 2), 32); + EXPECT_EQ(*AZStd::cbegin(const_int_array), 30); + EXPECT_EQ(*AZStd::next(AZStd::cbegin(const_int_array)), 31); + EXPECT_EQ(*AZStd::next(AZStd::cbegin(const_int_array), 2), 32); - EXPECT_EQ(cend(const_int_array) - AZ_ARRAY_SIZE(const_int_array), cbegin(const_int_array)); - EXPECT_EQ(*prev(cend(const_int_array)), 39); - EXPECT_EQ(*prev(cend(const_int_array), 2), 38); + EXPECT_EQ(AZStd::cend(const_int_array) - AZ_ARRAY_SIZE(const_int_array), AZStd::cbegin(const_int_array)); + EXPECT_EQ(*AZStd::prev(AZStd::cend(const_int_array)), 39); + EXPECT_EQ(*AZStd::prev(AZStd::cend(const_int_array), 2), 38); } TEST_F(Iterators, IteratorTraits_ResolveAtCompileTime) { using list_type = AZStd::list; - static_assert(AZStd::Internal::has_iterator_category_v); - static_assert(AZStd::Internal::has_iterator_type_aliases_v); constexpr bool list_type_iterator_type_aliases = AZStd::Internal::has_iterator_type_aliases_v; static_assert(AZStd::is_convertible_v::iterator_category, AZStd::input_iterator_tag>); - static_assert(is_same_v::iterator_category, bidirectional_iterator_tag>); - static_assert(is_same_v::value_type, int>); - static_assert(is_same_v::difference_type, AZStd::ptrdiff_t>); - static_assert(is_same_v::pointer, int*>); - static_assert(is_same_v::reference, int&>); - static_assert(AZStd::Internal::is_input_iterator_v); - static_assert(!AZStd::Internal::has_iterator_concept_v>); - static_assert(!AZStd::Internal::satisfies_contiguous_iterator_concept_v); + static_assert(AZStd::is_same_v::iterator_category, AZStd::bidirectional_iterator_tag>); + static_assert(AZStd::is_same_v::value_type, int>); + static_assert(AZStd::is_same_v::difference_type, AZStd::ptrdiff_t>); + static_assert(AZStd::is_same_v::pointer, int*>); + static_assert(AZStd::is_same_v::reference, int&>); + static_assert(AZStd::input_iterator); + static_assert(!AZStd::contiguous_iterator); - static_assert(AZStd::Internal::has_iterator_category_v); - static_assert(AZStd::Internal::has_iterator_type_aliases_v); constexpr bool list_type_const_iterator_type_aliases = AZStd::Internal::has_iterator_type_aliases_v; static_assert(AZStd::is_convertible_v::iterator_category, AZStd::input_iterator_tag>); - static_assert(is_same_v::iterator_category, bidirectional_iterator_tag>); - static_assert(is_same_v::value_type, int>); - static_assert(is_same_v::difference_type, AZStd::ptrdiff_t>); - static_assert(is_same_v::pointer, const int*>); - static_assert(is_same_v::reference, const int&>); - static_assert(AZStd::Internal::is_input_iterator_v); - static_assert(!AZStd::Internal::has_iterator_concept_v>); - static_assert(!AZStd::Internal::satisfies_contiguous_iterator_concept_v); + static_assert(AZStd::is_same_v::iterator_category, AZStd::bidirectional_iterator_tag>); + static_assert(AZStd::is_same_v::value_type, int>); + static_assert(AZStd::is_same_v::difference_type, AZStd::ptrdiff_t>); + static_assert(AZStd::is_same_v::pointer, const int*>); + static_assert(AZStd::is_same_v::reference, const int&>); + static_assert(AZStd::input_iterator); + static_assert(!AZStd::contiguous_iterator); using pointer_type = const char*; - static_assert(AZStd::Internal::has_iterator_category_v>); - static_assert(AZStd::Internal::has_iterator_type_aliases_v>); - static_assert(is_same_v::iterator_concept, contiguous_iterator_tag>); - static_assert(is_same_v::iterator_category, random_access_iterator_tag>); - static_assert(is_same_v::value_type, char>); - static_assert(is_same_v::difference_type, AZStd::ptrdiff_t>); - static_assert(is_same_v::pointer, const char*>); - static_assert(is_same_v::reference, const char&>); - static_assert(AZStd::Internal::has_iterator_concept_v>); - static_assert(AZStd::Internal::satisfies_contiguous_iterator_concept_v); + static_assert(AZStd::is_same_v::iterator_concept, AZStd::contiguous_iterator_tag>); + static_assert(AZStd::is_same_v::iterator_category, AZStd::random_access_iterator_tag>); + static_assert(AZStd::is_same_v::value_type, char>); + static_assert(AZStd::is_same_v::difference_type, AZStd::ptrdiff_t>); + static_assert(AZStd::is_same_v::pointer, const char*>); + static_assert(AZStd::is_same_v::reference, const char&>); + static_assert(AZStd::contiguous_iterator); } } diff --git a/Code/Framework/AzCore/Tests/AZStd/RangesTests.cpp b/Code/Framework/AzCore/Tests/AZStd/RangesTests.cpp new file mode 100644 index 0000000000..7d0751a519 --- /dev/null +++ b/Code/Framework/AzCore/Tests/AZStd/RangesTests.cpp @@ -0,0 +1,583 @@ +/* + * 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 +{ + class RangesTestFixture + : public ScopedAllocatorSetupFixture + {}; + + struct RangeLikeCustomizationPoint {}; + + RangeLikeCustomizationPoint* begin(RangeLikeCustomizationPoint& rangeLike) + { + return &rangeLike; + } + RangeLikeCustomizationPoint* end(RangeLikeCustomizationPoint& rangeLike) + { + return &rangeLike; + } + const RangeLikeCustomizationPoint* cbegin(const RangeLikeCustomizationPoint& rangeLike) + { + return &rangeLike; + } + const RangeLikeCustomizationPoint* cend(const RangeLikeCustomizationPoint& rangeLike) + { + return &rangeLike; + } + RangeLikeCustomizationPoint* rbegin(RangeLikeCustomizationPoint& rangeLike) + { + return &rangeLike; + } + RangeLikeCustomizationPoint* rend(RangeLikeCustomizationPoint& rangeLike) + { + return &rangeLike; + } + const RangeLikeCustomizationPoint* crbegin(const RangeLikeCustomizationPoint& rangeLike) + { + return &rangeLike; + } + const RangeLikeCustomizationPoint* crend(const RangeLikeCustomizationPoint& rangeLike) + { + return &rangeLike; + } + + constexpr size_t size(const RangeLikeCustomizationPoint&) + { + return 0; + } + constexpr size_t size(RangeLikeCustomizationPoint&) + { + return 0; + } + + + // range access + TEST_F(RangesTestFixture, RangesBegin_Compiles_WithExtentArray) + { + using ArrayExtentType = int[5]; + + ArrayExtentType extentArray{}; + EXPECT_EQ(extentArray + 0, AZStd::ranges::begin(extentArray)); + } + + TEST_F(RangesTestFixture, RangesBegin_DoesNotCompile_WithNoExtentArray) + { + using ArrayNoExtentType = int[]; + static_assert(!AZStd::invocable); + } + + TEST_F(RangesTestFixture, RangesBegin_Compiles_WithMemberOverload) + { + AZStd::string_view strView; + EXPECT_EQ(strView.begin(), AZStd::ranges::begin(strView)); + } + + TEST_F(RangesTestFixture, RangesBegin_Compiles_WithADL) + { + RangeLikeCustomizationPoint rangeLike; + EXPECT_EQ(&rangeLike, AZStd::ranges::begin(rangeLike)); + } + + TEST_F(RangesTestFixture, RangesEnd_Compiles_WithExtentArray) + { + using ArrayExtentType = int[5]; + + ArrayExtentType extentArray{}; + EXPECT_EQ(extentArray + 5, AZStd::ranges::end(extentArray)); + } + + TEST_F(RangesTestFixture, RangesEnd_DoesNotCompile_WithNoExtentArray) + { + using ArrayNoExtentType = int[]; + static_assert(!AZStd::invocable); + } + + TEST_F(RangesTestFixture, RangesEnd_Compiles_WithMemberOverload) + { + AZStd::string_view strView; + EXPECT_EQ(strView.end(), AZStd::ranges::end(strView)); + } + TEST_F(RangesTestFixture, RangesEnd_Compiles_WithADL) + { + RangeLikeCustomizationPoint rangeLike; + EXPECT_EQ(&rangeLike, AZStd::ranges::end(rangeLike)); + } + + TEST_F(RangesTestFixture, RangesCBegin_Compiles_WithExtentArray) + { + using ArrayExtentType = int[5]; + + ArrayExtentType extentArray{}; + EXPECT_EQ(extentArray + 0, AZStd::ranges::cbegin(extentArray)); + } + + TEST_F(RangesTestFixture, RangesCBegin_Compiles_WithMemberOverload) + { + AZStd::string_view strView; + EXPECT_EQ(strView.cbegin(), AZStd::ranges::cbegin(strView)); + } + + TEST_F(RangesTestFixture, RangesCBegin_Compiles_WithADL) + { + RangeLikeCustomizationPoint rangeLike; + EXPECT_EQ(&rangeLike, AZStd::ranges::cbegin(rangeLike)); + } + + TEST_F(RangesTestFixture, RangesCEnd_Compiles_WithExtentArray) + { + using ArrayExtentType = int[5]; + + ArrayExtentType extentArray{}; + EXPECT_EQ(extentArray + 5, AZStd::ranges::cend(extentArray)); + } + + TEST_F(RangesTestFixture, RangesCEnd_Compiles_WithMemberOverload) + { + AZStd::string_view strView; + EXPECT_EQ(strView.cend(), AZStd::ranges::cend(strView)); + } + + TEST_F(RangesTestFixture, RangesCEnd_Compiles_WithADL) + { + RangeLikeCustomizationPoint rangeLike; + EXPECT_EQ(&rangeLike, AZStd::ranges::cend(rangeLike)); + } + + TEST_F(RangesTestFixture, RangesRBegin_Compiles_WithExtentArray) + { + using ArrayExtentType = int[5]; + + ArrayExtentType extentArray{}; + EXPECT_EQ(extentArray + 5, AZStd::ranges::rbegin(extentArray).base()); + } + + TEST_F(RangesTestFixture, RangesRBegin_Compiles_WithMemberOverload) + { + AZStd::string_view strView; + EXPECT_EQ(strView.rbegin(), AZStd::ranges::rbegin(strView)); + } + TEST_F(RangesTestFixture, RangesRBegin_Compiles_WithADL) + { + RangeLikeCustomizationPoint rangeLike; + EXPECT_EQ(&rangeLike, AZStd::ranges::rbegin(rangeLike)); + } + + TEST_F(RangesTestFixture, RangesREnd_Compiles_WithExtentArray) + { + using ArrayExtentType = int[5]; + + ArrayExtentType extentArray{}; + EXPECT_EQ(extentArray, AZStd::ranges::rend(extentArray).base()); + } + + TEST_F(RangesTestFixture, RangesREnd_Compiles_WithMemberOverload) + { + AZStd::string_view strView; + EXPECT_EQ(strView.rend(), AZStd::ranges::rend(strView)); + } + TEST_F(RangesTestFixture, RangesREnd_Compiles_WithADL) + { + RangeLikeCustomizationPoint rangeLike; + EXPECT_EQ(&rangeLike, AZStd::ranges::rend(rangeLike)); + } + + TEST_F(RangesTestFixture, RangesCRBegin_Compiles_WithExtentArray) + { + using ArrayExtentType = int[5]; + + ArrayExtentType extentArray{}; + EXPECT_EQ(extentArray + 5, AZStd::ranges::crbegin(extentArray).base()); + } + + TEST_F(RangesTestFixture, RangesCRBegin_Compiles_WithMemberOverload) + { + AZStd::string_view strView; + EXPECT_EQ(strView.crbegin(), AZStd::ranges::crbegin(strView)); + } + TEST_F(RangesTestFixture, RangesCRBegin_Compiles_WithADL) + { + RangeLikeCustomizationPoint rangeLike; + EXPECT_EQ(&rangeLike, AZStd::ranges::crbegin(rangeLike)); + } + + TEST_F(RangesTestFixture, RangesCREnd_Compiles_WithExtentArray) + { + using ArrayExtentType = int[5]; + + ArrayExtentType extentArray{}; + EXPECT_EQ(extentArray + 0, AZStd::ranges::crend(extentArray).base()); + } + + TEST_F(RangesTestFixture, RangesCREnd_Compiles_WithMemberOverload) + { + AZStd::string_view strView; + EXPECT_EQ(strView.crend(), AZStd::ranges::crend(strView)); + } + + TEST_F(RangesTestFixture, RangesCREnd_Compiles_WithADL) + { + RangeLikeCustomizationPoint rangeLike; + EXPECT_EQ(&rangeLike, AZStd::ranges::crend(rangeLike)); + } + + // range access - size + TEST_F(RangesTestFixture, RangesSize_Compiles_WithExtentArray) + { + using ArrayExtentType = int[5]; + + constexpr ArrayExtentType extentArray{}; + static_assert(5 == AZStd::ranges::size(extentArray)); + } + + TEST_F(RangesTestFixture, RangesSize_DoesNotCompile_WithNoExtentArray) + { + using ArrayNoExtentType = int[]; + static_assert(!AZStd::invocable); + } + + TEST_F(RangesTestFixture, RangesSize_Compiles_WithMemberOverload) + { + AZStd::string_view strView; + EXPECT_EQ(strView.size(), AZStd::ranges::size(strView)); + } + + + TEST_F(RangesTestFixture, RangesSize_Compiles_WithADL) + { + RangeLikeCustomizationPoint rangeLike; + + EXPECT_EQ(0, AZStd::ranges::size(rangeLike)); + } + + TEST_F(RangesTestFixture, RangesSSize_Compiles_WithExtentArray) + { + using ArrayExtentType = int[5]; + + constexpr ArrayExtentType extentArray{}; + static_assert(AZStd::signed_integral); + static_assert(5 == AZStd::ranges::ssize(extentArray)); + } + + TEST_F(RangesTestFixture, RangesSSize_DoesNotCompile_WithNoExtentArray) + { + using ArrayNoExtentType = int[]; + static_assert(!AZStd::invocable); + } + + TEST_F(RangesTestFixture, RangesSSize_Compiles_WithMemberOverload) + { + AZStd::string_view strView; + static_assert(AZStd::signed_integral); + EXPECT_EQ(strView.size(), AZStd::ranges::ssize(strView)); + } + + TEST_F(RangesTestFixture, RangesSSize_Compiles_WithADL) + { + RangeLikeCustomizationPoint rangeLike; + static_assert(AZStd::signed_integral); + EXPECT_EQ(0, AZStd::ranges::ssize(rangeLike)); + } + + // range access - empty + TEST_F(RangesTestFixture, RangesEmpty_Compiles_WithExtentArray) + { + using ArrayExtentType = int[5]; + + constexpr ArrayExtentType extentArray{}; + static_assert(!AZStd::ranges::empty(extentArray)); + } + + TEST_F(RangesTestFixture, RangesEmpty_DoesNotCompile_WithNoExtentArray) + { + using ArrayNoExtentType = int[]; + static_assert(!AZStd::invocable); + } + + TEST_F(RangesTestFixture, RangesEmpty_Compiles_WithMemberOverload) + { + constexpr AZStd::string_view strView; + static_assert(AZStd::ranges::empty(strView)); + } + + TEST_F(RangesTestFixture, RangesEmpty_Compiles_WithADL) + { + constexpr RangeLikeCustomizationPoint rangeLike; + + static_assert(AZStd::ranges::empty(rangeLike)); + } + + // range access - data + TEST_F(RangesTestFixture, RangesData_Compiles_WithExtentArray) + { + using ArrayExtentType = int[5]; + + constexpr ArrayExtentType extentArray{}; + EXPECT_EQ(extentArray, AZStd::ranges::data(extentArray)); + } + + TEST_F(RangesTestFixture, RangesData_DoesNotCompile_WithNoExtentArray) + { + using ArrayNoExtentType = int[]; + static_assert(!AZStd::invocable); + } + + TEST_F(RangesTestFixture, RangesData_Compiles_WithMemberOverload) + { + constexpr AZStd::string_view strView; + EXPECT_EQ(strView.data(), AZStd::ranges::data(strView)); + } + + TEST_F(RangesTestFixture, RangesData_Compiles_WithADL) + { + RangeLikeCustomizationPoint rangeLike; + + EXPECT_EQ(&rangeLike, AZStd::ranges::data(rangeLike)); + } + + // range access - cdata + TEST_F(RangesTestFixture, RangesCData_Compiles_WithExtentArray) + { + using ArrayExtentType = int[5]; + + constexpr ArrayExtentType extentArray{}; + EXPECT_EQ(extentArray, AZStd::ranges::cdata(extentArray)); + } + + TEST_F(RangesTestFixture, RangesCData_DoesNotCompile_WithNoExtentArray) + { + using ArrayNoExtentType = int[]; + static_assert(!AZStd::invocable); + } + + TEST_F(RangesTestFixture, RangesCData_Compiles_WithMemberOverload) + { + constexpr AZStd::string_view strView; + EXPECT_EQ(strView.data(), AZStd::ranges::cdata(strView)); + } + + TEST_F(RangesTestFixture, RangesCData_Compiles_WithADL) + { + RangeLikeCustomizationPoint rangeLike; + + EXPECT_EQ(&rangeLike, AZStd::ranges::cdata(rangeLike)); + } + + // Ranges TypeTraits Test + TEST_F(RangesTestFixture, RangesTypeTraits_Compiles) + { + // string_view + static_assert(AZStd::same_as, const char*>); + static_assert(AZStd::same_as, const char*>); + static_assert(AZStd::same_as, ptrdiff_t>); + static_assert(AZStd::same_as, size_t>); + static_assert(AZStd::same_as, char>); + static_assert(AZStd::same_as, const char&>); + static_assert(AZStd::same_as, const char&&>); + + // string + static_assert(AZStd::same_as, char*>); + static_assert(AZStd::same_as, char*>); + static_assert(AZStd::same_as, ptrdiff_t>); + static_assert(AZStd::same_as, size_t>); + static_assert(AZStd::same_as, char>); + static_assert(AZStd::same_as, char&>); + static_assert(AZStd::same_as, char&&>); + + // int array type + using ArrayExtentType = int[5]; + static_assert(AZStd::same_as, int*>); + static_assert(AZStd::same_as, int*>); + static_assert(AZStd::same_as, ptrdiff_t>); + static_assert(AZStd::same_as, size_t>); + static_assert(AZStd::same_as, int>); + static_assert(AZStd::same_as, int&>); + static_assert(AZStd::same_as, int&&>); + + // RangeLikeCustomizationPoint type which specializes several range functions + static_assert(AZStd::same_as, RangeLikeCustomizationPoint*>); + static_assert(AZStd::same_as, RangeLikeCustomizationPoint*>); + static_assert(AZStd::same_as, ptrdiff_t>); + static_assert(AZStd::same_as, size_t>); + static_assert(AZStd::same_as, RangeLikeCustomizationPoint>); + static_assert(AZStd::same_as, RangeLikeCustomizationPoint&>); + static_assert(AZStd::same_as, RangeLikeCustomizationPoint&&>); + } + + // Ranges Concepts Test + TEST_F(RangesTestFixture, RangesConcepts_Compiles) + { + using ArrayExtentType = int[5]; + // concept - range + static_assert(AZStd::ranges::range); + static_assert(AZStd::ranges::range); + static_assert(AZStd::ranges::range); + static_assert(!AZStd::ranges::range); + + // concept - sized_range + static_assert(AZStd::ranges::sized_range); + static_assert(AZStd::ranges::sized_range); + // Path classes do not have a size() function so they are not a sized_range + static_assert(!AZStd::ranges::sized_range); + + // concept - borrowed_range + static_assert(AZStd::ranges::borrowed_range); + static_assert(AZStd::ranges::borrowed_range); + static_assert(!AZStd::ranges::borrowed_range); + + // concept - output_range + static_assert(AZStd::ranges::output_range); + static_assert(!AZStd::ranges::output_range); + + // concept - input_range + static_assert(AZStd::ranges::input_range>); + static_assert(AZStd::ranges::input_range); + static_assert(AZStd::ranges::input_range); + + // concept - forward_range + static_assert(AZStd::ranges::forward_range>); + static_assert(AZStd::ranges::forward_range); + static_assert(AZStd::ranges::forward_range); + + // concept - bidirectional_range + static_assert(AZStd::ranges::bidirectional_range>); + static_assert(AZStd::ranges::bidirectional_range); + static_assert(AZStd::ranges::bidirectional_range); + + // concept - random_access_range + static_assert(!AZStd::ranges::random_access_range>); + static_assert(AZStd::ranges::random_access_range>); + static_assert(AZStd::ranges::random_access_range); + static_assert(AZStd::ranges::random_access_range); + + // concept - contiguous_range + static_assert(!AZStd::ranges::contiguous_range>); + static_assert(AZStd::ranges::contiguous_range); + static_assert(AZStd::ranges::contiguous_range); + + // concept - common_range + static_assert(AZStd::ranges::common_range); + static_assert(AZStd::ranges::common_range>); + static_assert(AZStd::ranges::common_range>); + static_assert(AZStd::ranges::common_range); + static_assert(AZStd::ranges::common_range); + + // concept - view + static_assert(AZStd::ranges::view); + static_assert(!AZStd::ranges::view); + + // concept - viewable_range + static_assert(AZStd::ranges::viewable_range); + static_assert(AZStd::ranges::viewable_range); + static_assert(!AZStd::ranges::viewable_range); + } + + // Ranges iterator operations + TEST_F(RangesTestFixture, RangesAdvance_PositiveDifference_Succeeds) + { + AZStd::string_view testString{ "Hello World" }; + auto strIter = testString.begin(); + + // difference overload + AZStd::ranges::advance(strIter, 5); + ASSERT_NE(testString.end(), strIter); + EXPECT_EQ(' ', *strIter); + + // bound overload + AZStd::ranges::advance(strIter, testString.end()); + EXPECT_EQ(testString.end(), strIter); + + // difference + bound overload + strIter = testString.begin(); + ptrdiff_t charactersToTraverse = 20; + EXPECT_EQ(charactersToTraverse - testString.size(), AZStd::ranges::advance(strIter, charactersToTraverse, testString.end())); + EXPECT_EQ(testString.end(), strIter); + + strIter = testString.begin(); + charactersToTraverse = 5; + EXPECT_EQ(0, AZStd::ranges::advance(strIter, charactersToTraverse, testString.end())); + ASSERT_NE(testString.end(), strIter); + EXPECT_EQ(' ', *strIter); + } + + TEST_F(RangesTestFixture, RangesAdvance_NegativeDifference_Succeeds) + { + AZStd::string_view testString{ "Hello World" }; + auto strIter = testString.end(); + + // difference overload + AZStd::ranges::advance(strIter, -5); + ASSERT_NE(testString.end(), strIter); + EXPECT_EQ('W', *strIter); + + // difference + bound overload + strIter = testString.end(); + ptrdiff_t charactersToTraverse = -20; + EXPECT_EQ(charactersToTraverse + testString.size(), AZStd::ranges::advance(strIter, charactersToTraverse, testString.begin())); + EXPECT_EQ(testString.begin(), strIter); + + strIter = testString.end(); + charactersToTraverse = -5; + EXPECT_EQ(0, AZStd::ranges::advance(strIter, charactersToTraverse, testString.begin())); + ASSERT_NE(testString.end(), strIter); + ASSERT_NE(testString.begin(), strIter); + EXPECT_EQ('W', *strIter); + } + + TEST_F(RangesTestFixture, RangesDistance_Succeeds) + { + AZStd::string_view testString{ "Hello World" }; + EXPECT_EQ(testString.size(), AZStd::ranges::distance(testString)); + EXPECT_EQ(testString.size(), AZStd::ranges::distance(testString.begin(), testString.end())); + + AZStd::list testList{ 'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd' }; + EXPECT_EQ(testList.size(), AZStd::ranges::distance(testList)); + EXPECT_EQ(testList.size(), AZStd::ranges::distance(testList.begin(), testList.end())); + } + + TEST_F(RangesTestFixture, RangesNext_Succeeds) + { + AZStd::string_view testString{ "Hello World" }; + auto strIter = testString.begin(); + auto boundIter = testString.begin() + 5; + // single increment + EXPECT_EQ(testString.begin() + 1, AZStd::ranges::next(strIter)); + // increment by value + strIter = testString.begin(); + EXPECT_EQ(testString.begin() + 5, AZStd::ranges::next(strIter, 5)); + // increment until bound + strIter = testString.begin(); + EXPECT_EQ(testString.begin() + 5, AZStd::ranges::next(strIter, boundIter)); + // increment by value up until bound + strIter = testString.begin(); + EXPECT_EQ(testString.begin() + 5, AZStd::ranges::next(strIter, 10, boundIter)); + strIter = testString.begin(); + EXPECT_EQ(testString.begin() + 4, AZStd::ranges::next(strIter, 4, boundIter)); + } + + TEST_F(RangesTestFixture, RangesPrev_Succeeds) + { + AZStd::string_view testString{ "Hello World" }; + auto strIter = testString.end(); + auto boundIter = testString.end() - 5; + // single decrement + EXPECT_EQ(testString.end() - 1, AZStd::ranges::prev(strIter)); + // decrement by value + strIter = testString.end(); + EXPECT_EQ(testString.end() - 5, AZStd::ranges::prev(strIter, 5)); + // decrement by value up until bound + strIter = testString.end(); + EXPECT_EQ(testString.end() - 5, AZStd::ranges::prev(strIter, 10, boundIter)); + strIter = testString.end(); + EXPECT_EQ(testString.end() - 4, AZStd::ranges::prev(strIter, 4, boundIter)); + } +} diff --git a/Code/Framework/AzCore/Tests/AZStd/SpanTests.cpp b/Code/Framework/AzCore/Tests/AZStd/SpanTests.cpp new file mode 100644 index 0000000000..f9861ae1f2 --- /dev/null +++ b/Code/Framework/AzCore/Tests/AZStd/SpanTests.cpp @@ -0,0 +1,249 @@ +/* + * 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 + +namespace UnitTest +{ + class SpanTestFixture + : public ScopedAllocatorSetupFixture + {}; + + // range access + TEST_F(SpanTestFixture, IsConstructibleWithContiguousRangeLikeContainers) + { + constexpr AZStd::string_view testStringView{ "Foo" }; + AZStd::string testString{ "Foo" }; + AZStd::vector testVector{ 'F', 'o', 'o' }; + AZStd::fixed_vector testFixedVector{ 'F', 'o', 'o' }; + AZStd::array testStdArray{ 'F', 'o', 'o' }; + const char testCArray[]{ 'F', 'o', 'o' }; + + constexpr AZStd::span stringViewSpan(testStringView); + static_assert(stringViewSpan.data() == testStringView.data()); + + AZStd::span testStringSpan(testString); + EXPECT_EQ(testStringSpan.data(), testString.data()); + + AZStd::span testVectorSpan(testVector); + EXPECT_EQ(testVectorSpan.data(), testVector.data()); + + AZStd::span testFixedVectorSpan(testFixedVector); + EXPECT_EQ(testFixedVectorSpan.data(), testFixedVector.data()); + + AZStd::span testStdArraySpan(testStdArray); + EXPECT_EQ(testStdArraySpan.data(), testStdArray.data()); + + AZStd::span testCArraySpan(testCArray); + EXPECT_EQ(AZStd::data(testCArray), testCArraySpan.data()); + } + + TEST_F(SpanTestFixture, IsConstructibleWithContiguousIterators) + { + constexpr AZStd::string_view testStringView{ "Foo" }; + AZStd::string testString{ "Foo" }; + AZStd::vector testVector{ 'F', 'o', 'o' }; + AZStd::fixed_vector testFixedVector{ 'F', 'o', 'o' }; + AZStd::array testStdArray{ 'F', 'o', 'o' }; + const char testCArray[]{ 'F', 'o', 'o' }; + + constexpr AZStd::span stringViewSpan(testStringView.begin(), testStringView.end()); + static_assert(stringViewSpan.data() == testStringView.data()); + + AZStd::span testStringSpan(testString.begin(), testString.end()); + EXPECT_EQ(testStringSpan.data(), testString.data()); + + AZStd::span testVectorSpan(testVector.begin(), testVector.end()); + EXPECT_EQ(testVectorSpan.data(), testVector.data()); + + AZStd::span testFixedVectorSpan(testFixedVector.begin(), testFixedVector.end()); + EXPECT_EQ(testFixedVectorSpan.data(), testFixedVector.data()); + + AZStd::span testStdArraySpan(testStdArray.begin(), testStdArray.end()); + EXPECT_EQ(testStdArraySpan.data(), testStdArray.data()); + + AZStd::span testCArraySpan(AZStd::begin(testCArray), AZStd::end(testCArray)); + EXPECT_EQ(AZStd::data(testCArray), testCArraySpan.data()); + } + + TEST_F(SpanTestFixture, ObserverMethods_ReturnsCorrectValues) + { + AZStd::vector intVector{ 4, 5, 6, 1, 7 }; + + AZStd::span intSpan(intVector); + + EXPECT_FALSE(intSpan.empty()); + EXPECT_EQ(intVector.size(), intSpan.size()); + EXPECT_EQ(intSpan.size() * sizeof(int), intSpan.size_bytes()); + + intSpan = {}; + + EXPECT_TRUE(intSpan.empty()); + EXPECT_EQ(0, intSpan.size()); + EXPECT_EQ(0, intSpan.size_bytes()); + } + + TEST_F(SpanTestFixture, ElementAccessorMethods_Succeeds) + { + AZStd::vector intVector{ 4, 5, 6, 1, 7 }; + + AZStd::span intSpan(intVector); + + EXPECT_EQ(intVector.data(), intSpan.data()); + EXPECT_EQ(4, intSpan.front()); + EXPECT_EQ(7, intSpan.back()); + EXPECT_EQ(6, intSpan[2]); + + // Create subspan from elements 1 .. end - 1 + intSpan = intSpan.subspan(1, intSpan.size() - 2); + EXPECT_NE(intVector.data(), intSpan.data()); + EXPECT_EQ(5, intSpan.front()); + EXPECT_EQ(1, intSpan.back()); + EXPECT_EQ(6, intSpan[1]); + } + + TEST_F(SpanTestFixture, Supspan_Returns_Subview_Succeeds) + { + AZStd::vector intVector{ 4, 5, 6, 1, 7 }; + + AZStd::span intSpan(intVector); + + // dynamic_extent subspan with count + auto dynamicIntSubSpan = intSpan.subspan(1, 2); + ASSERT_EQ(2, dynamicIntSubSpan.size()); + EXPECT_EQ(5, dynamicIntSubSpan[0]); + EXPECT_EQ(6, dynamicIntSubSpan[1]); + + // dynamic_extent subspan without count + dynamicIntSubSpan = intSpan.subspan(1); + ASSERT_EQ(4, dynamicIntSubSpan.size()); + EXPECT_EQ(5, dynamicIntSubSpan[0]); + EXPECT_EQ(6, dynamicIntSubSpan[1]); + EXPECT_EQ(1, dynamicIntSubSpan[2]); + EXPECT_EQ(7, dynamicIntSubSpan[3]); + + // template subspan with count + auto templateIntSubSpan1 = intSpan.subspan<1, 3>(); + static_assert(decltype(templateIntSubSpan1)::extent == 3); + ASSERT_EQ(3, templateIntSubSpan1.size()); + EXPECT_EQ(5, templateIntSubSpan1[0]); + EXPECT_EQ(6, templateIntSubSpan1[1]); + EXPECT_EQ(1, templateIntSubSpan1[2]); + + // template subspan without count + auto templateIntSubSpan2 = intSpan.subspan<1>(); + static_assert(decltype(templateIntSubSpan2)::extent == AZStd::dynamic_extent); + ASSERT_EQ(4, templateIntSubSpan2.size()); + EXPECT_EQ(5, templateIntSubSpan2[0]); + EXPECT_EQ(6, templateIntSubSpan2[1]); + EXPECT_EQ(1, templateIntSubSpan2[2]); + EXPECT_EQ(7, templateIntSubSpan2[3]); + + // get subspan of fixed extent span without count + auto subSpanOfSubSpan = templateIntSubSpan1.subspan<1>(); + static_assert(decltype(subSpanOfSubSpan)::extent == 2); + ASSERT_EQ(2, subSpanOfSubSpan.size()); + EXPECT_EQ(6, subSpanOfSubSpan[0]); + EXPECT_EQ(1, subSpanOfSubSpan[1]); + } + + TEST_F(SpanTestFixture, FirstMethod_Returns_FirstCountElementsOfSpan) + { + constexpr size_t vectorElementCount = 5; + AZStd::vector intVector{ 4, 5, 6, 1, 7 }; + + AZStd::span intSpan(intVector); + + { + // No templated first function + auto prefixSpan = intSpan.first(3); + ASSERT_EQ(3, prefixSpan.size()); + EXPECT_EQ(4, prefixSpan[0]); + EXPECT_EQ(5, prefixSpan[1]); + EXPECT_EQ(6, prefixSpan[2]); + + auto prefixSpanRedux = prefixSpan.first(1); + ASSERT_EQ(1, prefixSpanRedux.size()); + EXPECT_EQ(4, prefixSpanRedux[0]); + + // Test failure of preconditions by requesting more + // elements thant stored in the span + AZ_TEST_START_TRACE_SUPPRESSION; + intSpan.first(intSpan.size() + 1); + AZ_TEST_STOP_TRACE_SUPPRESSION(1); + } + + { + // templated first function + auto prefixSpan = intSpan.first<3>(); + static_assert(decltype(prefixSpan)::extent == 3); + ASSERT_EQ(3, prefixSpan.size()); + EXPECT_EQ(4, prefixSpan[0]); + EXPECT_EQ(5, prefixSpan[1]); + EXPECT_EQ(6, prefixSpan[2]); + + auto prefixSpanRedux = prefixSpan.first<1>(); + ASSERT_EQ(1, prefixSpanRedux.size()); + EXPECT_EQ(4, prefixSpanRedux[0]); + + // Test failure of preconditions by requesting more + // elements thant stored in the span + AZ_TEST_START_TRACE_SUPPRESSION; + intSpan.first(); + AZ_TEST_STOP_TRACE_SUPPRESSION(1); + } + } + + TEST_F(SpanTestFixture, LastCountElementsOfSpan) + { + constexpr size_t vectorElementCount = 5; + AZStd::vector intVector{ 4, 5, 6, 1, 7 }; + + AZStd::span intSpan(intVector); + + { + // No templated last function + auto suffixSpan = intSpan.last(3); + ASSERT_EQ(3, suffixSpan.size()); + EXPECT_EQ(6, suffixSpan[0]); + EXPECT_EQ(1, suffixSpan[1]); + EXPECT_EQ(7, suffixSpan[2]); + + auto suffixSpanRedux = suffixSpan.last(1); + ASSERT_EQ(1, suffixSpanRedux.size()); + EXPECT_EQ(7, suffixSpanRedux[0]); + + // Test failure of preconditions by requesting more + // elements thant stored in the span + AZ_TEST_START_TRACE_SUPPRESSION; + intSpan.last(intSpan.size() + 1); + AZ_TEST_STOP_TRACE_SUPPRESSION(1); + } + + { + // templated last function + auto suffixSpan = intSpan.last<3>(); + static_assert(decltype(suffixSpan)::extent == 3); + ASSERT_EQ(3, suffixSpan.size()); + EXPECT_EQ(6, suffixSpan[0]); + EXPECT_EQ(1, suffixSpan[1]); + EXPECT_EQ(7, suffixSpan[2]); + + auto suffixSpanRedux = suffixSpan.last<1>(); + ASSERT_EQ(1, suffixSpanRedux.size()); + EXPECT_EQ(7, suffixSpanRedux[0]); + + // Test failure of preconditions by requesting more + // elements thant stored in the span + AZ_TEST_START_TRACE_SUPPRESSION; + intSpan.last(); + AZ_TEST_STOP_TRACE_SUPPRESSION(1); + } + } +} diff --git a/Code/Framework/AzCore/Tests/AZStd/TypeTraits.cpp b/Code/Framework/AzCore/Tests/AZStd/TypeTraits.cpp index aeba048d69..d0f34d14a0 100644 --- a/Code/Framework/AzCore/Tests/AZStd/TypeTraits.cpp +++ b/Code/Framework/AzCore/Tests/AZStd/TypeTraits.cpp @@ -45,197 +45,197 @@ namespace UnitTest // Primary type categories: // alignment_of and align_to - AZ_TEST_STATIC_ASSERT(alignment_of::value == 4); - AZ_TEST_STATIC_ASSERT(alignment_of::value == 1); + static_assert(alignment_of::value == 4); + static_assert(alignment_of::value == 1); - AZ_TEST_STATIC_ASSERT(alignment_of::value == 16); - aligned_storage::type alignedArray; + static_assert(alignment_of::value == 16); + aligned_storage::type alignedArray; AZ_TEST_ASSERT((((AZStd::size_t)&alignedArray) & 15) == 0); - AZ_TEST_STATIC_ASSERT((alignment_of< aligned_storage::type >::value) == 8); - AZ_TEST_STATIC_ASSERT(sizeof(aligned_storage::type) == 16); + static_assert((alignment_of< aligned_storage::type >::value) == 8); + static_assert(sizeof(aligned_storage::type) == 16); // is_void - AZ_TEST_STATIC_ASSERT(is_void::value == false); - AZ_TEST_STATIC_ASSERT(is_void::value == true); - AZ_TEST_STATIC_ASSERT(is_void::value == true); - AZ_TEST_STATIC_ASSERT(is_void::value == true); - AZ_TEST_STATIC_ASSERT(is_void::value == true); + static_assert(is_void::value == false); + static_assert(is_void::value == true); + static_assert(is_void::value == true); + static_assert(is_void::value == true); + static_assert(is_void::value == true); // is_integral - AZ_TEST_STATIC_ASSERT(is_integral::value == true); - AZ_TEST_STATIC_ASSERT(is_integral::value == true); - AZ_TEST_STATIC_ASSERT(is_integral::value == true); - AZ_TEST_STATIC_ASSERT(is_integral::value == true); - AZ_TEST_STATIC_ASSERT(is_integral::value == true); - AZ_TEST_STATIC_ASSERT(is_integral::value == true); - AZ_TEST_STATIC_ASSERT(is_integral::value == true); - AZ_TEST_STATIC_ASSERT(is_integral::value == true); - AZ_TEST_STATIC_ASSERT(is_integral::value == true); - AZ_TEST_STATIC_ASSERT(is_integral::value == true); - //AZ_TEST_STATIC_ASSERT(is_integral::value == true); + static_assert(is_integral::value == true); + static_assert(is_integral::value == true); + static_assert(is_integral::value == true); + static_assert(is_integral::value == true); + static_assert(is_integral::value == true); + static_assert(is_integral::value == true); + static_assert(is_integral::value == true); + static_assert(is_integral::value == true); + static_assert(is_integral::value == true); + static_assert(is_integral::value == true); + //static_assert(is_integral::value == true); - AZ_TEST_STATIC_ASSERT(is_integral::value == true); - AZ_TEST_STATIC_ASSERT(is_integral::value == true); - AZ_TEST_STATIC_ASSERT(is_integral::value == true); - AZ_TEST_STATIC_ASSERT(is_integral::value == true); - AZ_TEST_STATIC_ASSERT(is_integral::value == true); - AZ_TEST_STATIC_ASSERT(is_integral::value == true); - AZ_TEST_STATIC_ASSERT(is_integral::value == true); - AZ_TEST_STATIC_ASSERT(is_integral::value == true); - AZ_TEST_STATIC_ASSERT(is_integral::value == true); - AZ_TEST_STATIC_ASSERT(is_integral::value == true); - AZ_TEST_STATIC_ASSERT(is_integral::value == true); - AZ_TEST_STATIC_ASSERT(is_integral::value == true); + static_assert(is_integral::value == true); + static_assert(is_integral::value == true); + static_assert(is_integral::value == true); + static_assert(is_integral::value == true); + static_assert(is_integral::value == true); + static_assert(is_integral::value == true); + static_assert(is_integral::value == true); + static_assert(is_integral::value == true); + static_assert(is_integral::value == true); + static_assert(is_integral::value == true); + static_assert(is_integral::value == true); + static_assert(is_integral::value == true); - AZ_TEST_STATIC_ASSERT(is_integral::value == false); - AZ_TEST_STATIC_ASSERT(is_integral::value == false); - AZ_TEST_STATIC_ASSERT(is_integral::value == false); + static_assert(is_integral::value == false); + static_assert(is_integral::value == false); + static_assert(is_integral::value == false); // is_floating_point - AZ_TEST_STATIC_ASSERT(is_floating_point::value == false); - AZ_TEST_STATIC_ASSERT(is_floating_point::value == true); - AZ_TEST_STATIC_ASSERT(is_floating_point::value == true); - AZ_TEST_STATIC_ASSERT(is_floating_point::value == true); - AZ_TEST_STATIC_ASSERT(is_floating_point::value == true); + static_assert(is_floating_point::value == false); + static_assert(is_floating_point::value == true); + static_assert(is_floating_point::value == true); + static_assert(is_floating_point::value == true); + static_assert(is_floating_point::value == true); // is_array - AZ_TEST_STATIC_ASSERT(is_array::value == false); - AZ_TEST_STATIC_ASSERT(is_array::value == true); - AZ_TEST_STATIC_ASSERT(is_array::value == true); - AZ_TEST_STATIC_ASSERT(is_array::value == true); - AZ_TEST_STATIC_ASSERT(is_array::value == true); + static_assert(is_array::value == false); + static_assert(is_array::value == true); + static_assert(is_array::value == true); + static_assert(is_array::value == true); + static_assert(is_array::value == true); - AZ_TEST_STATIC_ASSERT(is_array::value == true); - AZ_TEST_STATIC_ASSERT(is_array::value == true); - AZ_TEST_STATIC_ASSERT(is_array::value == true); - AZ_TEST_STATIC_ASSERT(is_array::value == true); + static_assert(is_array::value == true); + static_assert(is_array::value == true); + static_assert(is_array::value == true); + static_assert(is_array::value == true); // is_pointer - AZ_TEST_STATIC_ASSERT(is_pointer::value == false); - AZ_TEST_STATIC_ASSERT(is_pointer::value == true); - AZ_TEST_STATIC_ASSERT(is_pointer::value == true); - AZ_TEST_STATIC_ASSERT(is_pointer::value == true); - AZ_TEST_STATIC_ASSERT(is_pointer::value == true); + static_assert(is_pointer::value == false); + static_assert(is_pointer::value == true); + static_assert(is_pointer::value == true); + static_assert(is_pointer::value == true); + static_assert(is_pointer::value == true); // is_reference - AZ_TEST_STATIC_ASSERT(is_reference::value == false); - AZ_TEST_STATIC_ASSERT(is_reference::value == true); - AZ_TEST_STATIC_ASSERT(is_reference::value == true); - AZ_TEST_STATIC_ASSERT(is_reference::value == true); - AZ_TEST_STATIC_ASSERT(is_reference::value == true); + static_assert(is_reference::value == false); + static_assert(is_reference::value == true); + static_assert(is_reference::value == true); + static_assert(is_reference::value == true); + static_assert(is_reference::value == true); // is_member_object_pointer - AZ_TEST_STATIC_ASSERT(is_member_object_pointer::value == false); - AZ_TEST_STATIC_ASSERT(is_member_object_pointer::value == false); - AZ_TEST_STATIC_ASSERT(is_member_object_pointer::value == true); + static_assert(is_member_object_pointer::value == false); + static_assert(is_member_object_pointer::value == false); + static_assert(is_member_object_pointer::value == true); // is_member_function_pointer - AZ_TEST_STATIC_ASSERT(is_member_function_pointer::value == false); - AZ_TEST_STATIC_ASSERT(is_member_function_pointer::value == true); - AZ_TEST_STATIC_ASSERT(is_member_function_pointer::value == false); - AZ_TEST_STATIC_ASSERT((is_member_function_pointer::value)); - AZ_TEST_STATIC_ASSERT((is_member_function_pointer::value)); - AZ_TEST_STATIC_ASSERT((is_member_function_pointer::value)); - AZ_TEST_STATIC_ASSERT((is_member_function_pointer::value)); - AZ_TEST_STATIC_ASSERT((is_member_function_pointer::value)); - AZ_TEST_STATIC_ASSERT((is_member_function_pointer::value)); - AZ_TEST_STATIC_ASSERT((is_member_function_pointer::value)); - AZ_TEST_STATIC_ASSERT((is_member_function_pointer::value)); - AZ_TEST_STATIC_ASSERT((is_member_function_pointer::value)); + static_assert(is_member_function_pointer::value == false); + static_assert(is_member_function_pointer::value == true); + static_assert(is_member_function_pointer::value == false); + static_assert((is_member_function_pointer::value)); + static_assert((is_member_function_pointer::value)); + static_assert((is_member_function_pointer::value)); + static_assert((is_member_function_pointer::value)); + static_assert((is_member_function_pointer::value)); + static_assert((is_member_function_pointer::value)); + static_assert((is_member_function_pointer::value)); + static_assert((is_member_function_pointer::value)); + static_assert((is_member_function_pointer::value)); // is_enum - AZ_TEST_STATIC_ASSERT(is_enum::value == false); - AZ_TEST_STATIC_ASSERT(is_enum::value == false); - AZ_TEST_STATIC_ASSERT(is_enum::value == true); + static_assert(is_enum::value == false); + static_assert(is_enum::value == false); + static_assert(is_enum::value == true); // is_union - AZ_TEST_STATIC_ASSERT(is_union::value == false); - AZ_TEST_STATIC_ASSERT(is_union::value == false); - AZ_TEST_STATIC_ASSERT(is_union::value == true); + static_assert(is_union::value == false); + static_assert(is_union::value == false); + static_assert(is_union::value == true); // is_class - AZ_TEST_STATIC_ASSERT(is_class::value == false); - AZ_TEST_STATIC_ASSERT(is_class::value == true); - AZ_TEST_STATIC_ASSERT(is_class::value == true); + static_assert(is_class::value == false); + static_assert(is_class::value == true); + static_assert(is_class::value == true); // is_function - AZ_TEST_STATIC_ASSERT(is_function::value == false); - AZ_TEST_STATIC_ASSERT(is_function::value == false); - AZ_TEST_STATIC_ASSERT(is_function::value == true); + static_assert(is_function::value == false); + static_assert(is_function::value == false); + static_assert(is_function::value == true); ////////////////////////////////////////////////////////////////////////// // composite type categories: // is_arithmetic - AZ_TEST_STATIC_ASSERT(is_arithmetic::value == false); - AZ_TEST_STATIC_ASSERT(is_arithmetic::value == true); - AZ_TEST_STATIC_ASSERT(is_arithmetic::value == true); + static_assert(is_arithmetic::value == false); + static_assert(is_arithmetic::value == true); + static_assert(is_arithmetic::value == true); // is_fundamental - AZ_TEST_STATIC_ASSERT(is_fundamental::value == false); - AZ_TEST_STATIC_ASSERT(is_fundamental::value == true); - AZ_TEST_STATIC_ASSERT(is_fundamental::value == true); - AZ_TEST_STATIC_ASSERT(is_fundamental::value == true); + static_assert(is_fundamental::value == false); + static_assert(is_fundamental::value == true); + static_assert(is_fundamental::value == true); + static_assert(is_fundamental::value == true); // is_object - AZ_TEST_STATIC_ASSERT(is_object::value == true); - AZ_TEST_STATIC_ASSERT(is_object::value == false); - AZ_TEST_STATIC_ASSERT(is_object::value == false); - AZ_TEST_STATIC_ASSERT(is_object::value == false); + static_assert(is_object::value == true); + static_assert(is_object::value == false); + static_assert(is_object::value == false); + static_assert(is_object::value == false); // is_scalar - AZ_TEST_STATIC_ASSERT(is_scalar::value == false); - AZ_TEST_STATIC_ASSERT(is_scalar::value == true); - AZ_TEST_STATIC_ASSERT(is_scalar::value == true); - AZ_TEST_STATIC_ASSERT(is_scalar::value == true); + static_assert(is_scalar::value == false); + static_assert(is_scalar::value == true); + static_assert(is_scalar::value == true); + static_assert(is_scalar::value == true); // is_compound - AZ_TEST_STATIC_ASSERT(is_compound::value == false); - AZ_TEST_STATIC_ASSERT(is_compound::value == true); - AZ_TEST_STATIC_ASSERT(is_compound::value == true); - AZ_TEST_STATIC_ASSERT(is_compound::value == true); - AZ_TEST_STATIC_ASSERT(is_compound::value == true); - AZ_TEST_STATIC_ASSERT(is_compound::value == true); + static_assert(is_compound::value == false); + static_assert(is_compound::value == true); + static_assert(is_compound::value == true); + static_assert(is_compound::value == true); + static_assert(is_compound::value == true); + static_assert(is_compound::value == true); // is_member_pointer - AZ_TEST_STATIC_ASSERT(is_member_pointer::value == false); - AZ_TEST_STATIC_ASSERT(is_member_pointer::value == true); - AZ_TEST_STATIC_ASSERT(is_member_pointer::value == true); + static_assert(is_member_pointer::value == false); + static_assert(is_member_pointer::value == true); + static_assert(is_member_pointer::value == true); ////////////////////////////////////////////////////////////////////////// // type properties: // is_const - AZ_TEST_STATIC_ASSERT(is_const::value == false); - AZ_TEST_STATIC_ASSERT(is_const::value == false); - AZ_TEST_STATIC_ASSERT(is_const::value == true); - AZ_TEST_STATIC_ASSERT(is_const::value == true); + static_assert(is_const::value == false); + static_assert(is_const::value == false); + static_assert(is_const::value == true); + static_assert(is_const::value == true); // is_volatile - AZ_TEST_STATIC_ASSERT(is_volatile::value == false); - AZ_TEST_STATIC_ASSERT(is_volatile::value == false); - AZ_TEST_STATIC_ASSERT(is_volatile::value == true); - AZ_TEST_STATIC_ASSERT(is_volatile::value == true); + static_assert(is_volatile::value == false); + static_assert(is_volatile::value == false); + static_assert(is_volatile::value == true); + static_assert(is_volatile::value == true); // is_pod - AZ_TEST_STATIC_ASSERT(is_pod::value == true); - AZ_TEST_STATIC_ASSERT(is_pod::value == true); - AZ_TEST_STATIC_ASSERT(is_pod::value == false); - AZ_TEST_STATIC_ASSERT((is_pod< aligned_storage<30, 32>::type >::value) == true); + static_assert(is_pod::value == true); + static_assert(is_pod::value == true); + static_assert(is_pod::value == false); + static_assert((is_pod< aligned_storage<30, 32>::type >::value) == true); // is_empty - AZ_TEST_STATIC_ASSERT(is_empty::value == false); - AZ_TEST_STATIC_ASSERT(is_empty::value == true); - AZ_TEST_STATIC_ASSERT(is_empty::value == false); + static_assert(is_empty::value == false); + static_assert(is_empty::value == true); + static_assert(is_empty::value == false); // is_polymorphic - AZ_TEST_STATIC_ASSERT(is_polymorphic::value == false); - AZ_TEST_STATIC_ASSERT(is_polymorphic::value == true); + static_assert(is_polymorphic::value == false); + static_assert(is_polymorphic::value == true); // is_abstract - AZ_TEST_STATIC_ASSERT(is_abstract::value == false); - AZ_TEST_STATIC_ASSERT(is_abstract::value == true); + static_assert(is_abstract::value == false); + static_assert(is_abstract::value == true); // has_trivial_constructor static_assert(is_trivially_constructible_v); @@ -264,20 +264,20 @@ namespace UnitTest // has_nothrow_assign // is_signed - AZ_TEST_STATIC_ASSERT(is_signed::value == true); - AZ_TEST_STATIC_ASSERT(is_signed::value == false); - AZ_TEST_STATIC_ASSERT(is_signed::value == false); + static_assert(is_signed::value == true); + static_assert(is_signed::value == false); + static_assert(is_signed::value == false); static_assert(is_signed::value); // is_unsigned - AZ_TEST_STATIC_ASSERT(is_unsigned::value == false); - AZ_TEST_STATIC_ASSERT(is_unsigned::value == false); - AZ_TEST_STATIC_ASSERT(is_unsigned::value == true); - AZ_TEST_STATIC_ASSERT(is_unsigned::value == false); + static_assert(is_unsigned::value == false); + static_assert(is_unsigned::value == false); + static_assert(is_unsigned::value == true); + static_assert(is_unsigned::value == false); // true and false types - AZ_TEST_STATIC_ASSERT(true_type::value == true); - AZ_TEST_STATIC_ASSERT(false_type::value == false); + static_assert(true_type::value == true); + static_assert(false_type::value == false); //! function traits tests struct NotMyStruct @@ -290,7 +290,7 @@ namespace UnitTest { bool operator()(FunctionTestStruct&) const { return true; }; }; - + using PrimitiveFunctionPtr = int(*)(bool, float, double, AZ::u8, AZ::s8, AZ::u16, AZ::s16, AZ::u32, AZ::s32, AZ::u64, AZ::s64); using NotMyStructMemberPtr = int(NotMyStruct::*)(); using ComplexFunctionPtr = float(*)(MyEmptyStruct&, NotMyStructMemberPtr, MyUnion*); @@ -298,27 +298,27 @@ namespace UnitTest using MemberFunctionPtr = void(MyInterface::*)(int); using ConstMemberFunctionPtr = bool(FunctionTestStruct::*)(FunctionTestStruct&) const; - AZ_TEST_STATIC_ASSERT((AZStd::is_same::result_type, int>::value)); - AZ_TEST_STATIC_ASSERT((AZStd::is_same::get_arg_t<10>, AZ::s64>::value)); - AZ_TEST_STATIC_ASSERT((AZStd::is_same, AZ::u16>::value)); - AZ_TEST_STATIC_ASSERT((AZStd::function_traits::arity == 11)); - - AZ_TEST_STATIC_ASSERT((AZStd::is_same, float>::value)); - AZ_TEST_STATIC_ASSERT((AZStd::is_same, int(NotMyStruct::*)()>::value)); - AZ_TEST_STATIC_ASSERT((AZStd::function_traits::arity == 3)); + static_assert((AZStd::is_same::result_type, int>::value)); + static_assert((AZStd::is_same::get_arg_t<10>, AZ::s64>::value)); + static_assert((AZStd::is_same, AZ::u16>::value)); + static_assert((AZStd::function_traits::arity == 11)); - AZ_TEST_STATIC_ASSERT((AZStd::is_same::class_fp_type, void(MyInterface::*)(int)>::value)); - AZ_TEST_STATIC_ASSERT((AZStd::is_same::raw_fp_type, void(*)(int)>::value)); - AZ_TEST_STATIC_ASSERT((AZStd::is_same::class_type, MyInterface>::value)); - AZ_TEST_STATIC_ASSERT((AZStd::function_traits::arity == 1)); + static_assert((AZStd::is_same, float>::value)); + static_assert((AZStd::is_same, int(NotMyStruct::*)()>::value)); + static_assert((AZStd::function_traits::arity == 3)); - AZ_TEST_STATIC_ASSERT((AZStd::is_same::class_fp_type, bool(FunctionTestStruct::*)(FunctionTestStruct&) const> ::value)); - AZ_TEST_STATIC_ASSERT((AZStd::is_same::raw_fp_type, bool(*)(FunctionTestStruct&)> ::value)); - AZ_TEST_STATIC_ASSERT((AZStd::is_same::class_type, FunctionTestStruct>::value)); - AZ_TEST_STATIC_ASSERT((AZStd::is_same, FunctionTestStruct&>::value)); - AZ_TEST_STATIC_ASSERT((AZStd::function_traits::arity == 1)); - - AZ_TEST_STATIC_ASSERT((AZStd::is_same::class_fp_type, bool(FunctionTestStruct::*)(FunctionTestStruct&) const>::value)); + static_assert((AZStd::is_same::class_fp_type, void(MyInterface::*)(int)>::value)); + static_assert((AZStd::is_same::raw_fp_type, void(*)(int)>::value)); + static_assert((AZStd::is_same::class_type, MyInterface>::value)); + static_assert((AZStd::function_traits::arity == 1)); + + static_assert((AZStd::is_same::class_fp_type, bool(FunctionTestStruct::*)(FunctionTestStruct&) const> ::value)); + static_assert((AZStd::is_same::raw_fp_type, bool(*)(FunctionTestStruct&)> ::value)); + static_assert((AZStd::is_same::class_type, FunctionTestStruct>::value)); + static_assert((AZStd::is_same, FunctionTestStruct&>::value)); + static_assert((AZStd::function_traits::arity == 1)); + + static_assert((AZStd::is_same::class_fp_type, bool(FunctionTestStruct::*)(FunctionTestStruct&) const>::value)); auto lambdaFunction = [](FunctionTestStruct, int) -> bool { @@ -326,16 +326,16 @@ namespace UnitTest }; using LambdaType = decltype(lambdaFunction); - AZ_TEST_STATIC_ASSERT((AZStd::is_same::raw_fp_type, bool(*)(FunctionTestStruct, int)>::value)); - AZ_TEST_STATIC_ASSERT((AZStd::is_same::class_fp_type, bool(LambdaType::*)(FunctionTestStruct, int) const>::value)); - AZ_TEST_STATIC_ASSERT((AZStd::function_traits::arity == 2)); + static_assert((AZStd::is_same::raw_fp_type, bool(*)(FunctionTestStruct, int)>::value)); + static_assert((AZStd::is_same::class_fp_type, bool(LambdaType::*)(FunctionTestStruct, int) const>::value)); + static_assert((AZStd::function_traits::arity == 2)); static_assert(AZStd::is_same::return_type, bool>::value, "Lambda result type should be bool"); AZStd::function stdFunction; using StdFunctionType = decay_t; - AZ_TEST_STATIC_ASSERT((AZStd::is_same::raw_fp_type, void(*)(LambdaType*, ComplexFunction&)>::value)); - AZ_TEST_STATIC_ASSERT((AZStd::function_traits::arity == 2)); - } + static_assert((AZStd::is_same::raw_fp_type, void(*)(LambdaType*, ComplexFunction&)>::value)); + static_assert((AZStd::function_traits::arity == 2)); + } struct ConstMethodTestStruct { @@ -343,145 +343,264 @@ namespace UnitTest void NonConstMethod() { } }; - AZ_TEST_STATIC_ASSERT((static_cast(function_traits::qual_flags) & static_cast(Internal::qualifier_flags::const_)) != 0); - AZ_TEST_STATIC_ASSERT((static_cast(function_traits::qual_flags) & static_cast(Internal::qualifier_flags::const_)) == 0); -} + static_assert((static_cast(function_traits::qual_flags)& static_cast(Internal::qualifier_flags::const_)) != 0); + static_assert((static_cast(function_traits::qual_flags)& static_cast(Internal::qualifier_flags::const_)) == 0); -TEST(TypeTraits, StdRemoveConstCompiles) -{ - static_assert(AZStd::is_same_v>, "C++11 std::remove_const_t has failed"); - static_assert(AZStd::is_same_v>, "C++11 std::remove_const_t has failed"); - static_assert(AZStd::is_same_v>, "C++11 std::remove_const_t has failed"); - static_assert(AZStd::is_same_v>, "C++11 std::remove_const_t has failed"); - static_assert(AZStd::is_same_v>, "C++11 std::remove_const_t has failed"); - static_assert(AZStd::is_same_v>>, "C++11 std::remove_const_t has failed"); -} - -TEST(TypeTraits, StdRemoveVolatileCompiles) -{ - static_assert(AZStd::is_same_v>, "C++11 std::remove_volatile_t has failed"); - static_assert(AZStd::is_same_v>, "C++11 std::remove_volatile_t has failed"); - static_assert(AZStd::is_same_v>, "C++11 std::remove_volatile_t has failed"); - static_assert(AZStd::is_same_v>, "C++11 std::remove_volatile_t has failed"); - static_assert(AZStd::is_same_v>, "C++11 std::remove_volatile_t has failed"); - static_assert(AZStd::is_same_v>, "C++11 std::remove_volatile_t has failed"); - static_assert(AZStd::is_same_v>>, "C++11 std::remove_volatile_t has failed"); -} - -TEST(TypeTraits, StdIsConstCompiles) -{ - static_assert(!AZStd::is_const_v, "C++11 std::is_const has failed"); - static_assert(AZStd::is_const_v, "C++11 std::is_const has failed"); - // references are never const - static_assert(!AZStd::is_const_v, "C++11 std::is_const has failed"); - // pointer checks for constness - static_assert(!AZStd::is_const_v, "C++11 std::is_const has failed"); - static_assert(AZStd::is_const_v, "C++11 std::is_const has failed"); - static_assert(AZStd::is_const_v, "C++11 std::is_const has failed"); -} - -TEST(TypeTraits, StdIsVolatileCompiles) -{ - static_assert(!AZStd::is_volatile_v, "C++11 std::is_volatile has failed"); - static_assert(AZStd::is_volatile_v, "C++11 std::is_volatile has failed"); - // references are never volatile - static_assert(!AZStd::is_volatile_v, "C++11 std::is_volatile has failed"); - // pointer checks for volatile - static_assert(!AZStd::is_volatile_v, "C++11 std::is_volatile has failed"); - static_assert(AZStd::is_volatile_v, "C++11 std::is_volatile has failed"); - static_assert(!AZStd::is_volatile_v, "C++11 std::is_volatile has failed"); - static_assert(AZStd::is_volatile_v, "C++11 std::is_volatile has failed"); -} - -TEST(TypeTraits, TemplateIsCopyConstructible_WithCopyConstructibleValueType_ReturnsTrue) -{ - static_assert(AZStd::Internal::template_is_copy_constructible>::value, ""); - static_assert(AZStd::Internal::template_is_copy_constructible>::value, ""); - static_assert(AZStd::Internal::template_is_copy_constructible>::value, ""); - static_assert(AZStd::Internal::template_is_copy_constructible>::value, ""); - static_assert(AZStd::Internal::template_is_copy_constructible>::value, ""); - static_assert(AZStd::Internal::template_is_copy_constructible>::value, ""); - static_assert(AZStd::Internal::template_is_copy_constructible>::value, ""); - static_assert(AZStd::Internal::template_is_copy_constructible>::value, ""); - static_assert(AZStd::Internal::template_is_copy_constructible>::value, ""); - static_assert(AZStd::Internal::template_is_copy_constructible>::value, ""); - static_assert(AZStd::Internal::template_is_copy_constructible>::value, ""); - static_assert(AZStd::Internal::template_is_copy_constructible>::value, ""); - - struct CopyableType + TEST(TypeTraits, StdRemoveConstCompiles) { - CopyableType() = default; - CopyableType(const CopyableType&) = default; - }; - static_assert(AZStd::Internal::template_is_copy_constructible::value, ""); -} + static_assert(AZStd::is_same_v>, "C++11 std::remove_const_t has failed"); + static_assert(AZStd::is_same_v>, "C++11 std::remove_const_t has failed"); + static_assert(AZStd::is_same_v>, "C++11 std::remove_const_t has failed"); + static_assert(AZStd::is_same_v>, "C++11 std::remove_const_t has failed"); + static_assert(AZStd::is_same_v>, "C++11 std::remove_const_t has failed"); + static_assert(AZStd::is_same_v>>, "C++11 std::remove_const_t has failed"); + } -TEST(TypeTraits, TemplateIsCopyConstructible_WithOutCopyConstructibleValueType_ReturnsFalse) -{ - static_assert(!AZStd::Internal::template_is_copy_constructible>>::value, ""); - static_assert(!AZStd::Internal::template_is_copy_constructible>>::value, ""); - static_assert(!AZStd::Internal::template_is_copy_constructible>>::value, ""); - static_assert(!AZStd::Internal::template_is_copy_constructible, int>>::value, ""); - static_assert(!AZStd::Internal::template_is_copy_constructible>>::value, ""); - static_assert(!AZStd::Internal::template_is_copy_constructible, int>>::value, ""); - static_assert(!AZStd::Internal::template_is_copy_constructible>>::value, ""); - static_assert(!AZStd::Internal::template_is_copy_constructible, int>>::value, ""); - static_assert(!AZStd::Internal::template_is_copy_constructible>>::value, ""); - static_assert(!AZStd::Internal::template_is_copy_constructible, int>>::value, ""); - static_assert(!AZStd::Internal::template_is_copy_constructible>>::value, ""); - static_assert(!AZStd::Internal::template_is_copy_constructible>>::value, ""); - static_assert(!AZStd::Internal::template_is_copy_constructible>>::value, ""); - static_assert(!AZStd::Internal::template_is_copy_constructible>>::value, ""); - static_assert(!AZStd::Internal::template_is_copy_constructible>>::value, ""); - static_assert(!AZStd::Internal::template_is_copy_constructible, int>>::value, ""); - static_assert(!AZStd::Internal::template_is_copy_constructible>>::value, ""); - - struct MoveOnly + TEST(TypeTraits, StdRemoveVolatileCompiles) { - MoveOnly() = default; - MoveOnly(const MoveOnly&) = delete; - MoveOnly(MoveOnly&&) = default; - }; - static_assert(!AZStd::Internal::template_is_copy_constructible::value, ""); -} + static_assert(AZStd::is_same_v>, "C++11 std::remove_volatile_t has failed"); + static_assert(AZStd::is_same_v>, "C++11 std::remove_volatile_t has failed"); + static_assert(AZStd::is_same_v>, "C++11 std::remove_volatile_t has failed"); + static_assert(AZStd::is_same_v>, "C++11 std::remove_volatile_t has failed"); + static_assert(AZStd::is_same_v>, "C++11 std::remove_volatile_t has failed"); + static_assert(AZStd::is_same_v>, "C++11 std::remove_volatile_t has failed"); + static_assert(AZStd::is_same_v>>, "C++11 std::remove_volatile_t has failed"); + } -TEST(TypeTraits, MakeSignedCompiles) -{ - static_assert(AZStd::is_same_v::type, AZ::s8>); - static_assert(AZStd::is_same_v, AZ::s8>); - static_assert(AZStd::is_same_v, AZ::s16>); - static_assert(AZStd::is_same_v, AZ::s16>); - static_assert(AZStd::is_same_v, AZ::s32>); - static_assert(AZStd::is_same_v, AZ::s32>); - static_assert(AZStd::is_same_v, AZ::s64>); - static_assert(AZStd::is_same_v, AZ::s64>); -} - -TEST(TypeTraits, MakeUnsignedCompiles) -{ - static_assert(AZStd::is_same_v::type, AZ::u8>); - static_assert(AZStd::is_same_v, AZ::u8>); - static_assert(AZStd::is_same_v, AZ::u16>); - static_assert(AZStd::is_same_v, AZ::u16>); - static_assert(AZStd::is_same_v, AZ::u32>); - static_assert(AZStd::is_same_v, AZ::u32>); - static_assert(AZStd::is_same_v, AZ::u64>); - static_assert(AZStd::is_same_v, AZ::u64>); -} - -// VS2017 workaround, calling decltype directly on the fully specialized aznumeric_cast template -// function fails with error C3556: 'aznumeric_cast': incorrect argument to 'decltype' -// So invoke the attempt to invoke function in a non-evaluated context and SFINAE to prevent a compile -// error -template -constexpr bool NumericCastInvocable = false; -template -constexpr bool NumericCastInvocable(AZStd::declval()))>> = true; -TEST(TypeTraits, NumericCastConversionOperatorCompiles) -{ - struct AzNumericCastConvertibleCompileTest + TEST(TypeTraits, StdIsConstCompiles) { - constexpr operator int() { return {}; }; - }; - static_assert(NumericCastInvocable, "aznumeric_cast conversion operator overload is should be compilable"); + static_assert(!AZStd::is_const_v, "C++11 std::is_const has failed"); + static_assert(AZStd::is_const_v, "C++11 std::is_const has failed"); + // references are never const + static_assert(!AZStd::is_const_v, "C++11 std::is_const has failed"); + // pointer checks for constness + static_assert(!AZStd::is_const_v, "C++11 std::is_const has failed"); + static_assert(AZStd::is_const_v, "C++11 std::is_const has failed"); + static_assert(AZStd::is_const_v, "C++11 std::is_const has failed"); + } + + TEST(TypeTraits, StdIsVolatileCompiles) + { + static_assert(!AZStd::is_volatile_v, "C++11 std::is_volatile has failed"); + static_assert(AZStd::is_volatile_v, "C++11 std::is_volatile has failed"); + // references are never volatile + static_assert(!AZStd::is_volatile_v, "C++11 std::is_volatile has failed"); + // pointer checks for volatile + static_assert(!AZStd::is_volatile_v, "C++11 std::is_volatile has failed"); + static_assert(AZStd::is_volatile_v, "C++11 std::is_volatile has failed"); + static_assert(!AZStd::is_volatile_v, "C++11 std::is_volatile has failed"); + static_assert(AZStd::is_volatile_v, "C++11 std::is_volatile has failed"); + } + + + struct CommonReferenceSpecializationTest + {}; +} + +namespace AZStd +{ + template