birkeh/o3de
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'main' of https://github.com/aws-lumberyard/o3de into Prefab/Create/PositionFix

Browse Source 
# Conflicts:
#	Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabPublicHandler.cpp
This commit is contained in:
daimini
2021-05-18 15:04:34 -07:00
parent bb458254a2 3182dc37c3
commit a4953a5204
428 changed files with 3167 additions and 29057 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.gitattributes
+8
View File
@@ -117,3 +117,11 @@
*.wem filter=lfs diff=lfs merge=lfs -text
*.wxs filter=lfs diff=lfs merge=lfs -text
*.zip filter=lfs diff=lfs merge=lfs -text
*.tbscene filter=lfs diff=lfs merge=lfs -text
*.spp filter=lfs diff=lfs merge=lfs -text
Gems/Atom/Tools/MaterialEditor/Assets/MaterialEditor/ViewportModels/Hermanubis.fbx filter=lfs diff=lfs merge=lfs -text
Gems/AtomLyIntegration/CommonFeatures/Assets/Objects/Lucy/Lucy_High.fbx filter=lfs diff=lfs merge=lfs -text
Gems/AtomLyIntegration/CommonFeatures/Assets/Objects/Lucy/Lucy_low.fbx filter=lfs diff=lfs merge=lfs -text
Gems/AtomLyIntegration/CommonFeatures/Assets/Objects/Lucy/.wip/marmoset_bake.tbscene filter=lfs diff=lfs merge=lfs -text
Gems/AtomLyIntegration/CommonFeatures/Assets/Objects/Lucy/.wip/Brass/brass_bake.spp filter=lfs diff=lfs merge=lfs -text
Gems/AtomLyIntegration/CommonFeatures/Assets/Objects/Lucy/.wip/stone/stone_bake.spp filter=lfs diff=lfs merge=lfs -text
AutomatedTesting/Gem/PythonTests/Blast/CMakeLists.txt
+25
View File
@@ -0,0 +1,25 @@
#
# All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
# its licensors.
#
# For complete copyright and license terms please see the LICENSE at the root of this
# distribution (the "License"). All use of this software is governed by the License,
# or, if provided, by the license below or the license accompanying this file. Do not
# remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#
if(PAL_TRAIT_BUILD_TESTS_SUPPORTED AND PAL_TRAIT_BUILD_HOST_TOOLS)
ly_add_pytest(
NAME AutomatedTesting::BlastTests
TEST_SUITE main
TEST_SERIAL TRUE
PATH ${CMAKE_CURRENT_LIST_DIR}/TestSuite_Active.py
TIMEOUT 1500
RUNTIME_DEPENDENCIES
Legacy::Editor
AZ::AssetProcessor
AutomatedTesting.Assets
COMPONENT Blast
)
endif()
AutomatedTesting/Gem/PythonTests/CMakeLists.txt
+19 -361
View File
@@ -15,388 +15,46 @@
ly_get_list_relative_pal_filename(pal_dir ${CMAKE_CURRENT_LIST_DIR}/Platform/${PAL_PLATFORM_NAME})
include(${pal_dir}/PAL_traits_${PAL_PLATFORM_NAME_LOWERCASE}.cmake)
## Asset pipeline ##
add_subdirectory(assetpipeline)
## Atom Renderer ##
add_subdirectory(atom_renderer)
## Physics ##
if(PAL_TRAIT_BUILD_TESTS_SUPPORTED AND PAL_TRAIT_BUILD_HOST_TOOLS)
ly_add_pytest(
NAME AutomatedTesting::PhysicsTests_Main
TEST_SUITE main
TEST_SERIAL
PATH ${CMAKE_CURRENT_LIST_DIR}/physics/TestSuite_Main.py
TIMEOUT 1500
RUNTIME_DEPENDENCIES
Legacy::Editor
AZ::AssetProcessor
AutomatedTesting.Assets
COMPONENT
Physics
)
ly_add_pytest(
NAME AutomatedTesting::PhysicsTests_Periodic
TEST_SUITE periodic
TEST_SERIAL
PATH ${CMAKE_CURRENT_LIST_DIR}/physics/TestSuite_Periodic.py
TIMEOUT 1500
RUNTIME_DEPENDENCIES
Legacy::Editor
AZ::AssetProcessor
AutomatedTesting.Assets
COMPONENT
Physics
)
ly_add_pytest(
NAME AutomatedTesting::PhysicsTests_Sandbox
TEST_SUITE sandbox
TEST_SERIAL
PATH ${CMAKE_CURRENT_LIST_DIR}/physics/TestSuite_Sandbox.py
TIMEOUT 1500
RUNTIME_DEPENDENCIES
Legacy::Editor
AZ::AssetProcessor
AutomatedTesting.Assets
COMPONENT
Physics
)
endif()
add_subdirectory(physics)
## ScriptCanvas ##
if(PAL_TRAIT_BUILD_TESTS_SUPPORTED AND PAL_TRAIT_BUILD_HOST_TOOLS)
ly_add_pytest(
NAME AutomatedTesting::ScriptCanvasTests
TEST_SUITE periodic
TEST_SERIAL
PATH ${CMAKE_CURRENT_LIST_DIR}/scripting/TestSuite_Active.py
TIMEOUT 1500
RUNTIME_DEPENDENCIES
Legacy::Editor
AZ::AssetProcessor
AutomatedTesting.Assets
COMPONENT
ScriptCanvas
)
ly_add_pytest(
NAME AutomatedTesting::ScriptCanvasTests_Sandbox
TEST_SUITE sandbox
TEST_SERIAL
PATH ${CMAKE_CURRENT_LIST_DIR}/scripting/TestSuite_Sandbox.py
TIMEOUT 1500
RUNTIME_DEPENDENCIES
Legacy::Editor
AZ::AssetProcessor
AutomatedTesting.Assets
)
endif()
add_subdirectory(scripting)
## White Box ##
if(PAL_TRAIT_BUILD_TESTS_SUPPORTED AND PAL_TRAIT_BUILD_HOST_TOOLS)
ly_add_pytest(
NAME AutomatedTesting::WhiteBoxTests
TEST_SUITE main
TEST_SERIAL
PATH ${CMAKE_CURRENT_LIST_DIR}/WhiteBox/TestSuite_Active.py
TIMEOUT 1500
RUNTIME_DEPENDENCIES
Legacy::Editor
AZ::AssetProcessor
AutomatedTesting.Assets
COMPONENT
WhiteBox
)
endif()
add_subdirectory(WhiteBox)
## NvCloth ##
if(PAL_TRAIT_BUILD_TESTS_SUPPORTED AND PAL_TRAIT_BUILD_HOST_TOOLS)
ly_add_pytest(
NAME AutomatedTesting::NvClothTests_Main
TEST_SUITE main
TEST_SERIAL
PATH ${CMAKE_CURRENT_LIST_DIR}/NvCloth/TestSuite_Active.py
TIMEOUT 1500
RUNTIME_DEPENDENCIES
Legacy::Editor
AZ::AssetProcessor
AutomatedTesting.Assets
COMPONENT
NvCloth
)
endif()
add_subdirectory(NvCloth)
## Prefab ##
if(PAL_TRAIT_BUILD_TESTS_SUPPORTED AND PAL_TRAIT_BUILD_HOST_TOOLS)
ly_add_pytest(
NAME AutomatedTesting::PrefabTests
TEST_SUITE main
TEST_SERIAL
PATH ${CMAKE_CURRENT_LIST_DIR}/prefab/TestSuite_Main.py
TIMEOUT 1500
RUNTIME_DEPENDENCIES
Legacy::Editor
AZ::AssetProcessor
AutomatedTesting.Assets
)
endif()
add_subdirectory(prefab)
## Editor Python Bindings ##
if(PAL_TRAIT_BUILD_TESTS_SUPPORTED AND PAL_TRAIT_BUILD_HOST_TOOLS)
ly_add_pytest(
NAME AutomatedTesting::EditorPythonBindings
TEST_SUITE sandbox
TEST_SERIAL
PATH ${CMAKE_CURRENT_LIST_DIR}/EditorPythonBindings
TIMEOUT 1500
RUNTIME_DEPENDENCIES
Legacy::Editor
AZ::AssetProcessor
AutomatedTesting.Assets
Gem::EditorPythonBindings.Editor
COMPONENT TestTools
)
endif()
add_subdirectory(EditorPythonBindings)
## Python Asset Builder ##
if(PAL_TRAIT_BUILD_TESTS_SUPPORTED AND PAL_TRAIT_BUILD_HOST_TOOLS)
ly_add_pytest(
NAME AutomatedTesting::PythonAssetBuilder
TEST_SUITE periodic
TEST_SERIAL
PATH ${CMAKE_CURRENT_LIST_DIR}/PythonAssetBuilder
TIMEOUT 1500
RUNTIME_DEPENDENCIES
Legacy::Editor
AZ::AssetProcessor
AutomatedTesting.Assets
Gem::EditorPythonBindings.Editor
Gem::PythonAssetBuilder.Editor
COMPONENT TestTools
)
endif()
add_subdirectory(PythonAssetBuilder)
## Blast ##
if(PAL_TRAIT_BUILD_TESTS_SUPPORTED AND PAL_TRAIT_BUILD_HOST_TOOLS)
ly_add_pytest(
NAME AutomatedTesting::BlastTests
TEST_SUITE main
TEST_SERIAL TRUE
PATH ${CMAKE_CURRENT_LIST_DIR}/Blast/TestSuite_Active.py
TIMEOUT 1500
RUNTIME_DEPENDENCIES
Legacy::Editor
AZ::AssetProcessor
AutomatedTesting.Assets
COMPONENT Blast
)
endif()
#############
add_subdirectory(Blast)
## Large Worlds ##
include(${pal_dir}/PAL_traits_${PAL_PLATFORM_NAME_LOWERCASE}.cmake)
if(PAL_TRAIT_BUILD_TESTS_SUPPORTED AND PAL_TRAIT_BUILD_HOST_TOOLS AND PAL_TRAIT_LARGE_WORLDS_TEST_SUPPORTED)
## DynVeg ##
# Temporarily moving all tests to periodic suite - SPEC-6553
#ly_add_pytest(
# NAME AutomatedTesting::DynamicVegetationTests_Main
# TEST_SERIAL
# TEST_SUITE main
# PATH ${CMAKE_CURRENT_LIST_DIR}/largeworlds/dyn_veg
# PYTEST_MARKS "not SUITE_sandbox and not SUITE_periodic and not SUITE_benchmark"
# TIMEOUT 1500
# RUNTIME_DEPENDENCIES
# AZ::AssetProcessor
# Legacy::Editor
# AutomatedTesting.GameLauncher
# AutomatedTesting.Assets
# COMPONENT
# LargeWorlds
#)
ly_add_pytest(
NAME AutomatedTesting::DynamicVegetationTests_Sandbox
TEST_SERIAL
TEST_SUITE sandbox
PATH ${CMAKE_CURRENT_LIST_DIR}/largeworlds/dyn_veg
PYTEST_MARKS "SUITE_sandbox"
TIMEOUT 1500
RUNTIME_DEPENDENCIES
AZ::AssetProcessor
Legacy::Editor
AutomatedTesting.GameLauncher
AutomatedTesting.Assets
COMPONENT
LargeWorlds
)
ly_add_pytest(
NAME AutomatedTesting::DynamicVegetationFilterTests_Periodic
TEST_SERIAL
TEST_SUITE periodic
PATH ${CMAKE_CURRENT_LIST_DIR}/largeworlds/dyn_veg
PYTEST_MARKS "SUITE_periodic and dynveg_filter"
TIMEOUT 1500
RUNTIME_DEPENDENCIES
AZ::AssetProcessor
Legacy::Editor
AutomatedTesting.Assets
COMPONENT
LargeWorlds
)
ly_add_pytest(
NAME AutomatedTesting::DynamicVegetationModifierTests_Periodic
TEST_SERIAL
TEST_SUITE periodic
PATH ${CMAKE_CURRENT_LIST_DIR}/largeworlds/dyn_veg
PYTEST_MARKS "SUITE_periodic and dynveg_modifier"
TIMEOUT 1500
RUNTIME_DEPENDENCIES
AZ::AssetProcessor
Legacy::Editor
AutomatedTesting.Assets
COMPONENT
LargeWorlds
)
ly_add_pytest(
NAME AutomatedTesting::DynamicVegetationRegressionTests_Periodic
TEST_SERIAL
TEST_SUITE periodic
PATH ${CMAKE_CURRENT_LIST_DIR}/largeworlds/dyn_veg
PYTEST_MARKS "SUITE_periodic and dynveg_regression"
TIMEOUT 1500
RUNTIME_DEPENDENCIES
AZ::AssetProcessor
Legacy::Editor
AutomatedTesting.Assets
COMPONENT
LargeWorlds
)
ly_add_pytest(
NAME AutomatedTesting::DynamicVegetationAreaTests_Periodic
TEST_SERIAL
TEST_SUITE periodic
PATH ${CMAKE_CURRENT_LIST_DIR}/largeworlds/dyn_veg
PYTEST_MARKS "SUITE_periodic and dynveg_area"
TIMEOUT 1500
RUNTIME_DEPENDENCIES
AZ::AssetProcessor
Legacy::Editor
AutomatedTesting.Assets
COMPONENT
LargeWorlds
)
ly_add_pytest(
NAME AutomatedTesting::DynamicVegetationMiscTests_Periodic
TEST_SERIAL
TEST_SUITE periodic
PATH ${CMAKE_CURRENT_LIST_DIR}/largeworlds/dyn_veg
PYTEST_MARKS "SUITE_periodic and dynveg_misc"
TIMEOUT 1500
RUNTIME_DEPENDENCIES
AZ::AssetProcessor
Legacy::Editor
AutomatedTesting.Assets
COMPONENT
LargeWorlds
)
ly_add_pytest(
NAME AutomatedTesting::DynamicVegetationSurfaceTagTests_Periodic
TEST_SERIAL
TEST_SUITE periodic
PATH ${CMAKE_CURRENT_LIST_DIR}/largeworlds/dyn_veg
PYTEST_MARKS "SUITE_periodic and dynveg_surfacetagemitter"
TIMEOUT 1500
RUNTIME_DEPENDENCIES
AZ::AssetProcessor
Legacy::Editor
AutomatedTesting.Assets
COMPONENT
LargeWorlds
)
## LandscapeCanvas ##
# Temporarily moving all tests to periodic suite - SPEC-6553
#ly_add_pytest(
# NAME AutomatedTesting::LandscapeCanvasTests_Main
# TEST_SERIAL
# TEST_SUITE main
# PATH ${CMAKE_CURRENT_LIST_DIR}/largeworlds/landscape_canvas
# PYTEST_MARKS "not SUITE_sandbox and not SUITE_periodic and not SUITE_benchmark"
# TIMEOUT 1500
# RUNTIME_DEPENDENCIES
# AZ::AssetProcessor
# Legacy::Editor
# AutomatedTesting.Assets
# COMPONENT
# LargeWorlds
#)
ly_add_pytest(
NAME AutomatedTesting::LandscapeCanvasTests_Periodic
TEST_SERIAL
TEST_SUITE periodic
PATH ${CMAKE_CURRENT_LIST_DIR}/largeworlds/landscape_canvas
PYTEST_MARKS "SUITE_periodic"
TIMEOUT 1500
RUNTIME_DEPENDENCIES
AZ::AssetProcessor
Legacy::Editor
AutomatedTesting.Assets
COMPONENT
LargeWorlds
)
## GradientSignal ##
ly_add_pytest(
NAME AutomatedTesting::GradientSignalTests_Periodic
TEST_SERIAL
TEST_SUITE periodic
PATH ${CMAKE_CURRENT_LIST_DIR}/largeworlds/gradient_signal
TIMEOUT 1500
RUNTIME_DEPENDENCIES
AZ::AssetProcessor
Legacy::Editor
AutomatedTesting.Assets
COMPONENT
LargeWorlds
)
endif()
add_subdirectory(largeworlds)
## Editor ##
if(PAL_TRAIT_BUILD_TESTS_SUPPORTED AND PAL_TRAIT_BUILD_HOST_TOOLS AND PAL_TRAIT_FOUNDATION_TEST_SUPPORTED)
ly_add_pytest(
NAME AutomatedTesting::EditorTests_Periodic
TEST_SUITE periodic
TEST_SERIAL
PATH ${CMAKE_CURRENT_LIST_DIR}/editor
TIMEOUT 1500
RUNTIME_DEPENDENCIES
Legacy::Editor
AZ::AssetProcessor
AutomatedTesting.Assets
COMPONENT
Editor
)
endif()
add_subdirectory(editor)
if(PAL_TRAIT_BUILD_TESTS_SUPPORTED AND PAL_TRAIT_BUILD_HOST_TOOLS)
# Unstable, SPEC-3838 will restore
#ly_add_pytest(
# NAME AutomatedTesting::asset_load_benchmark_test
# TEST_SERIAL
# TEST_SUITE benchmark
# PATH ${CMAKE_CURRENT_LIST_DIR}/streaming/benchmark/asset_load_benchmark_test.py
# RUNTIME_DEPENDENCIES
# AZ::AssetProcessor
# AZ::AssetProcessorBatch
# AutomatedTesting.GameLauncher
#)
endif()
## Streaming ##
add_subdirectory(streaming)
## Streaming ##
add_subdirectory(smoke)
AutomatedTesting/Gem/PythonTests/EditorPythonBindings/CMakeLists.txt
+26
View File
@@ -0,0 +1,26 @@
#
# All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
# its licensors.
#
# For complete copyright and license terms please see the LICENSE at the root of this
# distribution (the "License"). All use of this software is governed by the License,
# or, if provided, by the license below or the license accompanying this file. Do not
# remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#
if(PAL_TRAIT_BUILD_TESTS_SUPPORTED AND PAL_TRAIT_BUILD_HOST_TOOLS)
ly_add_pytest(
NAME AutomatedTesting::EditorPythonBindings
TEST_SUITE sandbox
TEST_SERIAL
PATH ${CMAKE_CURRENT_LIST_DIR}
TIMEOUT 1500
RUNTIME_DEPENDENCIES
Legacy::Editor
AZ::AssetProcessor
AutomatedTesting.Assets
Gem::EditorPythonBindings.Editor
COMPONENT TestTools
)
endif()
AutomatedTesting/Gem/PythonTests/NvCloth/CMakeLists.txt
+26
View File
@@ -0,0 +1,26 @@
#
# All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
# its licensors.
#
# For complete copyright and license terms please see the LICENSE at the root of this
# distribution (the "License"). All use of this software is governed by the License,
# or, if provided, by the license below or the license accompanying this file. Do not
# remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#
if(PAL_TRAIT_BUILD_TESTS_SUPPORTED AND PAL_TRAIT_BUILD_HOST_TOOLS)
ly_add_pytest(
NAME AutomatedTesting::NvClothTests_Main
TEST_SUITE main
TEST_SERIAL
PATH ${CMAKE_CURRENT_LIST_DIR}/TestSuite_Active.py
TIMEOUT 1500
RUNTIME_DEPENDENCIES
Legacy::Editor
AZ::AssetProcessor
AutomatedTesting.Assets
COMPONENT
NvCloth
)
endif()
AutomatedTesting/Gem/PythonTests/PythonAssetBuilder/CMakeLists.txt
+27
View File
@@ -0,0 +1,27 @@
#
# All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
# its licensors.
#
# For complete copyright and license terms please see the LICENSE at the root of this
# distribution (the "License"). All use of this software is governed by the License,
# or, if provided, by the license below or the license accompanying this file. Do not
# remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#
if(PAL_TRAIT_BUILD_TESTS_SUPPORTED AND PAL_TRAIT_BUILD_HOST_TOOLS)
ly_add_pytest(
NAME AutomatedTesting::PythonAssetBuilder
TEST_SUITE periodic
TEST_SERIAL
PATH ${CMAKE_CURRENT_LIST_DIR}
TIMEOUT 1500
RUNTIME_DEPENDENCIES
Legacy::Editor
AZ::AssetProcessor
AutomatedTesting.Assets
Gem::EditorPythonBindings.Editor
Gem::PythonAssetBuilder.Editor
COMPONENT TestTools
)
endif()
AutomatedTesting/Gem/PythonTests/WhiteBox/CMakeLists.txt
+26
View File
@@ -0,0 +1,26 @@
#
# All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
# its licensors.
#
# For complete copyright and license terms please see the LICENSE at the root of this
# distribution (the "License"). All use of this software is governed by the License,
# or, if provided, by the license below or the license accompanying this file. Do not
# remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#
if(PAL_TRAIT_BUILD_TESTS_SUPPORTED AND PAL_TRAIT_BUILD_HOST_TOOLS)
ly_add_pytest(
NAME AutomatedTesting::WhiteBoxTests
TEST_SUITE main
TEST_SERIAL
PATH ${CMAKE_CURRENT_LIST_DIR}/TestSuite_Active.py
TIMEOUT 1500
RUNTIME_DEPENDENCIES
Legacy::Editor
AZ::AssetProcessor
AutomatedTesting.Assets
COMPONENT
WhiteBox
)
endif()
AutomatedTesting/Gem/PythonTests/assetpipeline/CMakeLists.txt
-4
View File
@@ -13,8 +13,6 @@ add_subdirectory(asset_processor_tests)
if(PAL_TRAIT_BUILD_TESTS_SUPPORTED AND PAL_TRAIT_BUILD_HOST_TOOLS)
## AP Python Tests ##
ly_add_pytest(
NAME AssetPipelineTests.AuxiliaryContent
PATH ${CMAKE_CURRENT_LIST_DIR}/auxiliary_content_tests/auxiliary_content_tests.py
@@ -22,7 +20,6 @@ if(PAL_TRAIT_BUILD_TESTS_SUPPORTED AND PAL_TRAIT_BUILD_HOST_TOOLS)
TEST_SUITE periodic
)
ly_add_pytest(
NAME AssetPipelineTests.BankInfoParser
PATH ${CMAKE_CURRENT_LIST_DIR}/wwise_bank_dependency_tests/bank_info_parser_tests.py
@@ -33,4 +30,3 @@ if(PAL_TRAIT_BUILD_TESTS_SUPPORTED AND PAL_TRAIT_BUILD_HOST_TOOLS)
)
endif()
AutomatedTesting/Gem/PythonTests/assetpipeline/asset_processor_tests/CMakeLists.txt
-1
View File
@@ -141,4 +141,3 @@ if(PAL_TRAIT_BUILD_TESTS_SUPPORTED AND PAL_TRAIT_BUILD_HOST_TOOLS)
# )
endif()
AutomatedTesting/Gem/PythonTests/editor/CMakeLists.txt
+26
View File
@@ -0,0 +1,26 @@
#
# All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
# its licensors.
#
# For complete copyright and license terms please see the LICENSE at the root of this
# distribution (the "License"). All use of this software is governed by the License,
# or, if provided, by the license below or the license accompanying this file. Do not
# remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#
if(PAL_TRAIT_BUILD_TESTS_SUPPORTED AND PAL_TRAIT_BUILD_HOST_TOOLS AND PAL_TRAIT_FOUNDATION_TEST_SUPPORTED)
ly_add_pytest(
NAME AutomatedTesting::EditorTests_Periodic
TEST_SUITE periodic
TEST_SERIAL
PATH ${CMAKE_CURRENT_LIST_DIR}
TIMEOUT 1500
RUNTIME_DEPENDENCIES
Legacy::Editor
AZ::AssetProcessor
AutomatedTesting.Assets
COMPONENT
Editor
)
endif()
AutomatedTesting/Gem/PythonTests/largeworlds/CMakeLists.txt
+186
View File
@@ -0,0 +1,186 @@
#
# All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
# its licensors.
#
# For complete copyright and license terms please see the LICENSE at the root of this
# distribution (the "License"). All use of this software is governed by the License,
# or, if provided, by the license below or the license accompanying this file. Do not
# remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#
if(PAL_TRAIT_BUILD_TESTS_SUPPORTED AND PAL_TRAIT_BUILD_HOST_TOOLS AND PAL_TRAIT_LARGE_WORLDS_TEST_SUPPORTED)
## DynVeg ##
# Temporarily moving all tests to periodic suite - SPEC-6553
#ly_add_pytest(
# NAME AutomatedTesting::DynamicVegetationTests_Main
# TEST_SERIAL
# TEST_SUITE main
# PATH ${CMAKE_CURRENT_LIST_DIR}/dyn_veg
# PYTEST_MARKS "not SUITE_sandbox and not SUITE_periodic and not SUITE_benchmark"
# TIMEOUT 1500
# RUNTIME_DEPENDENCIES
# AZ::AssetProcessor
# Legacy::Editor
# AutomatedTesting.GameLauncher
# AutomatedTesting.Assets
# COMPONENT
# LargeWorlds
#)
ly_add_pytest(
NAME AutomatedTesting::DynamicVegetationTests_Sandbox
TEST_SERIAL
TEST_SUITE sandbox
PATH ${CMAKE_CURRENT_LIST_DIR}/dyn_veg
PYTEST_MARKS "SUITE_sandbox"
TIMEOUT 1500
RUNTIME_DEPENDENCIES
AZ::AssetProcessor
Legacy::Editor
AutomatedTesting.GameLauncher
AutomatedTesting.Assets
COMPONENT
LargeWorlds
)
ly_add_pytest(
NAME AutomatedTesting::DynamicVegetationFilterTests_Periodic
TEST_SERIAL
TEST_SUITE periodic
PATH ${CMAKE_CURRENT_LIST_DIR}/dyn_veg
PYTEST_MARKS "SUITE_periodic and dynveg_filter"
TIMEOUT 1500
RUNTIME_DEPENDENCIES
AZ::AssetProcessor
Legacy::Editor
AutomatedTesting.Assets
COMPONENT
LargeWorlds
)
ly_add_pytest(
NAME AutomatedTesting::DynamicVegetationModifierTests_Periodic
TEST_SERIAL
TEST_SUITE periodic
PATH ${CMAKE_CURRENT_LIST_DIR}/dyn_veg
PYTEST_MARKS "SUITE_periodic and dynveg_modifier"
TIMEOUT 1500
RUNTIME_DEPENDENCIES
AZ::AssetProcessor
Legacy::Editor
AutomatedTesting.Assets
COMPONENT
LargeWorlds
)
ly_add_pytest(
NAME AutomatedTesting::DynamicVegetationRegressionTests_Periodic
TEST_SERIAL
TEST_SUITE periodic
PATH ${CMAKE_CURRENT_LIST_DIR}/dyn_veg
PYTEST_MARKS "SUITE_periodic and dynveg_regression"
TIMEOUT 1500
RUNTIME_DEPENDENCIES
AZ::AssetProcessor
Legacy::Editor
AutomatedTesting.Assets
COMPONENT
LargeWorlds
)
ly_add_pytest(
NAME AutomatedTesting::DynamicVegetationAreaTests_Periodic
TEST_SERIAL
TEST_SUITE periodic
PATH ${CMAKE_CURRENT_LIST_DIR}/dyn_veg
PYTEST_MARKS "SUITE_periodic and dynveg_area"
TIMEOUT 1500
RUNTIME_DEPENDENCIES
AZ::AssetProcessor
Legacy::Editor
AutomatedTesting.Assets
COMPONENT
LargeWorlds
)
ly_add_pytest(
NAME AutomatedTesting::DynamicVegetationMiscTests_Periodic
TEST_SERIAL
TEST_SUITE periodic
PATH ${CMAKE_CURRENT_LIST_DIR}/dyn_veg
PYTEST_MARKS "SUITE_periodic and dynveg_misc"
TIMEOUT 1500
RUNTIME_DEPENDENCIES
AZ::AssetProcessor
Legacy::Editor
AutomatedTesting.Assets
COMPONENT
LargeWorlds
)
ly_add_pytest(
NAME AutomatedTesting::DynamicVegetationSurfaceTagTests_Periodic
TEST_SERIAL
TEST_SUITE periodic
PATH ${CMAKE_CURRENT_LIST_DIR}/dyn_veg
PYTEST_MARKS "SUITE_periodic and dynveg_surfacetagemitter"
TIMEOUT 1500
RUNTIME_DEPENDENCIES
AZ::AssetProcessor
Legacy::Editor
AutomatedTesting.Assets
COMPONENT
LargeWorlds
)
## LandscapeCanvas ##
# Temporarily moving all tests to periodic suite - SPEC-6553
#ly_add_pytest(
# NAME AutomatedTesting::LandscapeCanvasTests_Main
# TEST_SERIAL
# TEST_SUITE main
# PATH ${CMAKE_CURRENT_LIST_DIR}/largeworlds/landscape_canvas
# PYTEST_MARKS "not SUITE_sandbox and not SUITE_periodic and not SUITE_benchmark"
# TIMEOUT 1500
# RUNTIME_DEPENDENCIES
# AZ::AssetProcessor
# Legacy::Editor
# AutomatedTesting.Assets
# COMPONENT
# LargeWorlds
#)
ly_add_pytest(
NAME AutomatedTesting::LandscapeCanvasTests_Periodic
TEST_SERIAL
TEST_SUITE periodic
PATH ${CMAKE_CURRENT_LIST_DIR}/landscape_canvas
PYTEST_MARKS "SUITE_periodic"
TIMEOUT 1500
RUNTIME_DEPENDENCIES
AZ::AssetProcessor
Legacy::Editor
AutomatedTesting.Assets
COMPONENT
LargeWorlds
)
## GradientSignal ##
ly_add_pytest(
NAME AutomatedTesting::GradientSignalTests_Periodic
TEST_SERIAL
TEST_SUITE periodic
PATH ${CMAKE_CURRENT_LIST_DIR}/gradient_signal
TIMEOUT 1500
RUNTIME_DEPENDENCIES
AZ::AssetProcessor
Legacy::Editor
AutomatedTesting.Assets
COMPONENT
LargeWorlds
)
endif()
AutomatedTesting/Gem/PythonTests/physics/CMakeLists.txt
+52
View File
@@ -0,0 +1,52 @@
#
# All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
# its licensors.
#
# For complete copyright and license terms please see the LICENSE at the root of this
# distribution (the "License"). All use of this software is governed by the License,
# or, if provided, by the license below or the license accompanying this file. Do not
# remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#
if(PAL_TRAIT_BUILD_TESTS_SUPPORTED AND PAL_TRAIT_BUILD_HOST_TOOLS)
ly_add_pytest(
NAME AutomatedTesting::PhysicsTests_Main
TEST_SUITE main
TEST_SERIAL
PATH ${CMAKE_CURRENT_LIST_DIR}/TestSuite_Main.py
TIMEOUT 1500
RUNTIME_DEPENDENCIES
Legacy::Editor
AZ::AssetProcessor
AutomatedTesting.Assets
COMPONENT
Physics
)
ly_add_pytest(
NAME AutomatedTesting::PhysicsTests_Periodic
TEST_SUITE periodic
TEST_SERIAL
PATH ${CMAKE_CURRENT_LIST_DIR}/TestSuite_Periodic.py
TIMEOUT 1500
RUNTIME_DEPENDENCIES
Legacy::Editor
AZ::AssetProcessor
AutomatedTesting.Assets
COMPONENT
Physics
)
ly_add_pytest(
NAME AutomatedTesting::PhysicsTests_Sandbox
TEST_SUITE sandbox
TEST_SERIAL
PATH ${CMAKE_CURRENT_LIST_DIR}/TestSuite_Sandbox.py
TIMEOUT 1500
RUNTIME_DEPENDENCIES
Legacy::Editor
AZ::AssetProcessor
AutomatedTesting.Assets
COMPONENT
Physics
)
endif()
AutomatedTesting/Gem/PythonTests/prefab/CMakeLists.txt
+25
View File
@@ -0,0 +1,25 @@
#
# All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
# its licensors.
#
# For complete copyright and license terms please see the LICENSE at the root of this
# distribution (the "License"). All use of this software is governed by the License,
# or, if provided, by the license below or the license accompanying this file. Do not
# remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#
## Prefab ##
if(PAL_TRAIT_BUILD_TESTS_SUPPORTED AND PAL_TRAIT_BUILD_HOST_TOOLS)
ly_add_pytest(
NAME AutomatedTesting::PrefabTests
TEST_SUITE main
TEST_SERIAL
PATH ${CMAKE_CURRENT_LIST_DIR}/TestSuite_Main.py
TIMEOUT 1500
RUNTIME_DEPENDENCIES
Legacy::Editor
AZ::AssetProcessor
AutomatedTesting.Assets
)
endif()
AutomatedTesting/Gem/PythonTests/scripting/CMakeLists.txt
+37
View File
@@ -0,0 +1,37 @@
#
# All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
# its licensors.
#
# For complete copyright and license terms please see the LICENSE at the root of this
# distribution (the "License"). All use of this software is governed by the License,
# or, if provided, by the license below or the license accompanying this file. Do not
# remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#
if(PAL_TRAIT_BUILD_TESTS_SUPPORTED AND PAL_TRAIT_BUILD_HOST_TOOLS)
ly_add_pytest(
NAME AutomatedTesting::ScriptCanvasTests_Perodic
TEST_SUITE periodic
TEST_SERIAL
PATH ${CMAKE_CURRENT_LIST_DIR}/TestSuite_Periodic.py
TIMEOUT 1500
RUNTIME_DEPENDENCIES
Legacy::Editor
AZ::AssetProcessor
AutomatedTesting.Assets
COMPONENT
ScriptCanvas
)
ly_add_pytest(
NAME AutomatedTesting::ScriptCanvasTests_Sandbox
TEST_SUITE sandbox
TEST_SERIAL
PATH ${CMAKE_CURRENT_LIST_DIR}/TestSuite_Sandbox.py
TIMEOUT 1500
RUNTIME_DEPENDENCIES
Legacy::Editor
AZ::AssetProcessor
AutomatedTesting.Assets
)
endif()
AutomatedTesting/Gem/PythonTests/scripting/TestSuite_Active.py → AutomatedTesting/Gem/PythonTests/scripting/TestSuite_Periodic.py
View File
AutomatedTesting/Gem/PythonTests/smoke/CMakeLists.txt
+27
View File
@@ -0,0 +1,27 @@
#
# All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
# its licensors.
#
# For complete copyright and license terms please see the LICENSE at the root of this
# distribution (the "License"). All use of this software is governed by the License,
# or, if provided, by the license below or the license accompanying this file. Do not
# remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
if(PAL_TRAIT_BUILD_TESTS_SUPPORTED AND PAL_TRAIT_BUILD_HOST_TOOLS)
ly_add_pytest(
NAME AutomatedTesting::SmokeTest
TEST_SUITE smoke
TEST_SERIAL
PATH ${CMAKE_CURRENT_LIST_DIR}
TIMEOUT 1500
RUNTIME_DEPENDENCIES
AZ::AssetProcessor
AZ::PythonBindingsExample
Legacy::Editor
AutomatedTesting.GameLauncher
AutomatedTesting.Assets
COMPONENT
Smoke
)
endif()
AutomatedTesting/Gem/PythonTests/smoke/Editor_NewExistingLevels_Works.py
+147
View File
@@ -0,0 +1,147 @@
"""
All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
its licensors.
For complete copyright and license terms please see the LICENSE at the root of this
distribution (the "License"). All use of this software is governed by the License,
or, if provided, by the license below or the license accompanying this file. Do not
remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
Test Case Title: Create Test for UI apps- Editor
"""
class Tests():
level_created = ("Level created", "Failed to create level")
entity_found = ("New Entity created in level", "Failed to create New Entity in level")
mesh_added = ("Mesh Component added", "Failed to add Mesh Component")
enter_game_mode = ("Game Mode successfully entered", "Failed to enter in Game Mode")
exit_game_mode = ("Game Mode successfully exited", "Failed to exit in Game Mode")
level_opened = ("Level opened successfully", "Failed to open level")
level_exported = ("Level exported successfully", "Failed to export level")
mesh_removed = ("Mesh Component removed", "Failed to remove Mesh Component")
entity_deleted = ("Entity deleted", "Failed to delete Entity")
level_edits_present = ("Level edits persist after saving", "Failed to save level edits after saving")
def Editor_NewExistingLevels_Works():
"""
Summary: Perform the below operations on Editor
1) Launch & Close editor
2) Create new level
3) Saving and loading levels
4) Level edits persist after saving
5) Export Level
6) Can switch to play mode (ctrl+g) and exit that
7) Run editor python bindings test
8) Create an Entity
9) Delete an Entity
10) Add a component to an Entity
Expected Behavior:
All operations succeed and do not cause a crash
Test Steps:
1) Launch editor and Create a new level
2) Create a new entity
3) Add Mesh component
4) Verify enter/exit game mode
5) Save, Load and Export level
6) Remove Mesh component
7) Delete entity
8) Open an existing level
9) Create a new entity in an existing level
10) Save, Load and Export an existing level and close editor
Note:
- This test file must be called from the Lumberyard 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 editor_python_test_tools.hydra_editor_utils as hydra
from editor_python_test_tools.utils import TestHelper as helper
from editor_python_test_tools.utils import Report
import azlmbr.bus as bus
import azlmbr.editor as editor
import azlmbr.legacy.general as general
import azlmbr.math as math
# 1) Launch editor and Create a new level
helper.init_idle()
test_level_name = "temp_level"
general.create_level_no_prompt(test_level_name, 128, 1, 128, False)
helper.wait_for_condition(lambda: general.get_current_level_name() == test_level_name, 2.0)
Report.result(Tests.level_created, general.get_current_level_name() == test_level_name)
# 2) Create a new entity
entity_position = math.Vector3(200.0, 200.0, 38.0)
new_entity = hydra.Entity("Entity1")
new_entity.create_entity(entity_position, [])
test_entity = hydra.find_entity_by_name("Entity1")
Report.result(Tests.entity_found, test_entity.IsValid())
# 3) Add Mesh component
new_entity.add_component("Mesh")
Report.result(Tests.mesh_added, hydra.has_components(new_entity.id, ["Mesh"]))
# 4) Verify enter/exit game mode
helper.enter_game_mode(Tests.enter_game_mode)
helper.exit_game_mode(Tests.exit_game_mode)
# 5) Save, Load and Export level
# Save Level
general.save_level()
# Open Level
general.open_level(test_level_name)
Report.result(Tests.level_opened, general.get_current_level_name() == test_level_name)
# Export Level
general.export_to_engine()
level_pak_file = os.path.join("AutomatedTesting", "Levels", test_level_name, "level.pak")
Report.result(Tests.level_exported, os.path.exists(level_pak_file))
# 6) Remove Mesh component
new_entity.remove_component("Mesh")
Report.result(Tests.mesh_removed, not hydra.has_components(new_entity.id, ["Mesh"]))
# 7) Delete entity
editor.ToolsApplicationRequestBus(bus.Broadcast, "DeleteEntityById", new_entity.id)
test_entity = hydra.find_entity_by_name("Entity1")
Report.result(Tests.entity_deleted, len(test_entity) == 0)
# 8) Open an existing level
general.open_level(test_level_name)
Report.result(Tests.level_opened, general.get_current_level_name() == test_level_name)
# 9) Create a new entity in an existing level
entity_position = math.Vector3(200.0, 200.0, 38.0)
new_entity_2 = hydra.Entity("Entity2")
new_entity_2.create_entity(entity_position, [])
test_entity = hydra.find_entity_by_name("Entity2")
Report.result(Tests.entity_found, test_entity.IsValid())
# 10) Save, Load and Export an existing level
# Save Level
general.save_level()
# Open Level
general.open_level(test_level_name)
Report.result(Tests.level_opened, general.get_current_level_name() == test_level_name)
entity_id = hydra.find_entity_by_name(new_entity_2.name)
Report.result(Tests.level_edits_present, entity_id == new_entity_2.id)
# Export Level
general.export_to_engine()
level_pak_file = os.path.join("AutomatedTesting", "Levels", test_level_name, "level.pak")
Report.result(Tests.level_exported, os.path.exists(level_pak_file))
if __name__ == "__main__":
from editor_python_test_tools.utils import Report
Report.start_test(Editor_NewExistingLevels_Works)
AutomatedTesting/Gem/PythonTests/smoke/__init__.py
+10
View File
@@ -0,0 +1,10 @@
"""
All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
its licensors.
For complete copyright and license terms please see the LICENSE at the root of this
distribution (the "License"). All use of this software is governed by the License,
or, if provided, by the license below or the license accompanying this file. Do not
remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
"""
AutomatedTesting/Gem/PythonTests/smoke/test_CLITool_AssetBuilder_Works.py
+33
View File
@@ -0,0 +1,33 @@
"""
All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
its licensors.
For complete copyright and license terms please see the LICENSE at the root of this
distribution (the "License"). All use of this software is governed by the License,
or, if provided, by the license below or the license accompanying this file. Do not
remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
CLI tool - AssetBuilder
Launch AssetBuilder and Verify the help message
"""
import os
import pytest
import subprocess
@pytest.mark.SUITE_smoke
class TestCLIToolAssetBuilderWorks(object):
@pytest.mark.xfail(reason="Ignoring failure temporarily - SPEC-6905")
def test_CLITool_AssetBuilder_Works(self, build_directory):
file_path = os.path.join(build_directory, "AssetBuilder")
help_message = "AssetBuilder is part of the Asset Processor"
# Launch AssetBuilder
output = subprocess.run([file_path, "-help"], capture_output=True, timeout=10)
assert (
len(output.stderr) == 0 and output.returncode == 0
), f"Error occurred while launching {file_path}: {output.stderr}"
# Verify help message
assert help_message in str(output.stdout), f"Help Message: {help_message} is not present"
AutomatedTesting/Gem/PythonTests/smoke/test_CLITool_AssetBundlerBatch_Works.py
+32
View File
@@ -0,0 +1,32 @@
"""
All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
its licensors.
For complete copyright and license terms please see the LICENSE at the root of this
distribution (the "License"). All use of this software is governed by the License,
or, if provided, by the license below or the license accompanying this file. Do not
remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
CLI tool - AssetBundlerBatch
Launch AssetBundlerBatch and Verify the help message
"""
import os
import pytest
import subprocess
@pytest.mark.SUITE_smoke
class TestCLIToolAssetBundlerBatchWorks(object):
def test_CLITool_AssetBundlerBatch_Works(self, build_directory):
file_path = os.path.join(build_directory, "AssetBundlerBatch")
help_message = "Specifies the Seed List file to operate on by path"
# Launch AssetBundlerBatch
output = subprocess.run([file_path, "--help"], capture_output=True, timeout=10)
assert (
len(output.stderr) == 0 and output.returncode == 0
), f"Error occurred while launching {file_path}: {output.stderr}"
# Verify help message
assert help_message in str(output.stdout), f"Help Message: {help_message} is not present"
AutomatedTesting/Gem/PythonTests/smoke/test_CLITool_AssetProcessorBatch_Works.py
+26
View File
@@ -0,0 +1,26 @@
"""
All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
its licensors.
For complete copyright and license terms please see the LICENSE at the root of this
distribution (the "License"). All use of this software is governed by the License,
or, if provided, by the license below or the license accompanying this file. Do not
remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
CLI tool - AssetProcessorBatch
Launch AssetProcessorBatch and Shutdown AssetProcessorBatch without any crash
"""
import pytest
@pytest.mark.parametrize("project", ["AutomatedTesting"])
@pytest.mark.SUITE_smoke
class TestsCLIToolAssetProcessorBatchWorks(object):
def test_CLITool_AssetProcessorBatch_Works(self, workspace):
"""
Test Launching AssetProcessorBatch and verifies that is shuts down without issue
"""
workspace.asset_processor.batch_process()
AutomatedTesting/Gem/PythonTests/smoke/test_CLITool_AzTestRunner_Works.py
+34
View File
@@ -0,0 +1,34 @@
"""
All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
its licensors.
For complete copyright and license terms please see the LICENSE at the root of this
distribution (the "License"). All use of this software is governed by the License,
or, if provided, by the license below or the license accompanying this file. Do not
remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
CLI tool - AzTestRunner
Launch AzTestRunner and Verify the help message
"""
import os
import pytest
import subprocess
@pytest.mark.SUITE_smoke
class TestCLIToolAzTestRunnerWorks(object):
def test_CLITool_AzTestRunner_Works(self, build_directory):
file_path = os.path.join(build_directory, "AzTestRunner")
help_message = "OKAY Symbol found: AzRunUnitTests"
# Launch AzTestRunner
output = subprocess.run(
[file_path, "AzTestRunner.Tests", "AzRunUnitTests", "--gtest_list_tests"], capture_output=True, timeout=10
)
assert (
len(output.stderr) == 0 and output.returncode == 0
), f"Error occurred while launching {file_path}: {output.stderr}"
# Verify help message
assert help_message in str(output.stdout), f"Help Message: {help_message} is not present"
AutomatedTesting/Gem/PythonTests/smoke/test_CLITool_PythonBindingsExample_Works.py
+32
View File
@@ -0,0 +1,32 @@
"""
All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
its licensors.
For complete copyright and license terms please see the LICENSE at the root of this
distribution (the "License"). All use of this software is governed by the License,
or, if provided, by the license below or the license accompanying this file. Do not
remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
CLI tool - PythonBindingsExample
Launch PythonBindingsExample and Verify the help message
"""
import os
import pytest
import subprocess
@pytest.mark.SUITE_smoke
class TestCLIToolPythonBindingsExampleWorks(object):
def test_CLITool_PythonBindingsExample_Works(self, build_directory):
file_path = os.path.join(build_directory, "PythonBindingsExample")
help_message = "--help Prints the help text"
# Launch PythonBindingsExample
output = subprocess.run([file_path, "-help"], capture_output=True, timeout=10)
assert (
len(output.stderr) == 0 and output.returncode == 1
), f"Error occurred while launching {file_path}: {output.stderr}"
# Verify help message
assert help_message in str(output.stdout), f"Help Message: {help_message} is not present"
AutomatedTesting/Gem/PythonTests/smoke/test_CLITool_SerializeContextTools_Works.py
+32
View File
@@ -0,0 +1,32 @@
"""
All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
its licensors.
For complete copyright and license terms please see the LICENSE at the root of this
distribution (the "License"). All use of this software is governed by the License,
or, if provided, by the license below or the license accompanying this file. Do not
remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
CLI tool - SerializeContextTools
Launch SerializeContextTools and Verify the help message
"""
import os
import pytest
import subprocess
@pytest.mark.SUITE_smoke
class TestCLIToolSerializeContextToolsWorks(object):
def test_CLITool_SerializeContextTools_Works(self, build_directory):
file_path = os.path.join(build_directory, "SerializeContextTools")
help_message = "Converts a file with an ObjectStream to the new JSON"
# Launch SerializeContextTools
output = subprocess.run([file_path, "-help"], capture_output=True, timeout=10)
assert (
len(output.stderr) == 0 and output.returncode == 0
), f"Error occurred while launching {file_path}: {output.stderr}"
# Verify help message
assert help_message in str(output.stdout), f"Help Message: {help_message} is not present"
AutomatedTesting/Gem/PythonTests/smoke/test_Editor_NewExistingLevels_Works.py
+32
View File
@@ -0,0 +1,32 @@
"""
All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
its licensors.
For complete copyright and license terms please see the LICENSE at the root of this
distribution (the "License"). All use of this software is governed by the License,
or, if provided, by the license below or the license accompanying this file. Do not
remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
"""
import pytest
import os
from automatedtesting_shared.base import TestAutomationBase
import ly_test_tools.environment.file_system as file_system
@pytest.mark.SUITE_smoke
@pytest.mark.parametrize("launcher_platform", ["windows_editor"])
@pytest.mark.parametrize("project", ["AutomatedTesting"])
@pytest.mark.parametrize("level", ["temp_level"])
class TestAutomation(TestAutomationBase):
def test_Editor_NewExistingLevels_Works(self, request, workspace, editor, level, project, launcher_platform):
def teardown():
file_system.delete([os.path.join(workspace.paths.engine_root(), project, "Levels", level)], True, True)
request.addfinalizer(teardown)
file_system.delete([os.path.join(workspace.paths.engine_root(), project, "Levels", level)], True, True)
from . import Editor_NewExistingLevels_Works as test_module
self._run_test(request, workspace, editor, test_module)
AutomatedTesting/Gem/PythonTests/smoke/test_StaticTools_GenPakShaders_Works.py
+44
View File
@@ -0,0 +1,44 @@
"""
All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
its licensors.
For complete copyright and license terms please see the LICENSE at the root of this
distribution (the "License"). All use of this software is governed by the License,
or, if provided, by the license below or the license accompanying this file. Do not
remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
Static tool scripts
Launch Static tool and Verify the help message
"""
import os
import pytest
import subprocess
import sys
def verify_help_message(static_tool):
help_message = ["--help", "show this help message and exit"]
output = subprocess.run([sys.executable, static_tool, "-h"], capture_output=True)
assert (
len(output.stderr) == 0 and output.returncode == 0
), f"Error occurred while launching {static_tool}: {output.stderr}"
# verify help message
for message in help_message:
assert message in str(output.stdout), f"Help Message: {message} is not present"
@pytest.mark.parametrize("project", ["AutomatedTesting"])
@pytest.mark.SUITE_smoke
class TestStaticToolsGenPakShadersWorks(object):
def test_StaticTools_GenPakShaders_Works(self, editor):
static_tools = [
os.path.join(editor.workspace.paths.engine_root(), "scripts", "bundler", "gen_shaders.py"),
os.path.join(editor.workspace.paths.engine_root(), "scripts", "bundler", "get_shader_list.py"),
os.path.join(editor.workspace.paths.engine_root(), "scripts", "bundler", "pak_shaders.py"),
]
for tool in static_tools:
verify_help_message(tool)
AutomatedTesting/Gem/PythonTests/smoke/test_UIApps_AssetProcessor_CheckIdle.py
+39
View File
@@ -0,0 +1,39 @@
"""
All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
its licensors.
For complete copyright and license terms please see the LICENSE at the root of this
distribution (the "License"). All use of this software is governed by the License,
or, if provided, by the license below or the license accompanying this file. Do not
remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
UI Apps: AssetProcessor
Open AssetProcessor, Wait until AssetProcessor is Idle
Close AssetProcessor.
"""
import pytest
from ly_test_tools.o3de.asset_processor import AssetProcessor
@pytest.mark.parametrize("project", ["AutomatedTesting"])
@pytest.mark.SUITE_smoke
class TestsUIAppsAssetProcessorCheckIdle(object):
@pytest.fixture(autouse=True)
def setup_teardown(self, request):
self.asset_processor = None
def teardown():
self.asset_processor.stop()
request.addfinalizer(teardown)
def test_UIApps_AssetProcessor_CheckIdle(self, workspace):
"""
Test Launching AssetProcessorBatch and verifies that is shuts down without issue
"""
self.asset_processor = AssetProcessor(workspace)
self.asset_processor.gui_process()
AutomatedTesting/Gem/PythonTests/streaming/CMakeLists.txt
+24
View File
@@ -0,0 +1,24 @@
#
# All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
# its licensors.
#
# For complete copyright and license terms please see the LICENSE at the root of this
# distribution (the "License"). All use of this software is governed by the License,
# or, if provided, by the license below or the license accompanying this file. Do not
# remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#
if(PAL_TRAIT_BUILD_TESTS_SUPPORTED AND PAL_TRAIT_BUILD_HOST_TOOLS)
# Unstable, SPEC-3838 will restore
#ly_add_pytest(
# NAME AutomatedTesting::asset_load_benchmark_test
# TEST_SERIAL
# TEST_SUITE benchmark
# PATH ${CMAKE_CURRENT_LIST_DIR}/benchmark/asset_load_benchmark_test.py
# RUNTIME_DEPENDENCIES
# AZ::AssetProcessor
# AZ::AssetProcessorBatch
# AutomatedTesting.GameLauncher
#)
endif()
Code/CryEngine/CryCommon/CryArray2d.h
-84
View File
@@ -1,84 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#ifndef CRYINCLUDE_CRYCOMMON_ARRAY2D_H
#define CRYINCLUDE_CRYCOMMON_ARRAY2D_H
#pragma once
// Dynamic replacement for static 2d array
template <class T>
struct Array2d
{
Array2d()
{
m_nSize = 0;
m_pData = 0;
}
int GetSize() const { return m_nSize; }
int GetDataSize() const { return m_nSize * m_nSize * sizeof(T); }
T* GetData() { return m_pData; }
T* GetDataEnd() { return &m_pData[m_nSize * m_nSize]; }
void SetData(T* pData, int nSize)
{
Allocate(nSize);
memcpy(m_pData, pData, nSize * nSize * sizeof(T));
}
void Allocate(int nSize)
{
if (m_nSize == nSize)
{
return;
}
delete [] m_pData;
m_nSize = nSize;
m_pData = new T [nSize * nSize];
memset(m_pData, 0, nSize * nSize * sizeof(T));
}
~Array2d()
{
delete [] m_pData;
}
void Reset()
{
delete [] m_pData;
m_pData = 0;
m_nSize = 0;
}
T* m_pData;
int m_nSize;
T* operator [] (const int& nPos) const
{
assert(nPos >= 0 && nPos < m_nSize);
return &m_pData[nPos * m_nSize];
}
Array2d& operator = (const Array2d& other)
{
Allocate(other.m_nSize);
memcpy(m_pData, other.m_pData, m_nSize * m_nSize * sizeof(T));
return *this;
}
};
#endif // CRYINCLUDE_CRYCOMMON_ARRAY2D_H
Code/CryEngine/CryCommon/CryPhysicsDeprecation.h
-32
View File
@@ -1,32 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Description: Utilities and functions used when cryphysics is disabled
#pragma once
// Assert if CryPhysics is disabled and no functionality replacement has been implemented
// 1: Runtime AZ_Error
// 2: Runtime Assertion
// 3: Compilation error
// Other: Do nothing
#define ENABLE_CRY_PHYSICS_REPLACEMENT_ASSERT 0
#if (ENABLE_CRY_PHYSICS_REPLACEMENT_ASSERT == 1)
#define CRY_PHYSICS_REPLACEMENT_ASSERT() AZ_Error("CryPhysics", false, __FUNCTION__ " - CRYPHYSICS REPLACEMENT NOT IMPLEMENTED")
#elif (ENABLE_CRY_PHYSICS_REPLACEMENT_ASSERT == 2)
#define CRY_PHYSICS_REPLACEMENT_ASSERT() AZ_Assert(false, "CRYPHYSICS REPLACEMENT NOT IMPLEMENTED")
#elif (ENABLE_CRY_PHYSICS_REPLACEMENT_ASSERT == 3)
#define CRY_PHYSICS_REPLACEMENT_ASSERT() static_assert(false, __FUNCTION__ " - CRYPHYSICS REPLACEMENT NOT IMPLEMENTED")
#else
#define CRY_PHYSICS_REPLACEMENT_ASSERT()
#endif
Code/CryEngine/CryCommon/CryPtrArray.h
-100
View File
@@ -1,100 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#ifndef CRYINCLUDE_CRYCOMMON_CRYPTRARRAY_H
#define CRYINCLUDE_CRYCOMMON_CRYPTRARRAY_H
#pragma once
#include "CryArray.h"
#include "CrySizer.h"
//---------------------------------------------------------------------------
template<class T, class P = T*>
struct PtrArray
: DynArray<P>
{
typedef DynArray<P> super;
// Overrides.
typedef T value_type;
ILINE ~PtrArray(){}
inline T& operator [](int i) const
{ return *super::operator[](i); }
// Iterators.
struct iterator
{
iterator(P* p)
: _ptr(p)
{}
operator P* () const
{
return _ptr;
}
void operator++()
{ _ptr++; }
void operator--()
{ _ptr--; }
T& operator*() const
{ assert(_ptr); return **_ptr; }
T* operator->() const
{ assert(_ptr); return *_ptr; }
protected:
P* _ptr;
};
struct const_iterator
{
const_iterator(const P* p)
: _ptr(p)
{}
operator const P* () const
{
return _ptr;
}
void operator++()
{ _ptr++; }
void operator--()
{ _ptr--; }
T& operator*() const
{ assert(_ptr); return **_ptr; }
T* operator->() const
{ assert(_ptr); return *_ptr; }
protected:
const P* _ptr;
};
void GetMemoryUsage(ICrySizer* pSizer) const
{
pSizer->AddObject(this->begin(), this->get_alloc_size());
for (int i = 0; i < this->size(); ++i)
{
pSizer->AddObject(this->super::operator [](i));
}
}
};
//---------------------------------------------------------------------------
template<class T>
struct SmartPtrArray
: PtrArray< T, _smart_ptr<T> >
{
};
#endif // CRYINCLUDE_CRYCOMMON_CRYPTRARRAY_H
Code/CryEngine/CryCommon/CrySizer.h
-7
View File
@@ -33,7 +33,6 @@
#include <Cry_Vector3.h>
#include <Cry_Quat.h>
#include <Cry_Color.h>
#include <CryArray2d.h>
#include <smartptr.h>
// forward declarations for overloads
@@ -249,12 +248,6 @@ public:
void AddObject([[maybe_unused]] const AZ::Vector3& rObj) {}
void AddObject(void*) {}
template<typename T>
void AddObject(const Array2d<T>& array2d)
{
this->AddObject(array2d.m_pData, array2d.GetDataSize());
}
// overloads for container, will automaticly traverse the content
template<typename T, typename Alloc>
void AddObject(const std::list<T, Alloc>& rList)
Code/CryEngine/CryCommon/CryUtils.h
-24
View File
@@ -1,24 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#pragma once
#include <cstddef> // size_t
namespace Detail
{
template <typename T, size_t size>
char (&ArrayCountHelper(T(&)[size]))[size];
}
#define CRY_ARRAY_COUNT(arr) sizeof(::Detail::ArrayCountHelper(arr))
Code/CryEngine/CryCommon/CryZlib.h
-40
View File
@@ -1,40 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#pragma once
// Include this file instead of including zlib.h directly
// because zconf.h (included by zlib.h) defines WINDOWS and WIN32 - those
// definitions conflict with CryEngine's definitions.
#if defined(CRY_TMP_DEFINED_WINDOWS) || defined(CRY_TMP_DEFINED_WIN32)
# error CRY_TMP_DEFINED_WINDOWS and/or CRY_TMP_DEFINED_WIN32 already defined
#endif
#if defined(WINDOWS)
# define CRY_TMP_DEFINED_WINDOWS 1
#endif
#if defined(WIN32)
# define CRY_TMP_DEFINED_WIN32 1
#endif
#include <zlib.h>
#if !defined(CRY_TMP_DEFINED_WINDOWS)
# undef WINDOWS
#endif
#undef CRY_TMP_DEFINED_WINDOWS
#if !defined(CRY_TMP_DEFINED_WIN32)
# undef WIN32
#endif
#undef CRY_TMP_DEFINED_WIN32
Code/CryEngine/CryCommon/FinalizingSpline.h
-1043
View File
File diff suppressed because it is too large Load Diff
Code/CryEngine/CryCommon/GeomQuery.h
-469
View File
@@ -1,469 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
// Description : Facility for efficiently generating random positions on geometry
#ifndef CRYINCLUDE_CRYCOMMON_GEOMQUERY_H
#define CRYINCLUDE_CRYCOMMON_GEOMQUERY_H
#pragma once
#include "Cry_Geo.h"
#include "CryArray.h"
#include "Random.h"
//////////////////////////////////////////////////////////////////////
// Extents cache
class CGeomExtent
{
public:
CGeomExtent()
: m_nEmptyEndParts(0) {}
ILINE operator bool() const
{
return m_afCumExtents.capacity() + m_nEmptyEndParts != 0;
}
ILINE int NumParts() const
{
return m_afCumExtents.size();
}
ILINE float TotalExtent() const
{
return !m_afCumExtents.empty() ? m_afCumExtents.back() : 0.f;
}
void Clear()
{
m_afCumExtents.clear();
m_nEmptyEndParts = 0;
}
void AddPart(float fExtent)
{
// Defer empty parts until a non-empty part is added.
if (fExtent <= 0.f)
{
m_nEmptyEndParts++;
}
else
{
float fTotal = TotalExtent();
for (; m_nEmptyEndParts; m_nEmptyEndParts--)
{
m_afCumExtents.push_back(fTotal);
}
m_afCumExtents.push_back(fTotal + fExtent);
}
}
void ReserveParts(int nCount)
{
m_afCumExtents.reserve(nCount);
}
// Find element in sorted array <= index (normalized 0 to 1)
int GetPart(float fIndex) const
{
int last = m_afCumExtents.size() - 1;
if (last <= 0)
{
return last;
}
fIndex *= m_afCumExtents[last];
// Binary search thru array.
int lo = 0, hi = last;
while (lo < hi)
{
int i = (lo + hi) >> 1;
if (fIndex < m_afCumExtents[i])
{
hi = i;
}
else
{
lo = i + 1;
}
}
assert(lo == 0 || m_afCumExtents[lo] > m_afCumExtents[lo - 1]);
return lo;
}
int RandomPart() const
{
return GetPart(cry_random(0.0f, 1.0f));
}
protected:
DynArray<float> m_afCumExtents;
int m_nEmptyEndParts;
};
class CGeomExtents
{
public:
ILINE CGeomExtents()
: m_aExtents(0) {}
~CGeomExtents()
{ delete[] m_aExtents; }
void Clear()
{
delete[] m_aExtents;
m_aExtents = 0;
}
ILINE CGeomExtent const& operator [](EGeomForm eForm) const
{
assert(eForm >= 0 && eForm < MaxGeomForm);
if (m_aExtents)
{
return m_aExtents[eForm];
}
static CGeomExtent s_empty;
return s_empty;
}
ILINE CGeomExtent& Make(EGeomForm eForm)
{
assert(eForm >= 0 && eForm < MaxGeomForm);
if (!m_aExtents)
{
m_aExtents = new CGeomExtent[4];
}
return m_aExtents[eForm];
}
protected:
CGeomExtent* m_aExtents;
};
// Other random/extent functions
inline float ScaleExtent(EGeomForm eForm, float fScale)
{
switch (eForm)
{
default:
return 1;
case GeomForm_Edges:
return fScale;
case GeomForm_Surface:
return fScale * fScale;
case GeomForm_Volume:
return fScale * fScale * fScale;
}
}
inline float BoxExtent(EGeomForm eForm, Vec3 const& vSize)
{
switch (eForm)
{
default:
assert(0);
case GeomForm_Vertices:
return 8.f;
case GeomForm_Edges:
return (vSize.x + vSize.y + vSize.z) * 8.f;
case GeomForm_Surface:
return (vSize.x * vSize.y + vSize.x * vSize.z + vSize.y * vSize.z) * 8.f;
case GeomForm_Volume:
return vSize.x * vSize.y * vSize.z * 8.f;
}
}
// Utility functions.
template<class T>
inline
const typename T::value_type& RandomElem(const T& array)
{
int n = cry_random(0U, array.size() - 1);
return array[n];
}
// Geometric primitive randomizing functions.
ILINE void BoxRandomPos(PosNorm& ran, EGeomForm eForm, Vec3 const& vSize)
{
ran.vPos = cry_random_componentwise(-vSize, vSize);
ran.vNorm = ran.vPos;
if (eForm != GeomForm_Volume)
{
// Generate a random corner, for collapsing random point.
int nCorner = cry_random(0, 7);
ran.vNorm.x = (((nCorner & 1) << 1) - 1) * vSize.x;
ran.vNorm.y = (((nCorner & 2)) - 1) * vSize.y;
ran.vNorm.z = (((nCorner & 4) >> 1) - 1) * vSize.z;
if (eForm == GeomForm_Vertices)
{
ran.vPos = ran.vNorm;
}
else if (eForm == GeomForm_Surface)
{
// Collapse one axis.
float fAxis = cry_random(0.0f, vSize.x * vSize.y + vSize.y * vSize.z + vSize.z * vSize.x);
if ((fAxis -= vSize.y * vSize.z) < 0.f)
{
ran.vPos.x = ran.vNorm.x;
ran.vNorm.y = ran.vNorm.z = 0.f;
}
else if ((fAxis -= vSize.z * vSize.x) < 0.f)
{
ran.vPos.y = ran.vNorm.y;
ran.vNorm.x = ran.vNorm.z = 0.f;
}
else
{
ran.vPos.z = ran.vNorm.z;
ran.vNorm.x = ran.vNorm.y = 0.f;
}
}
else if (eForm == GeomForm_Edges)
{
// Collapse 2 axes.
float fAxis = cry_random(0.0f, vSize.x + vSize.y + vSize.z);
if ((fAxis -= vSize.x) < 0.f)
{
ran.vPos.y = ran.vNorm.y;
ran.vPos.z = ran.vNorm.z;
ran.vNorm.x = 0.f;
}
else if ((fAxis -= vSize.y) < 0.f)
{
ran.vPos.x = ran.vNorm.x;
ran.vPos.z = ran.vNorm.z;
ran.vNorm.y = 0.f;
}
else
{
ran.vPos.x = ran.vNorm.x;
ran.vPos.y = ran.vNorm.y;
ran.vNorm.z = 0.f;
}
}
}
ran.vNorm.Normalize();
}
inline float CircleExtent(EGeomForm eForm, float fRadius)
{
switch (eForm)
{
case GeomForm_Edges:
return gf_PI2 * fRadius;
case GeomForm_Surface:
return gf_PI * square(fRadius);
default:
return 1.f;
}
}
inline Vec2 CircleRandomPoint(EGeomForm eForm, float fRadius)
{
Vec2 vPt;
switch (eForm)
{
case GeomForm_Edges:
// Generate random angle.
sincos_tpl(cry_random(0.0f, gf_PI2), &vPt.y, &vPt.x);
vPt *= fRadius;
break;
case GeomForm_Surface:
// Generate random angle, and radius, adjusted for even distribution.
sincos_tpl(cry_random(0.0f, gf_PI2), &vPt.y, &vPt.x);
vPt *= sqrt(cry_random(0.0f, 1.0f)) * fRadius;
break;
default:
vPt.x = vPt.y = 0.f;
}
return vPt;
}
inline float SphereExtent(EGeomForm eForm, float fRadius)
{
switch (eForm)
{
default:
assert(0);
case GeomForm_Vertices:
case GeomForm_Edges:
return 0.f;
case GeomForm_Surface:
return gf_PI * 4.f * sqr(fRadius);
case GeomForm_Volume:
return gf_PI * 4.f / 3.f * cube(fRadius);
}
}
inline void SphereRandomPos(PosNorm& ran, EGeomForm eForm, float fRadius)
{
switch (eForm)
{
default:
assert(0);
case GeomForm_Vertices:
case GeomForm_Edges:
ran.vPos.zero();
ran.vNorm.zero();
return;
case GeomForm_Surface:
case GeomForm_Volume:
{
// Generate point on surface, as normal.
float fPhi = cry_random(0.0f, gf_PI2);
float fZ = cry_random(-1.f, 1.f);
float fH = sqrt_tpl(1.f - fZ * fZ);
sincos_tpl(fPhi, &ran.vNorm.y, &ran.vNorm.x);
ran.vNorm.x *= fH;
ran.vNorm.y *= fH;
ran.vNorm.z = fZ;
ran.vPos = ran.vNorm;
if (eForm == GeomForm_Volume)
{
float fV = cry_random(0.0f, 1.0f);
float fR = pow_tpl(fV, 0.333333f);
ran.vPos *= fR;
}
ran.vPos *= fRadius;
break;
}
}
}
// Triangle randomisation functions
inline float TriExtent(EGeomForm eForm, Vec3 const aPos[3])
{
switch (eForm)
{
default:
assert(0);
case GeomForm_Edges:
return (aPos[1] - aPos[0]).GetLengthFast();
case GeomForm_Surface:
return ((aPos[1] - aPos[0]) % (aPos[2] - aPos[0])).GetLengthFast() * 0.5f;
case GeomForm_Volume:
// Generate signed volume of pyramid by computing triple product of vertices.
return ((aPos[0] ^ aPos[1]) | aPos[2]) / 6.0f;
}
}
inline void TriRandomPos(PosNorm& ran, EGeomForm eForm, PosNorm const aRan[3], bool bDoNormals)
{
// Generate interpolators for verts.
switch (eForm)
{
default:
assert(0);
case GeomForm_Vertices:
ran = aRan[0];
return;
case GeomForm_Edges:
{
float t = cry_random(0.0f, 1.0f);
ran.vPos = aRan[0].vPos * (1.f - t) + aRan[1].vPos * t;
if (bDoNormals)
{
ran.vNorm = aRan[0].vNorm * (1.f - t) + aRan[1].vNorm * t;
}
break;
}
case GeomForm_Surface:
{
float t0 = cry_random(0.0f, 1.0f);
float t1 = cry_random(0.0f, 1.0f);
float t2 = cry_random(0.0f, 1.0f);
float fSum = t0 + t1 + t2;
ran.vPos = (aRan[0].vPos * t0 + aRan[1].vPos * t1 + aRan[2].vPos * t2) * (1.f / fSum);
if (bDoNormals)
{
ran.vNorm = aRan[0].vNorm * t0 + aRan[1].vNorm * t1 + aRan[2].vNorm * t2;
}
break;
}
case GeomForm_Volume:
{
float t0 = cry_random(0.0f, 1.0f);
float t1 = cry_random(0.0f, 1.0f);
float t2 = cry_random(0.0f, 1.0f);
float t3 = cry_random(0.0f, 1.0f);
float fSum = t0 + t1 + t2 + t3;
ran.vPos = (aRan[0].vPos * t0 + aRan[1].vPos * t1 + aRan[2].vPos * t2) * (1.f / fSum);
if (bDoNormals)
{
ran.vNorm = (aRan[0].vNorm * t0 + aRan[1].vNorm * t1 + aRan[2].vNorm * t2) * (1.f - t3) + ran.vPos.GetNormalizedFast() * t3;
}
break;
}
}
if (bDoNormals)
{
ran.vNorm.Normalize();
}
}
// Mesh random pos functions
inline int TriMeshPartCount(EGeomForm eForm, int nIndices)
{
switch (eForm)
{
default:
assert(0);
case GeomForm_Vertices:
case GeomForm_Edges:
// Number of edges = verts.
return nIndices;
case GeomForm_Surface:
case GeomForm_Volume:
// Number of tris.
assert(nIndices % 3 == 0);
return nIndices / 3;
}
}
inline int TriIndices(int aIndices[3], int nPart, EGeomForm eForm)
{
switch (eForm)
{
default:
assert(0);
case GeomForm_Vertices: // Part is vert index
aIndices[0] = nPart;
return 1;
case GeomForm_Edges: // Part is vert index
aIndices[0] = nPart;
aIndices[1] = nPart % 3 < 2 ? nPart + 1 : nPart - 2;
return 2;
case GeomForm_Surface: // Part is tri index
case GeomForm_Volume:
aIndices[0] = nPart * 3;
aIndices[1] = aIndices[0] + 1;
aIndices[2] = aIndices[0] + 2;
return 3;
}
}
#endif // CRYINCLUDE_CRYCOMMON_GEOMQUERY_H
Code/CryEngine/CryCommon/HashGrid.h
-617
View File
@@ -1,617 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#ifndef CRYINCLUDE_CRYCOMMON_HASHGRID_H
#define CRYINCLUDE_CRYCOMMON_HASHGRID_H
#pragma once
template<typename Key, typename DiscreetKey>
struct hash_grid_2d
{
typedef Key key_type;
typedef typename key_type::value_type key_value;
typedef DiscreetKey discreet_type;
typedef typename discreet_type::value_type discreet_value;
typedef hash_grid_2d<Key, DiscreetKey> type;
hash_grid_2d(const key_value& cellSizeX, const key_value& cellSizeY, const key_value& cellSizeZ)
: scaleFactorX(1 / cellSizeX)
, scaleFactorY(1 / cellSizeY)
{
}
inline discreet_type discreet(const key_type& key) const
{
return discreet_type(static_cast<discreet_value>(key[0] * scaleFactorX),
static_cast<discreet_value>(key[1] * scaleFactorY),
static_cast<discreet_value>(0));
}
inline size_t hash(const key_type& key) const
{
return hash(discreet(key));
}
inline size_t hash(const discreet_type& discreet) const
{
return static_cast<size_t>(
(discreet[0] ^ 920129341) +
(discreet[1] ^ 1926129311));
}
inline void swap(type& other)
{
std::swap(scaleFactorX, other.scaleFactorX);
std::swap(scaleFactorY, other.scaleFactorY);
}
private:
key_value scaleFactorX;
key_value scaleFactorY;
};
template<typename Key, typename DiscreetKey>
struct hash_grid_3d
{
typedef Key key_type;
typedef typename key_type::value_type key_value;
typedef DiscreetKey discreet_type;
typedef typename discreet_type::value_type discreet_value;
typedef hash_grid_3d<Key, DiscreetKey> type;
hash_grid_3d(const key_value& cellSizeX, const key_value& cellSizeY, const key_value& cellSizeZ)
: scaleFactorX(1 / cellSizeX)
, scaleFactorY(1 / cellSizeY)
, scaleFactorZ(1 / cellSizeZ)
{
}
inline discreet_type discreet(const key_type& key) const
{
return discreet_type(static_cast<discreet_value>(key[0] * scaleFactorX),
static_cast<discreet_value>(key[1] * scaleFactorY),
static_cast<discreet_value>(key[2] * scaleFactorZ));
}
inline size_t hash(const key_type& key) const
{
return hash(discreet(key));
}
inline size_t hash(const discreet_type& discreet) const
{
return static_cast<size_t>(
(discreet[0] ^ 920129341ul) +
(discreet[1] ^ 1926129311ul) +
(discreet[2] ^ 3926129401ul));
}
inline void swap(type& other)
{
std::swap(scaleFactorX, other.scaleFactorX);
std::swap(scaleFactorY, other.scaleFactorY);
std::swap(scaleFactorZ, other.scaleFactorZ);
}
private:
key_value scaleFactorX;
key_value scaleFactorY;
key_value scaleFactorZ;
};
template<typename KeyType, typename ValueType>
struct hash_grid_no_position
{
KeyType operator()(const ValueType&) const
{
switch (0)
{
case 0:
"hash_grid query performed without a valid position-retriever implementation";
}
;
return KeyType();
}
};
template<int NumberOfCells, typename ValueType, typename KeyHash,
typename PositionRetriever = hash_grid_no_position<typename KeyHash::key_type, ValueType> >
class hash_grid
: protected KeyHash
{
public:
enum
{
CellCount = NumberOfCells,
};
typedef ValueType value_type;
typedef KeyHash key_hash;
typedef typename key_hash::key_type key_type;
typedef typename key_type::value_type key_value;
typedef typename key_hash::discreet_type discreet_type;
typedef typename discreet_type::value_type discreet_value;
typedef PositionRetriever position_retriever_type;
typedef hash_grid<NumberOfCells, ValueType, KeyHash, PositionRetriever> type;
typedef std::vector<value_type> items_type;
struct cell_type
{
cell_type()
: query(0)
{
}
mutable uint32 query;
items_type items;
};
typedef std::vector<cell_type> cells_type;
inline hash_grid(float cellSizeX = 20.0f, float cellSizeY = 20.0f, float cellSizeZ = 20.0f,
const position_retriever_type& _position = position_retriever_type())
: key_hash(cellSizeX, cellSizeY, cellSizeZ)
, position(_position)
, m_cells(CellCount)
, m_count(0)
, m_query(0)
{
}
inline void clear()
{
m_cells.clear();
m_cells.resize(CellCount);
m_count = 0;
m_query = 0;
}
inline void swap(type& other)
{
m_cells.swap(other);
std::swap(m_count, other.m_count);
key_hash::swap(other);
}
inline size_t size() const
{
return m_count;
}
inline bool empty() const
{
return m_count == 0;
}
struct iterator
{
iterator()
: cell(~0u)
, item(~0u)
, grid(0)
{
}
value_type& operator*()
{
return grid->m_cells[cell][item];
}
const value_type& operator*() const
{
return grid->m_cells[cell][item];
}
value_type* operator->() const
{
return (&**this);
}
iterator& operator++()
{
assert(cell < grid_type::CellCount);
cell_type& items = grid->m_cells[cell];
if (!items.empty() && (item < items.size() - 1))
{
++item;
}
else
{
item = 0;
++cell;
while ((cell < type::CellCount) && grid->m_cells[cell].empty())
{
++cell;
}
}
return *this;
}
iterator operator++(int)
{
iterator tmp = *this;
++*this;
return tmp;
}
iterator& operator--()
{
if (item > 0)
{
--item;
}
else
{
--cell;
while ((cell > 0) && grid->m_cells[cell].empty())
{
--cell;
}
assert(cell < type::CellCount);
cell_type& items = grid->m_cells[cell];
item = items.size() - 1;
}
return *this;
}
iterator operator--(int)
{
iterator tmp = *this;
++*this;
return tmp;
}
bool operator==(const iterator& other) const
{
return (cell == other.cell) && (item == other.item) && (grid == other.grid);
}
bool operator!=(const iterator& other) const
{
return !(*this == other);
}
private:
friend class hash_grid<NumberOfCells, ValueType, KeyHash, PositionRetriever>;
typedef hash_grid<NumberOfCells, ValueType, KeyHash, PositionRetriever> grid_type;
iterator(size_t _cell, size_t _item, grid_type* _grid)
: grid(_grid)
, item(_item)
, cell(_cell)
{
}
grid_type* grid;
size_t cell;
size_t item;
};
inline iterator begin()
{
uint32 item = 0;
uint32 cell = 0;
while ((cell < type::CellCount) && m_cells[cell].empty())
{
++cell;
}
return iterator(cell, item, this);
}
inline iterator end()
{
return iterator(CellCount, 0, this);
}
inline iterator insert(const key_type& key, const value_type& value)
{
size_t hash_value = KeyHash::hash(key);
size_t index = hash_value % CellCount;
cell_type& cell = m_cells[index];
items_type& items = cell.items;
items.push_back(value);
++m_count;
return iterator(index, items.size() - 1, this);
}
inline void erase(const key_type& key, const value_type& value)
{
size_t hash_value = KeyHash::hash(key);
size_t index = hash_value % CellCount;
cell_type& cell = m_cells[index];
items_type& items = cell.items;
typename items_type::iterator it = items.begin();
typename items_type::iterator end = items.end();
for (; it != end; ++it)
{
if (*it == value)
{
std::swap(*it, items.back());
items.pop_back();
--m_count;
return;
}
}
}
inline iterator erase(const iterator& it)
{
--m_count;
cell_type& cell = m_cells[it.cell];
items_type& items = cell.items;
std::swap(items[it.item], items.back());
items.pop_back();
if (!items.empty())
{
return it;
}
uint32 index = it.cell;
while ((index < CellCount) && m_cells[index].items.empty())
{
++index;
}
return iterator(index, 0, this);
}
inline iterator find(const key_type& key, const value_type& value)
{
size_t index = KeyHash::hash(key) % CellCount;
cell_type& cell = m_cells[index];
items_type& items = cell.items;
typename items_type::iterator it = items.begin();
typename items_type::iterator iend = items.end();
for (; it != iend; ++it)
{
if (*it == value)
{
return iterator(index, it - items.begin(), this);
}
}
return end();
}
inline iterator move(const iterator& it, const key_type& to)
{
size_t index = KeyHash::hash(to) % CellCount;
if (index == it.cell)
{
return it;
}
cell_type& cell = m_cells[it.cell];
items_type& items = cell.items;
typename items_type::iterator iit = items.begin() + it.item;
cell_type& to_cell = m_cells[index];
items_type& to_items = to_cell.items;
to_items.push_back(*iit);
std::swap(items[it.item], items.back());
items.pop_back();
return iterator(index, to_items.size() - 1, this);
}
template<typename Container>
uint32 query_sphere(const key_type& center, const key_value& radius, Container& container) const
{
uint32 count = 0;
if (!empty())
{
++m_query;
key_type minc(center - key_type(radius));
key_type maxc(center + key_type(radius));
discreet_type mind = KeyHash::discreet(minc);
discreet_type maxd = KeyHash::discreet(maxc);
discreet_type current = mind;
float radius_sq = radius * radius;
for (; current[0] <= maxd[0]; ++current[0])
{
for (; current[1] <= maxd[1]; ++current[1])
{
for (; current[2] <= maxd[2]; ++current[2])
{
size_t hash_value = KeyHash::hash(current);
size_t index = hash_value % CellCount;
const cell_type& cell = m_cells[index];
if (cell.query != m_query)
{
cell.query = m_query;
const items_type& items = cell.items;
typename items_type::const_iterator it = items.begin();
typename items_type::const_iterator end = items.end();
for (; it != end; ++it)
{
if ((position(*it) - center).len2() <= radius_sq)
{
container.push_back(*it);
++count;
}
}
}
}
current[2] = mind[2];
}
current[1] = mind[1];
}
}
return count;
}
template<typename Container>
uint32 query_sphere_distance(const key_type& center, const key_value& radius, Container& container) const
{
uint32 count = 0;
if (!empty())
{
++m_query;
key_type minc(center - key_type(radius));
key_type maxc(center + key_type(radius));
discreet_type mind = KeyHash::discreet(minc);
discreet_type maxd = KeyHash::discreet(maxc);
discreet_type current = mind;
float radius_sq = radius * radius;
for (; current[0] <= maxd[0]; ++current[0])
{
for (; current[1] <= maxd[1]; ++current[1])
{
for (; current[2] <= maxd[2]; ++current[2])
{
size_t hash_value = KeyHash::hash(current);
size_t index = hash_value % CellCount;
const cell_type& cell = m_cells[index];
if (cell.query != m_query)
{
cell.query = m_query;
const items_type& items = cell.items;
typename items_type::const_iterator it = items.begin();
typename items_type::const_iterator end = items.end();
for (; it != end; ++it)
{
float distance_sq = (position(*it) - center).len2();
if (distance_sq <= radius_sq)
{
container.push_back(std::make_pair(distance_sq, *it));
++count;
}
}
}
}
current[2] = mind[2];
}
current[1] = mind[1];
}
}
return count;
}
template<typename Container>
uint32 query_box(const key_type& minc, const key_type& maxc, Container& container) const
{
uint32 count = 0;
if (!empty())
{
++m_query;
discreet_type mind = KeyHash::discreet(minc);
discreet_type maxd = KeyHash::discreet(maxc);
discreet_type current = mind;
for (; current[0] <= maxd[0]; ++current[0])
{
for (; current[1] <= maxd[1]; ++current[1])
{
for (; current[2] <= maxd[2]; ++current[2])
{
size_t hash_value = KeyHash::hash(current);
size_t index = hash_value % CellCount;
const cell_type& cell = m_cells[index];
if (cell.query != m_query)
{
cell.query = m_query;
const items_type& items = cell.items;
typename items_type::const_iterator it = items.begin();
typename items_type::const_iterator end = items.end();
for (; it != end; ++it)
{
key_type pos = position(*it);
if (pos[0] >= minc[0] &&
pos[1] >= minc[1] &&
pos[2] >= minc[2] &&
pos[0] <= maxc[0] &&
pos[1] <= maxc[1] &&
pos[2] <= maxc[2])
{
container.push_back(*it);
++count;
}
}
}
}
current[2] = mind[2];
}
current[1] = mind[1];
}
}
return count;
}
protected:
position_retriever_type position;
cells_type m_cells;
uint32 m_count;
mutable uint32 m_query;
};
#endif // CRYINCLUDE_CRYCOMMON_HASHGRID_H
Code/CryEngine/CryCommon/HeapContainer.h
-250
View File
@@ -1,250 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
// Containers that use their own heap for allocation.
#ifndef CRYINCLUDE_CRYCOMMON_HEAPCONTAINER_H
#define CRYINCLUDE_CRYCOMMON_HEAPCONTAINER_H
#pragma once
#include "PoolAllocator.h"
//---------------------------------------------------------------------------
template<class T, typename L = stl::PSyncMultiThread>
struct HeapQueue
: public L
{
typedef typename L::Lock Lock;
HeapQueue()
{
reset();
}
T* push_back()
{
Lock lock(*this);
return push_back(m_Allocator.New());
}
template<class I>
T* push_back(I const& init)
{
Lock lock(*this);
Node* pNode = (Node*)m_Allocator.Allocate();
new(static_cast<T*>(pNode))T(init);
return push_back(pNode);
}
template<class I, class J>
T* push_back(I const& i, J const& j)
{
Lock lock(*this);
Node* pNode = (Node*)m_Allocator.Allocate();
new(static_cast<T*>(pNode))T(i, j);
return push_back(pNode);
}
T* pop_front()
{
Lock lock(*this);
// Quick check, before locking.
if (empty())
{
return 0;
}
Node* pNode = *m_ppHead;
if (pNode)
{
m_ppHead = &(*m_ppHead)->pNext;
m_nQueued--;
validate();
}
return pNode;
}
void clear()
{
Lock lock(*this);
validate();
// Destruct all elements.
size_t nCheckAlloc = 0;
while (m_pList)
{
nCheckAlloc++;
Node* pNext = m_pList->pNext;
m_pList->~Node();
m_pList = pNext;
}
assert(nCheckAlloc == m_nAlloc);
// Empty queue structure.
reset();
// Free pool memory all at once.
m_Allocator.FreeMemory(false);
}
size_t size() const
{
return m_nQueued;
}
bool empty() const
{
return m_nQueued == 0;
}
size_t allocated_memory() const
{
// Amortise allocated mem over all list instances.
Lock lock(*this);
return m_Allocator.GetTotalMemory().nAlloc;
}
// Additional lock against storage deletion.
L ClearLock;
void GetMemoryUsage(ICrySizer* pSizer) const
{
pSizer->AddObject(m_Allocator);
}
protected:
struct Node
: T
{
Node* pNext;
};
Node* m_pList; // First (allocated) node in list.
Node** m_ppHead; // Points to pointer to front of queue, for popping.
Node** m_ppTail; // Points to pointer at end of list, and of queue, for pushing.
size_t m_nAlloc, m_nQueued;
void validate()
{
assert(m_nQueued <= m_nAlloc);
assert(m_ppHead);
assert(m_ppTail);
assert(!*m_ppTail);
assert((m_nQueued == 0) == !*m_ppHead);
assert((m_nQueued == 0) == (m_ppHead == m_ppTail));
assert((m_nAlloc == 0) == (m_ppTail == &m_pList));
assert((m_nAlloc == 0) == !m_pList);
}
void reset()
{
m_pList = 0;
m_ppHead = m_ppTail = &m_pList;
m_nAlloc = m_nQueued = 0;
validate();
}
Node* push_back(Node* pNode)
{
pNode->pNext = 0;
*m_ppTail = pNode;
m_ppTail = &pNode->pNext;
m_nAlloc++;
m_nQueued++;
validate();
return pNode;
}
// Allocate all elements from an exclusive pool.
// Any locking is performed by the queue, no further locking needed in allocator.
stl::TPoolAllocator<Node, stl::PSyncNone> m_Allocator;
};
//---------------------------------------------------------------------------
template<class T, class C = std::less<T>, typename L = stl::PSyncNone>
struct HeapPriorityQueue
: public HeapQueue<T, L>
{
// Hand-holding for brain-dead template compiler.
typedef HeapQueue<T, L> super;
typedef typename super::Node Node;
using super::empty;
using super::validate;
using super::m_ppHead;
using super::m_ppTail;
using super::m_nQueued;
public:
typedef typename super::Lock Lock;
// Pop the "largest" element, using class C.
T* pop_largest()
{
Lock lock(*this);
if (!empty())
{
C comp;
// Find highest-valued item.
// To do: improve linear search! Use priority queue.
Node** ppTop = m_ppHead;
for (Node** ppNode = &(*m_ppHead)->pNext; *ppNode; ppNode = &(*ppNode)->pNext)
{
if (comp(**ppTop, **ppNode))
{
ppTop = ppNode;
}
}
Node* pTop = *ppTop;
// Move link to head.
if (ppTop != m_ppHead)
{
if (!pTop->pNext)
{
// End of list.
m_ppTail = ppTop;
}
*ppTop = pTop->pNext;
pTop->pNext = *m_ppHead;
*m_ppHead = pTop;
}
// Pop head.
m_ppHead = &pTop->pNext;
m_nQueued--;
validate();
return pTop;
}
else
{
return NULL;
}
}
void GetMemoryUsage(ICrySizer* pSizer) const
{
HeapQueue<T, L>::GetMemoryUsage(pSizer);
}
};
#endif // CRYINCLUDE_CRYCOMMON_HEAPCONTAINER_H
Code/CryEngine/CryCommon/IChunkFile.h
-103
View File
@@ -1,103 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#ifndef CRYINCLUDE_CRYCOMMON_ICHUNKFILE_H
#define CRYINCLUDE_CRYCOMMON_ICHUNKFILE_H
#pragma once
#include "CryHeaders.h"
//////////////////////////////////////////////////////////////////////////
// Description:
// Chunked File (.cgf, .chr etc.) interface
//////////////////////////////////////////////////////////////////////////
struct IChunkFile
: _reference_target_t
{
//////////////////////////////////////////////////////////////////////////
// Chunk Description.
//////////////////////////////////////////////////////////////////////////
struct ChunkDesc
{
ChunkTypes chunkType;
int chunkVersion;
int chunkId;
uint32 fileOffset;
void* data;
uint32 size;
bool bSwapEndian;
//////////////////////////////////////////////////////////////////////////
ChunkDesc()
: chunkType(ChunkType_ANY)
, chunkVersion(0)
, chunkId(0)
, fileOffset(0)
, data(0)
, size(0)
, bSwapEndian(false)
{
}
void GetMemoryUsage([[maybe_unused]] ICrySizer* pSizer) const{ /*nothing*/}
static inline bool LessOffset(const ChunkDesc& d1, const ChunkDesc& d2) { return d1.fileOffset < d2.fileOffset; }
static inline bool LessOffsetByPtr(const ChunkDesc* d1, const ChunkDesc* d2) { return d1->fileOffset < d2->fileOffset; }
static inline bool LessId(const ChunkDesc& d1, const ChunkDesc& d2) { return d1.chunkId < d2.chunkId; }
};
// <interfuscator:shuffle>
virtual void GetMemoryUsage(ICrySizer* pSizer) const = 0;
// Releases chunk file interface.
virtual void Release() = 0;
virtual bool IsReadOnly() const = 0;
virtual bool IsLoaded() const = 0;
virtual bool Read(const char* filename) = 0;
virtual bool ReadFromMemory(const void* pData, int nDataSize) = 0;
// Writes chunks to file.
virtual bool Write(const char* filename) = 0;
// Writes chunks to a memory buffer (allocated inside) and returns
// pointer to the allocated memory (pData) and its size (nSize).
// The memory will be released on destruction of the ChunkFile object, or
// on the next WriteToMemoryBuffer() call, or on ReleaseMemoryBuffer() call.
virtual bool WriteToMemoryBuffer(void** pData, int* nSize) = 0;
// Releases memory that was allocated in WriteToMemoryBuffer()
virtual void ReleaseMemoryBuffer() = 0;
// Adds chunk to file, returns ChunkID of the added chunk.
virtual int AddChunk(ChunkTypes chunkType, int chunkVersion, EEndianness eEndianness, const void* chunkData, int chunkSize) = 0;
virtual void DeleteChunkById(int nChunkId) = 0;
virtual void DeleteChunksByType(ChunkTypes nChunkType) = 0;
virtual ChunkDesc* FindChunkByType(ChunkTypes nChunkType) = 0;
virtual ChunkDesc* FindChunkById(int nChunkId) = 0;
// Gets the number of chunks.
virtual int NumChunks() const = 0;
// Gets chunk description at i-th index.
virtual ChunkDesc* GetChunk(int nIndex) = 0;
virtual const ChunkDesc* GetChunk(int nIndex) const = 0;
virtual const char* GetLastError() const = 0;
// </interfuscator:shuffle>
};
#endif // CRYINCLUDE_CRYCOMMON_ICHUNKFILE_H
Code/CryEngine/CryCommon/IColorGradingController.h
-59
View File
@@ -1,59 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#ifndef CRYINCLUDE_CRYCOMMON_ICOLORGRADINGCONTROLLER_H
#define CRYINCLUDE_CRYCOMMON_ICOLORGRADINGCONTROLLER_H
#pragma once
struct SColorChartLayer
{
int m_texID;
float m_blendAmount;
SColorChartLayer()
: m_texID(-1)
, m_blendAmount(-1)
{
}
SColorChartLayer(int texID, float blendAmount)
: m_texID(texID)
, m_blendAmount(blendAmount)
{
}
SColorChartLayer(const SColorChartLayer& rhs)
: m_texID(rhs.m_texID)
, m_blendAmount(rhs.m_blendAmount)
{
}
};
struct IColorGradingController
{
public:
// <interfuscator:shuffle>
virtual ~IColorGradingController(){}
virtual int LoadColorChart(const char* pChartFilePath) const = 0;
virtual int LoadDefaultColorChart() const = 0;
virtual void UnloadColorChart(int texID) const = 0;
virtual void SetLayers(const SColorChartLayer* pLayers, uint32 numLayers) = 0;
// </interfuscator:shuffle>
};
#endif // CRYINCLUDE_CRYCOMMON_ICOLORGRADINGCONTROLLER_H
Code/CryEngine/CryCommon/IEntityRenderState.h
-81
View File
@@ -27,7 +27,6 @@ namespace AZ
struct IMaterial;
struct IVisArea;
struct SRenderingPassInfo;
struct IGeomCache;
struct SRendItemSorter;
struct SFrameLodInfo;
struct pe_params_area;
@@ -259,9 +258,6 @@ struct IRenderNode
virtual struct IStatObj* GetEntityStatObj(unsigned int nPartId = 0, unsigned int nSubPartId = 0, Matrix34A* pMatrix = NULL, bool bReturnOnlyVisible = false);
virtual _smart_ptr<IMaterial> GetEntitySlotMaterial([[maybe_unused]] unsigned int nPartId, [[maybe_unused]] bool bReturnOnlyVisible = false, [[maybe_unused]] bool* pbDrawNear = NULL) { return NULL; }
virtual void SetEntityStatObj([[maybe_unused]] unsigned int nSlot, [[maybe_unused]] IStatObj* pStatObj, [[maybe_unused]] const Matrix34A* pMatrix = NULL) {};
#if defined(USE_GEOM_CACHES)
virtual struct IGeomCacheRenderNode* GetGeomCacheRenderNode([[maybe_unused]] unsigned int nSlot, [[maybe_unused]] Matrix34A* pMatrix = NULL, [[maybe_unused]] bool bReturnOnlyVisible = false) { return NULL; }
#endif
virtual int GetSlotCount() const { return 1; }
// Summary:
@@ -793,81 +789,4 @@ struct IPrismRenderNode
};
#endif // EXCLUDE_DOCUMENTATION_PURPOSE
//////////////////////////////////////////////////////////////////////////
#if defined(USE_GEOM_CACHES)
struct IGeomCacheRenderNode
: public IRenderNode
{
virtual bool LoadGeomCache(const char* sGeomCacheFileName) = 0;
virtual void SetGeomCache(_smart_ptr<IGeomCache> geomCache) = 0;
// Gets the geometry cache that is rendered
virtual IGeomCache* GetGeomCache() const = 0;
// Sets the time in the animation for the current frame.
// Note that you should start streaming before calling this.
virtual void SetPlaybackTime(const float time) = 0;
// Get the current playback time
virtual float GetPlaybackTime() const = 0;
// Check if cache is streaming.
virtual bool IsStreaming() const = 0;
// Need to start streaming before playback, otherwise there will be stalls.
virtual void StartStreaming(const float time = 0.0f) = 0;
// Stops streaming and trashes the buffers
virtual void StopStreaming() = 0;
// Checks if looping is enabled
virtual bool IsLooping() const = 0;
// Enable/disable looping playback
virtual void SetLooping(const bool bEnable) = 0;
// Gets time delta from current playback position to last ready to play frame
virtual float GetPrecachedTime() const = 0;
// Check if bounds changed since last call to this function
virtual bool DidBoundsChange() = 0;
// Set stand in CGFs and distance
virtual void SetStandIn(const char* pFilePath, const char* pMaterial) = 0;
virtual IStatObj* GetStandIn() = 0;
virtual void SetFirstFrameStandIn(const char* pFilePath, const char* pMaterial) = 0;
virtual IStatObj* GetFirstFrameStandIn() = 0;
virtual void SetLastFrameStandIn(const char* pFilePath, const char* pMaterial) = 0;
virtual IStatObj* GetLastFrameStandIn() = 0;
virtual void SetStandInDistance(const float distance) = 0;
virtual float GetStandInDistance() = 0;
// Set distance at which cache will start streaming automatically (0 means no auto streaming)
virtual void SetStreamInDistance(const float distance) = 0;
virtual float GetStreamInDistance() = 0;
// Start/Stop drawing the cache
virtual void SetDrawing(bool bDrawing) = 0;
// Debug draw geometry
virtual void DebugDraw(const struct SGeometryDebugDrawInfo& info, float fExtrudeScale = 0.01f, uint nodeIndex = 0) const = 0;
// Ray intersection against cache
virtual bool RayIntersection(struct SRayHitInfo& hitInfo, _smart_ptr<IMaterial> pCustomMtl = NULL, uint* pHitNodeIndex = NULL) const = 0;
// Set max view distance
virtual void SetBaseMaxViewDistance(float maxViewDistance) = 0;
// Get node information
virtual uint GetNodeCount() const = 0;
virtual Matrix34 GetNodeTransform(const uint nodeIndex) const = 0;
virtual const char* GetNodeName(const uint nodeIndex) const = 0; // Node name is only stored in editor
virtual uint32 GetNodeNameHash(const uint nodeIndex) const = 0;
virtual bool IsNodeDataValid(const uint nodeIndex) const = 0; // Returns false if cache isn't loaded yet or index is out of range
};
#endif
#endif // CRYINCLUDE_CRYCOMMON_IENTITYRENDERSTATE_H
Code/CryEngine/CryCommon/IFuncVariable.h
-268
View File
@@ -1,268 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#ifndef CRYINCLUDE_CRYCOMMON_IFUNCVARIABLE_H
#define CRYINCLUDE_CRYCOMMON_IFUNCVARIABLE_H
#pragma once
#include "Cry_Vector2.h"
#include "Cry_Vector3.h"
#include "Cry_Matrix33.h"
#include "Cry_Color.h"
#include "smartptr.h"
#include "StringUtils.h"
class ITexture;
enum FuncParamType
{
e_FLOAT, e_INT, e_BOOL, e_VEC2, e_VEC3, e_VEC4, e_COLOR, e_MATRIX33,
// Though all types of textures are using the same class, it's important for editor to differentiate between them:
e_TEXTURE2D, e_TEXTURE3D, e_TEXTURE_CUBE
};
class IFuncVariable
: public _reference_target_t
{
public:
// <interfuscator:shuffle>
virtual ~IFuncVariable(){};
virtual float GetMin() const = 0;
virtual float GetMax() const = 0;
virtual void InvokeSetter(void* param) = 0;
virtual int GetInt() const = 0;
virtual float GetFloat() const = 0;
virtual bool GetBool() const = 0;
virtual Vec2 GetVec2() const = 0;
virtual Vec3 GetVec3() const = 0;
virtual Vec4 GetVec4() const = 0;
virtual ColorF GetColorF() const = 0;
virtual Matrix33 GetMatrix33() const = 0;
virtual ITexture* GetTexture() const = 0;
// </interfuscator:shuffle>
enum FuncParamType paramType; // float, string, int, vec3 etc
string name;
#if defined(FLARES_SUPPORT_EDITING)
string humanName;
string description;
#endif
};
template <class T>
class MFPVariable
: public IFuncVariable
{
public:
typedef void (T::* OpticsBase_MFPtr)();
OpticsBase_MFPtr pSetter;
OpticsBase_MFPtr pGetter;
T* pObj;
std::pair<float, float> range;
private:
MFPVariable ()
{
Set(e_INT, "", "", NULL, NULL, NULL);
}
public:
float GetMin() const override { return range.first; }
float GetMax() const override { return range.second; }
MFPVariable(FuncParamType type, const char* _humanname, const char* _description, T* obj, OpticsBase_MFPtr setter, OpticsBase_MFPtr getter, float fMin = 0, float fMax = 1.0f)
{
Set(type, _humanname, _description, obj, setter, getter, fMin, fMax);
}
void Set(FuncParamType type, const char* _humanname, const char* _description, T* obj, OpticsBase_MFPtr setter, OpticsBase_MFPtr getter, float fMin = 0, float fMax = 1.0f)
{
paramType = type;
char _nameNoSpace[50];
cry_strcpy(_nameNoSpace, _humanname);
char* p1 = _nameNoSpace;
char* p2 = p1;
while (*p1 != 0)
{
if ((*p1) == ' ')
{
++p1;
}
else
{
*p2++ = *p1++;
}
}
*p2 = 0;
name = _nameNoSpace;
#if defined(FLARES_SUPPORT_EDITING)
humanName = _humanname;
description = _description;
#endif
pObj = obj;
pSetter = setter;
pGetter = getter;
range.first = fMin;
range.second = fMax;
}
#define INVOKE_SETTER(PARAM_TYPE, param) (pObj->*(reinterpret_cast<void (T::*)(PARAM_TYPE)>(pSetter)))(*(PARAM_TYPE*)param)
#define INVOKE_SETTER_P(PARAM_TYPE, param) (pObj->*(reinterpret_cast<void (T::*)(PARAM_TYPE)>(pSetter)))((PARAM_TYPE)param)
void InvokeSetter(void* param) override
{
switch (paramType)
{
case e_FLOAT:
INVOKE_SETTER(float, param);
break;
case e_INT:
INVOKE_SETTER(int, param);
break;
case e_VEC2:
INVOKE_SETTER(Vec2, param);
break;
case e_VEC3:
INVOKE_SETTER(Vec3, param);
break;
case e_VEC4:
INVOKE_SETTER(Vec4, param);
break;
case e_BOOL:
INVOKE_SETTER(bool, param);
break;
case e_COLOR:
INVOKE_SETTER(ColorF, param);
break;
case e_MATRIX33:
INVOKE_SETTER(Matrix33, param);
break;
case e_TEXTURE2D:
INVOKE_SETTER_P(ITexture*, param);
break;
case e_TEXTURE3D:
INVOKE_SETTER_P(ITexture*, param);
break;
case e_TEXTURE_CUBE:
INVOKE_SETTER_P(ITexture*, param);
break;
}
}
#define INVOKE_GETTER(PARAM_TYPE) ((pObj->*reinterpret_cast<PARAM_TYPE (T::*)()>(pGetter))())
int GetInt() const override {return INVOKE_GETTER(int); }
float GetFloat() const override {return INVOKE_GETTER(float); }
bool GetBool() const override {return INVOKE_GETTER(bool); }
Vec2 GetVec2() const override {return INVOKE_GETTER(Vec2); }
Vec3 GetVec3() const override {return INVOKE_GETTER(Vec3); }
Vec4 GetVec4() const override {return INVOKE_GETTER(Vec4); }
ColorF GetColorF() const override {return INVOKE_GETTER(ColorF); }
Matrix33 GetMatrix33() const override {return INVOKE_GETTER(Matrix33); }
ITexture* GetTexture() const override {return INVOKE_GETTER(ITexture*); }
};
class FuncVariableGroup
{
private:
AZStd::vector<_smart_ptr<IFuncVariable> > variables;
string m_name;
#if defined(FLARES_SUPPORT_EDITING)
string m_humanname;
#endif
bool bCollapse;
public:
FuncVariableGroup()
: bCollapse(false)
{
SetName("");
}
~FuncVariableGroup()
{
}
void SetName(const char* name, [[maybe_unused]] const char* humanname = 0)
{
if (!name)
{
return;
}
m_name = name;
#if defined(FLARES_SUPPORT_EDITING)
m_humanname = humanname ? humanname : name;
#endif
}
const char* GetName()
{
return m_name.c_str();
}
#if defined(FLARES_SUPPORT_EDITING)
const char* GetHumanName()
{
return m_humanname.c_str();
}
#endif
void SetCollapse(bool _bCollapse)
{
bCollapse = _bCollapse;
}
bool IsCollapse()
{
return bCollapse;
}
IFuncVariable* FindVariable(const char* name)
{
for (int i = 0, iSize(variables.size()); i < iSize; ++i)
{
if (variables[i] == NULL)
{
continue;
}
if (!strcmp(variables[i]->name.c_str(), name))
{
return variables[i];
}
}
return NULL;
}
void SetVariable(int nIndex, IFuncVariable* v){ variables[nIndex] = v; }
int GetVariableCount() { return variables.size(); }
IFuncVariable* GetVariable(int nIndex)
{
return variables[nIndex];
}
void AddVariable(IFuncVariable* var)
{
variables.push_back(var);
}
};
#endif // CRYINCLUDE_CRYCOMMON_IFUNCVARIABLE_H
Code/CryEngine/CryCommon/IGeomCache.h
-140
View File
@@ -1,140 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
// Description : Interface for CGeomCache class
#ifndef CRYINCLUDE_CRYCOMMON_IGEOMCACHE_H
#define CRYINCLUDE_CRYCOMMON_IGEOMCACHE_H
#pragma once
#include "smartptr.h" // TYPEDEF_AUTOPTR
// Summary:
// Interface to hold geom cache data
struct IGeomCache
: public IStreamable
{
// Description:
// Increase the reference count of the object.
// Summary:
// Notifies that the object is being used
virtual int AddRef() = 0;
// Description:
// Decrease the reference count of the object. If the reference count
// reaches zero, the object will be deleted from memory.
// Summary:
// Notifies that the object is no longer needed
virtual int Release() = 0;
// Description:
// Checks if the geometry cache was successfully loaded from disk
// Return Value:
// True if valid, otherwise false
virtual bool IsValid() const = 0;
// Description:
// Set default material for the geometry.
// Arguments:
// pMaterial - A valid pointer to the material.
virtual void SetMaterial(_smart_ptr<IMaterial> pMaterial) = 0;
// Description:
// Returns default material of the geometry.
// Arguments:
// nType - Pass 0 to get the physic geometry or pass 1 to get the obstruct geometry
// Return Value:
// A pointer to a phys_geometry class.
virtual _smart_ptr<IMaterial> GetMaterial() = 0;
virtual const _smart_ptr<IMaterial> GetMaterial() const = 0;
// Summary:
// Returns the filename of the object
// Return Value:
// A null terminated string which contain the filename of the object.
virtual const char* GetFilePath() const = 0;
// Summary:
// Returns the duration of the geom cache animation
// Return value:
// float value in seconds
virtual float GetDuration() const = 0;
// Summary:
// Reloads the cache. Need to call this when cache file changed.
virtual void Reload() = 0;
// Summary:
// Returns the max AABB of the geom cache through the whole animation
// Return value:
// The geom cache's max axis aligned bounding box
virtual const AABB& GetAABB() const = 0;
/**
* Tells the GeomCache whether or not it can release its static mesh data
*
* For the new AZ Geom Cache asset we have to be able
* to tell the Geom Cache not to release loaded data.
* This only matters when Geom Caches are not streamed.
*
* The legacy system works like this (if e_streamCGF is 0):
* Load a geom cache entity.
* Entity creates a geom cache render node.
* Node loads geom cache, cache is marked as loaded.
* Render node immediately initializes with the Geom Cache data.
* Because the Geom Cache is not streamed, it releases unneeded data next tick
*
* The AZ system works like this:
* Geom Cache component is created
* Asset is requested
* Asset loads Geom Cache
* Geom Cache loads data and is marked as loaded
* Asset calls AllowReleaseLoadedData(false) and locks loaded state
* Tick happens and data is not freed (this is good, we need that data)
* OnAssetReady event fires and is picked up by Geom Cache Component
* Data is fed from the asset to the Geom Cache Render Node
* Component calls AllowReleaseLoadedData(true)
* Next tick the Geom Cache cleans up unneeded data
*/
virtual void SetProcessedByRenderNode(bool) = 0;
// Summary:
// Returns statistics
// Return value:
// SStatistics struct
struct SStatistics
{
bool m_bPlaybackFromMemory;
float m_averageAnimationDataRate;
uint m_numStaticMeshes;
uint m_numStaticVertices;
uint m_numStaticTriangles;
uint m_numAnimatedMeshes;
uint m_numAnimatedVertices;
uint m_numAnimatedTriangles;
uint m_numMaterials;
uint m_staticDataSize;
uint m_diskAnimationDataSize;
uint m_memoryAnimationDataSize;
};
virtual SStatistics GetStatistics() const = 0;
protected:
virtual ~IGeomCache() {}; // should be never called, use Release() instead
};
#endif // CRYINCLUDE_CRYCOMMON_IGEOMCACHE_H
Code/CryEngine/CryCommon/IImage.h
-76
View File
@@ -1,76 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#ifndef CRYINCLUDE_CRYCOMMON_IIMAGE_H
#define CRYINCLUDE_CRYCOMMON_IIMAGE_H
#pragma once
/**
* Possible errors for IImageFile::mfGet_error.
*/
enum EImFileError
{
eIFE_OK = 0, eIFE_IOerror, eIFE_OutOfMemory, eIFE_BadFormat, eIFE_ChunkNotFound
};
// here are all of the flags that can be passed into the image load flags
#define FIM_NORMALMAP 0x0001
#define FIM_NOTSUPPORTS_MIPS 0x0004
#define FIM_ALPHA 0x0008 // request attached alpha image
#define FIM_DECAL 0x0010
#define FIM_GREYSCALE 0x0020 // hint this texture is greyscale (could be DXT1 with colored artifacts)
#define FIM_STREAM_PREPARE 0x0080
#define FIM_UNUSED_BIT 0x0100 // Free to use
#define FIM_BIG_ENDIANNESS 0x0400 // for textures converted to big endianness format
#define FIM_SPLITTED 0x0800 // for dds textures stored in splitted files
#define FIM_SRGB_READ 0x1000
#define FIM_X360_NOT_PRETILED 0x2000 // for dds textures that cannot be pretiled
#define FIM_UNUSED_BIT_1 0x4000 // Free to use
#define FIM_RENORMALIZED_TEXTURE 0x8000 // for dds textures with EIF_RenormalizedTexture set in the dds header (not currently supported in the engine at runtime)
#define FIM_HAS_ATTACHED_ALPHA 0x10000 // image has an attached alpha image
#define FIM_SUPPRESS_DOWNSCALING 0x20000 // don't allow to drop mips when texture is non-streamable
#define FIM_DX10IO 0x40000 // for dds textures with extended DX10+ header
#define FIM_NOFALLBACKS 0x80000 // if the texture can't be loaded or is not found, do not replace it with a default 'not found' texture.
class IImageFile
{
public:
virtual int AddRef() = 0;
virtual int Release() = 0;
virtual const string& mfGet_filename () const = 0;
virtual int mfGet_width () const = 0;
virtual int mfGet_height () const = 0;
virtual int mfGet_depth () const = 0;
virtual int mfGet_NumSides () const = 0;
virtual EImFileError mfGet_error () const = 0;
virtual byte* mfGet_image (const int nSide) = 0;
virtual bool mfIs_image (const int nSide) const = 0;
virtual ETEX_Format mfGetFormat() const = 0;
virtual ETEX_TileMode mfGetTileMode() const = 0;
virtual int mfGet_numMips () const = 0;
virtual int mfGet_numPersistentMips () const = 0;
virtual int mfGet_Flags () const = 0;
virtual const ColorF& mfGet_minColor () const = 0;
virtual const ColorF& mfGet_maxColor () const = 0;
virtual int mfGet_ImageSize() const = 0;
protected:
virtual ~IImageFile() {}
};
#endif // CRYINCLUDE_CRYCOMMON_IIMAGE_H
Code/CryEngine/CryCommon/IMeshBaking.h
-50
View File
@@ -1,50 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#ifndef CRYINCLUDE_CRYCOMMON_IMESHBAKING_H
#define CRYINCLUDE_CRYCOMMON_IMESHBAKING_H
#pragma once
struct SMeshBakingMaterialParams
{
float rayLength;
float rayIndent;
bool bAlphaCutout;
bool bIgnore;
};
struct SMeshBakingInputParams
{
IStatObj* pCageMesh;
IStatObj* pInputMesh;
const SMeshBakingMaterialParams* pMaterialParams;
ColorF defaultBackgroundColour;
ColorF dilateMagicColour;
int outputTextureWidth;
int outputTextureHeight;
int numMaterialParams;
int nLodId;
bool bDoDilationPass;
bool bSmoothNormals;
bool bSaveSpecular;
_smart_ptr<IMaterial> pMaterial;
};
struct SMeshBakingOutput
{
ITexture* ppOuputTexture[3];
ITexture* ppIntermediateTexture[3];
};
#endif // CRYINCLUDE_CRYCOMMON_IMESHBAKING_H
Code/CryEngine/CryCommon/IObjManager.h
-252
View File
@@ -1,252 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#pragma once
struct IStreamable;
struct SCheckOcclusionJobData;
struct SCheckOcclusionOutput;
class COctreeNode;
struct IStatInstGroup;
namespace NAsyncCull
{
class CCullThread;
}
// Inplace object for IStreamable* to cache StreamableMemoryContentSize
struct SStreamAbleObject
{
explicit SStreamAbleObject(IStreamable* pObj, bool bUpdateMemUsage = true)
: m_pObj(pObj)
, fCurImportance(-1000.f)
{
if (pObj && bUpdateMemUsage)
{
m_nStreamableContentMemoryUsage = pObj->GetStreamableContentMemoryUsage();
}
else
{
m_nStreamableContentMemoryUsage = 0;
}
}
bool operator==(const SStreamAbleObject& rOther) const
{
return m_pObj == rOther.m_pObj;
}
int GetStreamableContentMemoryUsage() const { return m_nStreamableContentMemoryUsage; }
IStreamable* GetStreamAbleObject() const { return m_pObj; }
uint32 GetLastDrawMainFrameId() const
{
return m_pObj->GetLastDrawMainFrameId();
}
float fCurImportance;
private:
IStreamable* m_pObj;
int m_nStreamableContentMemoryUsage;
};
struct SObjManPrecacheCamera
{
SObjManPrecacheCamera()
: vPosition(ZERO)
, vDirection(ZERO)
, bbox(AABB::RESET)
, fImportanceFactor(1.0f)
{
}
Vec3 vPosition;
Vec3 vDirection;
AABB bbox;
float fImportanceFactor;
};
struct SObjManPrecachePoint
{
SObjManPrecachePoint()
: nId(0)
{
}
int nId;
CTimeValue expireTime;
};
struct IObjManager
{
virtual ~IObjManager() {}
virtual void PreloadLevelObjects() = 0;
virtual void UnloadObjects(bool bDeleteAll) = 0;
virtual void CheckTextureReadyFlag() = 0;
virtual void FreeStatObj(IStatObj* pObj) = 0;
virtual _smart_ptr<IStatObj> GetDefaultCGF() = 0;
typedef std::vector< IDecalRenderNode* > DecalsToPrecreate;
virtual DecalsToPrecreate& GetDecalsToPrecreate() = 0;
virtual PodArray<SStreamAbleObject>& GetArrStreamableObjects() = 0;
virtual PodArray<SObjManPrecacheCamera>& GetStreamPreCacheCameras() = 0;
virtual PodArray<COctreeNode*>& GetArrStreamingNodeStack() = 0;
virtual PodArray<SObjManPrecachePoint>& GetStreamPreCachePointDefs() = 0;
typedef std::map<string, IStatObj*, stl::less_stricmp<string> > ObjectsMap;
virtual ObjectsMap& GetNameToObjectMap() = 0;
typedef std::set<IStatObj*> LoadedObjects;
virtual LoadedObjects& GetLoadedObjects() = 0;
virtual Vec3 GetSunColor() = 0;
virtual void SetSunColor(const Vec3& color) = 0;
virtual Vec3 GetSunAnimColor() = 0;
virtual void SetSunAnimColor(const Vec3& color) = 0;
virtual float GetSunAnimSpeed() = 0;
virtual void SetSunAnimSpeed(float sunAnimSpeed) = 0;
virtual AZ::u8 GetSunAnimPhase() = 0;
virtual void SetSunAnimPhase(AZ::u8 sunAnimPhase) = 0;
virtual AZ::u8 GetSunAnimIndex() = 0;
virtual void SetSunAnimIndex(AZ::u8 sunAnimIndex) = 0;
virtual float GetSSAOAmount() = 0;
virtual void SetSSAOAmount(float amount) = 0;
virtual float GetSSAOContrast() = 0;
virtual void SetSSAOContrast(float amount) = 0;
virtual SRainParams& GetRainParams() = 0;
virtual SSnowParams& GetSnowParams() = 0;
virtual bool IsCameraPrecacheOverridden() = 0;
virtual void SetCameraPrecacheOverridden(bool state) = 0;
virtual IStatObj* LoadNewCGF(IStatObj* pObject, int flagCloth, bool bUseStreaming, bool bForceBreakable, unsigned long nLoadingFlags, const char* normalizedFilename, const void* pData, int nDataSize, const char* originalFilename, const char* geomName, IStatObj::SSubObject** ppSubObject) = 0;
virtual IStatObj* LoadFromCacheNoRef(IStatObj* pObject, bool bUseStreaming, unsigned long nLoadingFlags, const char* geomName, IStatObj::SSubObject** ppSubObject) = 0;
virtual IStatObj* AllocateStatObj() = 0;
virtual IStatObj* LoadStatObjUnsafeManualRef(const char* szFileName, const char* szGeomName = NULL, IStatObj::SSubObject** ppSubObject = NULL, bool bUseStreaming = true, unsigned long nLoadingFlags = 0, const void* m_pData = 0, int m_nDataSize = 0, const char* szBlockName = NULL) = 0;
virtual _smart_ptr<IStatObj> LoadStatObjAutoRef(const char* szFileName, const char* szGeomName = NULL, IStatObj::SSubObject** ppSubObject = NULL, bool bUseStreaming = true, unsigned long nLoadingFlags = 0, const void* m_pData = 0, int m_nDataSize = 0, const char* szBlockName = NULL) = 0;
virtual void GetLoadedStatObjArray(IStatObj** pObjectsArray, int& nCount) = 0;
virtual bool InternalDeleteObject(IStatObj* pObject) = 0;
virtual void MakeShadowCastersList(CVisArea* pReceiverArea, const AABB& aabbReceiver, int dwAllowedTypes, int32 nRenderNodeFlags, Vec3 vLightPos, CDLight* pLight, ShadowMapFrustum* pFr, PodArray<struct SPlaneObject>* pShadowHull, const SRenderingPassInfo& passInfo) = 0;
virtual int MakeStaticShadowCastersList(IRenderNode* pIgnoreNode, ShadowMapFrustum* pFrustum, int renderNodeExcludeFlags, int nMaxNodes, const SRenderingPassInfo& passInfo) = 0;
virtual void MakeDepthCubemapRenderItemList(CVisArea* pReceiverArea, const AABB& cubemapAABB, int renderNodeFlags, PodArray<struct IShadowCaster*>* objectsList, const SRenderingPassInfo& passInfo) = 0;
virtual void PrecacheStatObjMaterial(_smart_ptr<IMaterial> pMaterial, const float fEntDistance, IStatObj* pStatObj, bool bFullUpdate, bool bDrawNear) = 0;
virtual void PrecacheStatObj(IStatObj* pStatObj, int nLod, const Matrix34A& statObjMatrix, _smart_ptr<IMaterial> pMaterial, float fImportance, float fEntDistance, bool bFullUpdate, bool bHighPriority) = 0;
virtual int GetLoadedObjectCount() = 0;
virtual uint16 CheckCachedNearestCubeProbe(IRenderNode* pEnt) = 0;
virtual int16 GetNearestCubeProbe(IVisArea* pVisArea, const AABB& objBox, bool bSpecular = true) = 0;
virtual void RenderObject(IRenderNode* o, const AABB& objBox, float fEntDistance, EERType eERType, const SRenderingPassInfo& passInfo, const SRendItemSorter& rendItemSorter) = 0;
virtual void RenderDecalAndRoad(IRenderNode* pEnt, const AABB& objBox, float fEntDistance, bool nCheckOcclusion, const SRenderingPassInfo& passInfo, const SRendItemSorter& rendItemSorter) = 0;
virtual void RenderObjectDebugInfo(IRenderNode* pEnt, float fEntDistance, const SRenderingPassInfo& passInfo) = 0;
virtual void RenderAllObjectDebugInfo() = 0;
virtual void RenderObjectDebugInfo_Impl(IRenderNode* pEnt, float fEntDistance) = 0;
virtual void RemoveFromRenderAllObjectDebugInfo(IRenderNode* pEnt) = 0;
virtual float GetXYRadius(int nType, int nSID = DEFAULT_SID) = 0;
virtual bool GetStaticObjectBBox(int nType, Vec3& vBoxMin, Vec3& vBoxMax, int nSID = DEFAULT_SID) = 0;
virtual IStatObj* GetStaticObjectByTypeID(int nTypeID, int nSID = DEFAULT_SID) = 0;
virtual IStatObj* FindStaticObjectByFilename(const char* filename) = 0;
//virtual float GetBendingRandomFactor() = 0;
virtual float GetGSMMaxDistance() const = 0;
virtual void SetGSMMaxDistance(float value) = 0;
virtual int GetUpdateStreamingPrioriryRoundIdFast() = 0;
virtual int GetUpdateStreamingPrioriryRoundId() = 0;
virtual void IncrementUpdateStreamingPrioriryRoundIdFast(int amount) = 0;
virtual void IncrementUpdateStreamingPrioriryRoundId(int amount) = 0;
virtual NAsyncCull::CCullThread& GetCullThread() = 0;
virtual void SetLockCGFResources(bool state) = 0;
virtual bool IsLockCGFResources() = 0;
virtual bool IsBoxOccluded(const AABB& objBox, float fDistance, OcclusionTestClient* const __restrict pOcclTestVars, bool bIndoorOccludersOnly, EOcclusionObjectType eOcclusionObjectType, const SRenderingPassInfo& passInfo) = 0;
virtual void AddDecalToRenderer(float fDistance, _smart_ptr<IMaterial> pMat, const uint8 sortPrio, Vec3 right, Vec3 up, const UCol& ucResCol, const uint8 uBlendType, const Vec3& vAmbientColor, Vec3 vPos, const int nAfterWater, const SRenderingPassInfo& passInfo, const SRendItemSorter& rendItemSorter) = 0;
virtual void RegisterForStreaming(IStreamable* pObj) = 0;
virtual void UnregisterForStreaming(IStreamable* pObj) = 0;
virtual void UpdateRenderNodeStreamingPriority(IRenderNode* pObj, float fEntDistance, float fImportanceFactor, bool bFullUpdate, const SRenderingPassInfo& passInfo, bool bHighPriority = false) = 0;
virtual void GetMemoryUsage(class ICrySizer* pSizer) const = 0;
virtual void GetBandwidthStats(float* fBandwidthRequested) = 0;
virtual void ReregisterEntitiesInArea(Vec3 vBoxMin, Vec3 vBoxMax) = 0;
virtual void UpdateObjectsStreamingPriority(bool bSyncLoad, const SRenderingPassInfo& passInfo) = 0;
virtual void ProcessObjectsStreaming(const SRenderingPassInfo& passInfo) = 0;
virtual void ProcessObjectsStreaming_Impl(bool bSyncLoad, const SRenderingPassInfo& passInfo) = 0;
virtual void ProcessObjectsStreaming_Sort(bool bSyncLoad, const SRenderingPassInfo& passInfo) = 0;
virtual void ProcessObjectsStreaming_Release() = 0;
virtual void ProcessObjectsStreaming_InitLoad(bool bSyncLoad) = 0;
virtual void ProcessObjectsStreaming_Finish() = 0;
// time counters
virtual bool IsAfterWater(const Vec3& vPos, const SRenderingPassInfo& passInfo) = 0;
virtual void FreeNotUsedCGFs() = 0;
virtual void MakeUnitCube() = 0;
virtual bool CheckOcclusion_TestAABB(const AABB& rAABB, float fEntDistance) = 0;
virtual bool CheckOcclusion_TestQuad(const Vec3& vCenter, const Vec3& vAxisX, const Vec3& vAxisY) = 0;
virtual void PushIntoCullQueue(const SCheckOcclusionJobData& rCheckOcclusionData) = 0;
virtual void PopFromCullQueue(SCheckOcclusionJobData* pCheckOcclusionData) = 0;
virtual void PushIntoCullOutputQueue(const SCheckOcclusionOutput& rCheckOcclusionOutput) = 0;
virtual bool PopFromCullOutputQueue(SCheckOcclusionOutput* pCheckOcclusionOutput) = 0;
virtual void BeginCulling() = 0;
virtual void RemoveCullJobProducer() = 0;
virtual void AddCullJobProducer() = 0;
#ifndef _RELEASE
virtual void CoverageBufferDebugDraw() = 0;
#endif
virtual bool LoadOcclusionMesh(const char* pFileName) = 0;
virtual void ClearStatObjGarbage() = 0;
virtual void CheckForGarbage(IStatObj* pObject) = 0;
virtual void UnregisterForGarbage(IStatObj* pObject) = 0;
virtual int GetObjectLOD(const IRenderNode* pObj, float fDistance) = 0;
virtual bool RayStatObjIntersection(IStatObj* pStatObj, const Matrix34& objMat, _smart_ptr<IMaterial> pMat, Vec3 vStart, Vec3 vEnd, Vec3& vClosestHitPoint, float& fClosestHitDistance, bool bFastTest) = 0;
virtual bool RayRenderMeshIntersection(IRenderMesh* pRenderMesh, const Vec3& vInPos, const Vec3& vInDir, Vec3& vOutPos, Vec3& vOutNormal, bool bFastTest, _smart_ptr<IMaterial> pMat) = 0;
virtual bool SphereRenderMeshIntersection(IRenderMesh* pRenderMesh, const Vec3& vInPos, const float fRadius, _smart_ptr<IMaterial> pMat) = 0;
virtual uint8 GetDissolveRef(float fDist, float fMaxViewDist) = 0;
virtual float GetLodDistDissolveRef(SLodDistDissolveTransitionState* pState, float curDist, int nNewLod, const SRenderingPassInfo& passInfo) = 0;
virtual void CleanStreamingData() = 0;
virtual IRenderMesh* GetRenderMeshBox() = 0;
virtual void PrepareCullbufferAsync(const CCamera& rCamera) = 0;
virtual void BeginOcclusionCulling(const SRenderingPassInfo& passInfo) = 0;
virtual void EndOcclusionCulling(bool waitForOcclusionJobCompletion = false) = 0;
virtual void RenderBufferedRenderMeshes(const SRenderingPassInfo& passInfo) = 0;
virtual int GetListStaticTypesCount() = 0;
virtual int GetListStaticTypesGroupCount(int typeId) = 0;
virtual IStatInstGroup* GetIStatInstGroup(int typeId, int groupId) = 0;
virtual int IncrementNextPrecachePointId() = 0;
};
Code/CryEngine/CryCommon/IPhysicsDebugRenderer.h
-19
View File
@@ -1,19 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#ifndef CRYINCLUDE_CRYCOMMON_IPHYSICSDEBUGRENDERER_H
#define CRYINCLUDE_CRYCOMMON_IPHYSICSDEBUGRENDERER_H
#pragma once
#endif // CRYINCLUDE_CRYCOMMON_IPHYSICSDEBUGRENDERER_H
Code/CryEngine/CryCommon/IProximityTriggerSystem.h
-133
View File
@@ -1,133 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#ifndef CRYINCLUDE_CRYCOMMON_IPROXIMITYTRIGGERSYSTEM_H
#define CRYINCLUDE_CRYCOMMON_IPROXIMITYTRIGGERSYSTEM_H
#pragma once
#include <AzCore/base.h>
#include <AzCore/EBus/EBus.h>
#include <AzCore/Component/EntityId.h>
#include <AzCore/std/function/function_fwd.h>
#include <Cry_Geo.h> // AABB
/**
* Represents a registered proximity trigger.
*
* Contains the id of the trigger, its bounds, and whether or not it's active.
*/
struct SProximityElement
{
AZ::EntityId id;
AABB aabb;
uint32 bActivated : 1;
std::vector<SProximityElement*> inside;
using NarrowPassCheckFunction = AZStd::function<bool(const AZ::Vector3&)>;
// Can be used to do an optional narrow pass check on this proximity element
NarrowPassCheckFunction m_narrowPassChecker;
SProximityElement()
{
id = AZ::EntityId(0);
bActivated = 0;
}
~SProximityElement()
{
}
bool AddInside(SProximityElement* elem)
{
// Sorted add.
return stl::binary_insert_unique(inside, elem);
}
bool RemoveInside(SProximityElement* elem)
{
// sorted remove.
return stl::binary_erase(inside, elem);
}
bool IsInside(SProximityElement* elem)
{
return std::binary_search(inside.begin(), inside.end(), elem);
}
void GetMemoryUsage([[maybe_unused]] ICrySizer* pSizer) const{}
};
/**
* Bus for events dispatched by the proximity trigger system as triggered are
* entered and exited by entities in the world.
*/
class ProximityTriggerEvents
: public AZ::EBusTraits
{
public:
//////////////////////////////////////////////////////////////////////////
// Ebus Traits
// ID'd on trigger entity Id
static const AZ::EBusAddressPolicy AddressPolicy = AZ::EBusAddressPolicy::ById;
using BusIdType = AZ::EntityId;
//////////////////////////////////////////////////////////////////////////
virtual ~ProximityTriggerEvents() {}
/// Dispatched when an entity enters a trigger. The bus message is ID'd on the triggers entity Id.
virtual void OnTriggerEnter(AZ::EntityId /*entityEntering*/) {};
/// Dispatched when an entity exits a trigger. The bus message is ID'd on the triggers entity Id.
virtual void OnTriggerExit(AZ::EntityId /*entityExiting*/) {};
};
using ProximityTriggerEventBus = AZ::EBus<ProximityTriggerEvents>;
/**
* Bus for requests sent by components or game code to the proximity trigger system.
*/
class ProximityTriggerSystemRequests
: public AZ::EBusTraits
{
public:
//////////////////////////////////////////////////////////////////////////
// EBusTraits overrides - proximity trigger system is a singleton
static const AZ::EBusHandlerPolicy HandlerPolicy = AZ::EBusHandlerPolicy::Single;
//////////////////////////////////////////////////////////////////////////
virtual ~ProximityTriggerSystemRequests() {}
/// Creates a new trigger instance.
virtual SProximityElement* CreateTrigger(SProximityElement::NarrowPassCheckFunction narrowPassChecker = nullptr) = 0;
/// Removes a trigger and queues it for deletion.
virtual void RemoveTrigger(SProximityElement* pTrigger) = 0;
/// Moves a trigger in the world or redefines its dimensions.
virtual void MoveTrigger(SProximityElement* pTrigger, const AABB& aabb, bool invalidateCachedAABB = false) = 0;
/// Creates a proxy in the world associated with an entity (Component or Legacy) for interacting with proximity trigger instances.
virtual SProximityElement* CreateEntity(AZ::EntityId id) = 0;
/**
* Set the entity's AABB to a unit AABB at the entity's world position if \aabb is empty, otherwise set the entity's AABB to \aabb
* @param pEntity The pointer to a SProximityElment whose AABB needs to be updated
* @param pos World position of the entity
* @param aabb The new AABB in world space to set
*/
virtual void MoveEntity(SProximityElement* pEntity, const Vec3& pos, const AABB& aabb) = 0;
/// Removes an entity's proximity trigger proxy.
virtual void RemoveEntity(SProximityElement* pEntity, bool instantEvent = false) = 0;
};
using ProximityTriggerSystemRequestBus = AZ::EBus<ProximityTriggerSystemRequests>;
#endif // CRYINCLUDE_CRYCOMMON_IPROXIMITYTRIGGERSYSTEM_H
Code/CryEngine/CryCommon/IRenderer.h
+6 -16
View File
@@ -16,7 +16,12 @@
#include "Cry_Geo.h"
#include "Cry_Camera.h"
#include "ITexture.h"
#include <IFuncVariable.h> // <> required for Interfuscator
#include "Cry_Vector2.h"
#include "Cry_Vector3.h"
#include "Cry_Matrix33.h"
#include "Cry_Color.h"
#include "smartptr.h"
#include "StringUtils.h"
#include <IXml.h> // <> required for Interfuscator
#include "smartptr.h"
#include <AzCore/Casting/numeric_cast.h>
@@ -99,7 +104,6 @@ struct ShadowFrustumMGPUCache;
struct IAsyncTextureCompileListener;
struct IClipVolume;
struct SClipVolumeBlendInfo;
class IImageFile;
class CRenderView;
struct SDynTexture2;
class CTexture;
@@ -693,7 +697,6 @@ public:
#include <IShader.h> // <> required for Interfuscator
//DOC-IGNORE-END
#include <IRenderMesh.h>
#include "IMeshBaking.h"
// Flags passed in function FreeResources.
#define FRR_SHADERS 1
@@ -1051,11 +1054,6 @@ namespace AZ {
namespace Vertex {
class Format;
}
namespace VideoRenderer
{
struct IVideoRenderer;
struct DrawArguments;
}
}
enum eRenderPrimitiveType : int8;
enum RenderIndexType : int;
@@ -1464,7 +1462,6 @@ struct IRenderer
// Is threadsafe
virtual bool EF_ReloadFile_Request (const char* szFileName) = 0;
virtual _smart_ptr<IImageFile> EF_LoadImage(const char* szFileName, uint32 nFlags) = 0;
// Summary:
// Remaps shader gen mask to common global mask.
virtual uint64 EF_GetRemapedShaderMaskGen(const char* name, uint64 nMaskGen = 0, bool bFixup = 0) = 0;
@@ -1739,8 +1736,6 @@ struct IRenderer
virtual void RemoveTexture(unsigned int TextureId) = 0;
virtual void DeleteFont(IFFont* font) = 0;
virtual bool BakeMesh(const SMeshBakingInputParams* pInputParams, SMeshBakingOutput* pReturnValues) = 0;
/////////////////////////////////////////////////////////////////////////////////////////////////////
// This routines uses 2 destination surfaces. It triggers a backbuffer copy to one of its surfaces,
// and then copies the other surface to system memory. This hopefully will remove any
@@ -2346,11 +2341,6 @@ struct IRenderer
virtual void EndProfilerSection(const char* name) = 0;
virtual void AddProfilerLabel(const char* name) = 0;
// Video Renderer interface
virtual void InitializeVideoRenderer(AZ::VideoRenderer::IVideoRenderer* pVideoRenderer) = 0;
virtual void CleanupVideoRenderer(AZ::VideoRenderer::IVideoRenderer* pVideoRenderer) = 0;
virtual void DrawVideoRenderer(AZ::VideoRenderer::IVideoRenderer* pVideoRenderer, const AZ::VideoRenderer::DrawArguments& drawArguments) = 0;
private:
// use private for EF_Query to prevent client code to submit arbitrary combinations of output data/size
virtual void EF_QueryImpl(ERenderQueryTypes eQuery, void* pInOut0, uint32 nInOutSize0, void* pInOut1, uint32 nInOutSize1) = 0;
Code/CryEngine/CryCommon/IShader.h
+6 -2
View File
@@ -24,7 +24,12 @@
#endif
#include "smartptr.h"
#include <IFuncVariable.h> // <> required for Interfuscator
#include "Cry_Vector2.h"
#include "Cry_Vector3.h"
#include "Cry_Matrix33.h"
#include "Cry_Color.h"
#include "smartptr.h"
#include "StringUtils.h"
#include <IXml.h> // <> required for Interfuscator
#include "smartptr.h"
#include "VertexFormats.h"
@@ -767,7 +772,6 @@ _MS_ALIGN(16) struct SSkinningData
void* pCharInstCB; // used if per char instance cbs are available in renderdll (d3d11+);
// members below are for Software Skinning
void* pCustomData; // client specific data, used for example for sw-skinning on animation side
SSkinningData** pMasterSkinningDataList; // used by the SkinningData for a Character Instance, contains a list of all Skin Instances which need SW-Skinning
SSkinningData* pNextSkinningData; // List to the next element which needs SW-Skinning
} _ALIGN(16);
Code/CryEngine/CryCommon/IShader_info.h
-78
View File
@@ -1,78 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#pragma once
#include <IShader.h> // <> required for Interfuscator
// Traits
#if defined(AZ_RESTRICTED_PLATFORM)
#include AZ_RESTRICTED_FILE(IShader_info_h)
#elif !defined(LINUX) && !defined(APPLE)
#define ISHADER_INFO_H_TRAIT_DEFINE_ETEX_INFO 1
#endif
#if ISHADER_INFO_H_TRAIT_DEFINE_ETEX_INFO
ENUM_INFO_BEGIN(ETEX_Format)
ENUM_ELEM_INFO(, eTF_Unknown)
ENUM_ELEM_INFO(, eTF_R8G8B8A8S)
ENUM_ELEM_INFO(, eTF_R8G8B8A8)
ENUM_ELEM_INFO(, eTF_A8)
ENUM_ELEM_INFO(, eTF_R8)
ENUM_ELEM_INFO(, eTF_R8S)
ENUM_ELEM_INFO(, eTF_R16)
ENUM_ELEM_INFO(, eTF_R16F)
ENUM_ELEM_INFO(, eTF_R32F)
ENUM_ELEM_INFO(, eTF_R8G8)
ENUM_ELEM_INFO(, eTF_R8G8S)
ENUM_ELEM_INFO(, eTF_R16G16)
ENUM_ELEM_INFO(, eTF_R16G16S)
ENUM_ELEM_INFO(, eTF_R16G16F)
ENUM_ELEM_INFO(, eTF_R11G11B10F)
ENUM_ELEM_INFO(, eTF_R10G10B10A2)
ENUM_ELEM_INFO(, eTF_R16G16B16A16)
ENUM_ELEM_INFO(, eTF_R16G16B16A16S)
ENUM_ELEM_INFO(, eTF_R16G16B16A16F)
ENUM_ELEM_INFO(, eTF_R32G32B32A32F)
ENUM_ELEM_INFO(, eTF_CTX1)
ENUM_ELEM_INFO(, eTF_BC1)
ENUM_ELEM_INFO(, eTF_BC2)
ENUM_ELEM_INFO(, eTF_BC3)
ENUM_ELEM_INFO(, eTF_BC4U)
ENUM_ELEM_INFO(, eTF_BC4S)
ENUM_ELEM_INFO(, eTF_BC5U)
ENUM_ELEM_INFO(, eTF_BC5S)
ENUM_ELEM_INFO(, eTF_BC6UH)
ENUM_ELEM_INFO(, eTF_BC6SH)
ENUM_ELEM_INFO(, eTF_BC7)
ENUM_ELEM_INFO(, eTF_R9G9B9E5)
ENUM_ELEM_INFO(, eTF_D16)
ENUM_ELEM_INFO(, eTF_D24S8)
ENUM_ELEM_INFO(, eTF_D32F)
ENUM_ELEM_INFO(, eTF_D32FS8)
ENUM_ELEM_INFO(, eTF_B5G6R5)
ENUM_ELEM_INFO(, eTF_B5G5R5)
ENUM_ELEM_INFO(, eTF_B4G4R4A4)
ENUM_ELEM_INFO(, eTF_EAC_R11)
ENUM_ELEM_INFO(, eTF_EAC_RG11)
ENUM_ELEM_INFO(, eTF_ETC2)
ENUM_ELEM_INFO(, eTF_ETC2A)
ENUM_ELEM_INFO(, eTF_A8L8)
ENUM_ELEM_INFO(, eTF_L8)
ENUM_ELEM_INFO(, eTF_L8V8U8)
ENUM_ELEM_INFO(, eTF_B8G8R8)
ENUM_ELEM_INFO(, eTF_L8V8U8X8)
ENUM_ELEM_INFO(, eTF_B8G8R8X8)
ENUM_ELEM_INFO(, eTF_B8G8R8A8)
ENUM_INFO_END(ETEX_Format)
#endif
Code/CryEngine/CryCommon/ITerrain_info.h
-25
View File
@@ -1,25 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#ifndef CRYINCLUDE_CRY3DENGINE_ITERRAIN_INFO_H
#define CRYINCLUDE_CRY3DENGINE_ITERRAIN_INFO_H
#pragma once
#include <TypeInfo_impl.h>
#include <ITerrain.h>
STRUCT_INFO_BEGIN(ITerrain::SurfaceWeight)
STRUCT_VAR_INFO(Ids, TYPE_ARRAY(WeightCount, TYPE_INFO(uint8)))
STRUCT_VAR_INFO(Weights, TYPE_ARRAY(WeightCount, TYPE_INFO(uint8)))
STRUCT_INFO_END(ITerrain::SurfaceWeight)
#endif
Code/CryEngine/CryCommon/IVideoRenderer.h
-101
View File
@@ -1,101 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#pragma once
#include <ITexture.h>
namespace AZ
{
// General purpose video 'rendering' solution that abstracts video data into textures
// and data to update those textures with.
namespace VideoRenderer
{
enum Constants
{
MaxInputTextureCount = 4,
};
struct VideoTextureDesc
{
CryFixedStringT<64> m_name; // fixed string to avoid dll string copying issues
uint32 m_width{ 4 };
uint32 m_height{ 4 };
ETEX_Format m_format{ eTF_Unknown };
uint32 m_used{ 0 };
};
// Full description of video texture resources for the renderer to create.
struct VideoTexturesDesc
{
VideoTextureDesc m_outputTextureDesc;
VideoTextureDesc m_inputTextureDescs[MaxInputTextureCount];
};
// Full set of textures created from the VideoTexturesDesc provided to the renderer.
struct VideoTextures
{
uint32 m_outputTextureId{ 0 };
uint32 m_inputTextureIds[MaxInputTextureCount]{ 0 };
};
struct VideoUpdateData
{
struct VideoTextureUpdateData
{
// Data to update the texture with, can be null.
const void* m_data{ nullptr };
// Format of above data, required for format conversions if needed.
ETEX_Format m_dataFormat{ eTF_Unknown };
}
m_inputTextureData[MaxInputTextureCount];
};
// Set of data to update and render a frame of video textures.
// Everything should be passed through by value except for the update data, which should be double buffered at the source.
struct DrawArguments
{
// Set of textures to draw with.
VideoTextures m_textures;
// Set of data to update the above textures with if set.
VideoUpdateData m_updateData;
// Flag to indicate that we want to draw to the backbuffer.
uint32 m_drawingToBackbuffer{ 0 };
// Payload information for reference. Useful for debugging.
uint32 m_frameReference{ 0 };
// Scale applied to each texture.
Vec4 m_textureScales[MaxInputTextureCount]{};
// Value added to final composited texture.
Vec4 m_colorAdjustment{ ZERO };
};
// Video Rendering interface to provide callbacks from the Render Thread
struct IVideoRenderer
{
// Called from the Render Thread to request the description of the video textures.
virtual bool GetVideoTexturesDesc(AZ::VideoRenderer::VideoTexturesDesc& videoTexturesDesc) const = 0;
// Called from the Render Thread to get the set of video textures that were previously created. Used at cleanup time.
virtual bool GetVideoTextures(AZ::VideoRenderer::VideoTextures& videoTextures) const = 0;
// Called from the Render Thread to provide the video textures it created from the VideoTexturesDesc.
virtual bool NotifyTexturesCreated(const AZ::VideoRenderer::VideoTextures& videoTextures) = 0;
// CAlled from the Render Thread to notify the video manager that its textures were destroyed.
virtual bool NotifyTexturesDestroyed() = 0;
};
}
}
Code/CryEngine/CryCommon/InplaceFactory.h
-310
View File
@@ -1,310 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
// Description : Helper to enable inplace construction and destruction of objects
#ifndef CRYINCLUDE_CRYCOMMON_INPLACEFACTORY_H
#define CRYINCLUDE_CRYCOMMON_INPLACEFACTORY_H
#pragma once
// Inspired by the boost inplace/typed_inplace factory, written by
// Fernando Luis Cacciola Carballal and Tobias Schwinger
//
// See
// http://www.boost.org/doc/libs/1_42_0/libs/utility/in_place_factories.html
// for a detailed description
//
class CInplaceFactory0
{
public:
explicit CInplaceFactory0()
{}
template<class T>
void* apply(void* address) const
{
return new(address) T();
}
template<class T>
void* apply(void* address, std::size_t n) const
{
for (char* next = address = this->template apply<T>(address); !!--n; )
{
this->template apply<T>(next = next + sizeof(T));
}
return address;
}
};
template < typename Arg0 >
class CInplaceFactory1
{
Arg0& m_Arg0;
public:
explicit CInplaceFactory1(Arg0& arg)
: m_Arg0(arg)
{}
template<class T>
void* apply(void* address) const
{
return new(address) T(m_Arg0);
}
template<class T>
void* apply(void* address, std::size_t n) const
{
for (char* next = address = this->template apply<T>(address); !!--n; )
{
this->template apply<T>(next = next + sizeof(T));
}
return address;
}
};
template
<
typename Arg0,
typename Arg1
>
class CInplaceFactory2
{
Arg0& m_Arg0;
Arg1& m_Arg1;
public:
explicit CInplaceFactory2(Arg0& arg0, Arg1& arg1)
: m_Arg0(arg0)
, m_Arg1(arg1)
{}
template<class T>
void* apply(void* address) const
{
return new(address) T(
m_Arg0,
m_Arg1);
}
template<class T>
void* apply(void* address, std::size_t n) const
{
for (char* next = address = this->template apply<T>(address); !!--n; )
{
this->template apply<T>(next = next + sizeof(T));
}
return address;
}
};
template
<
typename Arg0,
typename Arg1,
typename Arg2
>
class CInplaceFactory3
{
Arg0& m_Arg0;
Arg1& m_Arg1;
Arg2& m_Arg2;
public:
explicit CInplaceFactory3(Arg0& arg0, Arg1& arg1, Arg2& arg2)
: m_Arg0(arg0)
, m_Arg1(arg1)
, m_Arg2(arg2)
{}
template<class T>
void* apply(void* address) const
{
return new(address) T(
m_Arg0,
m_Arg1,
m_Arg2);
}
template<class T>
void* apply(void* address, std::size_t n) const
{
for (char* next = address = this->template apply<T>(address); !!--n; )
{
this->template apply<T>(next = next + sizeof(T));
}
return address;
}
};
template
<
typename Arg0,
typename Arg1,
typename Arg2,
typename Arg3
>
class CInplaceFactory4
{
Arg0& m_Arg0;
Arg1& m_Arg1;
Arg2& m_Arg2;
Arg3& m_Arg3;
public:
explicit CInplaceFactory4(Arg0& arg0, Arg1& arg1, Arg2& arg2, Arg3& arg3)
: m_Arg0(arg0)
, m_Arg1(arg1)
, m_Arg2(arg2)
, m_Arg3(arg3)
{}
template<class T>
void* apply(void* address) const
{
return new(address) T(
m_Arg0,
m_Arg1,
m_Arg2,
m_Arg3);
}
template<class T>
void* apply(void* address, std::size_t n) const
{
for (char* next = address = this->template apply<T>(address); !!--n; )
{
this->template apply<T>(next = next + sizeof(T));
}
return address;
}
};
template
<
typename Arg0,
typename Arg1,
typename Arg2,
typename Arg3,
typename Arg4
>
class CInplaceFactory5
{
Arg0& m_Arg0;
Arg1& m_Arg1;
Arg2& m_Arg2;
Arg3& m_Arg3;
Arg4& m_Arg4;
public:
explicit CInplaceFactory5(Arg0& arg0, Arg1& arg1, Arg2& arg2, Arg3& arg3, Arg4& arg4)
: m_Arg0(arg0)
, m_Arg1(arg1)
, m_Arg2(arg2)
, m_Arg3(arg3)
, m_Arg4(arg4)
{}
template<class T>
void* apply(void* address) const
{
return new(address) T(
m_Arg0,
m_Arg1,
m_Arg2,
m_Arg3,
m_Arg4);
}
template<class T>
void* apply(void* address, std::size_t n) const
{
for (char* next = address = this->template apply<T>(address); !!--n; )
{
this->template apply<T>(next = next + sizeof(T));
}
return address;
}
};
inline CInplaceFactory0 InplaceFactory()
{
return CInplaceFactory0();
}
template < typename Arg0 >
inline CInplaceFactory1<Arg0> InplaceFactory(Arg0& arg0)
{
return CInplaceFactory1<Arg0>(arg0);
}
template
<
typename Arg0,
typename Arg1
>
inline CInplaceFactory2<Arg0, Arg1> InplaceFactory(Arg0& arg0, Arg1& arg1)
{
return CInplaceFactory2<Arg0, Arg1>(arg0, arg1);
}
template
<
typename Arg0,
typename Arg1,
typename Arg2
>
inline CInplaceFactory3<Arg0, Arg1, Arg2> InplaceFactory(Arg0& arg0, Arg1& arg1, Arg2& arg2)
{
return CInplaceFactory3<Arg0, Arg1, Arg2> (arg0, arg1, arg2);
}
template
<
typename Arg0,
typename Arg1,
typename Arg2,
typename Arg3
>
inline CInplaceFactory4<Arg0, Arg1, Arg2, Arg3> InplaceFactory(
Arg0& arg0, Arg1& arg1, Arg2& arg2, Arg3& arg3)
{
return CInplaceFactory4<Arg0, Arg1, Arg2, Arg3>(arg0, arg1, arg2, arg3);
}
template
<
typename Arg0,
typename Arg1,
typename Arg2,
typename Arg3,
typename Arg4
>
inline CInplaceFactory5<Arg0, Arg1, Arg2, Arg3, Arg4> InplaceFactory(
Arg0& arg0, Arg1& arg1, Arg2& arg2, Arg3& arg3, Arg4& arg4)
{
return CInplaceFactory5<Arg0, Arg1, Arg2, Arg3, Arg4>(arg0, arg1, arg2, arg3, arg4);
}
#endif // CRYINCLUDE_CRYCOMMON_INPLACEFACTORY_H
Code/CryEngine/CryCommon/MaterialUtils.h
-134
View File
@@ -1,134 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#pragma once
#ifndef CRYINCLUDE_CRYCOMMON_MATERIALUTILS_H
#define CRYINCLUDE_CRYCOMMON_MATERIALUTILS_H
#include <AzCore/base.h>
#include <AzCore/IO/SystemFile.h> // for max path len
#include <AzCore/std/string/string.h>
#include <AzCore/Utils/Utils.h>
#include <AzFramework/StringFunc/StringFunc.h>
#include <ISystem.h>
namespace MaterialUtils
{
//! UnifyMaterialName - given a non-unified material name, remove the extension, unify the slashes
//! and fix up any legacy naming issues so that the material name can be used in a hash map
//! and will work each lookup.
inline void UnifyMaterialName(char* inputOutputBuffer)
{
if (!inputOutputBuffer)
{
return;
}
// convert slashes and remove extensions:
size_t inputLength = strlen(inputOutputBuffer);
if (inputLength == 0)
{
return;
}
// this must be done first, so that the extension cutting function below does not mistakenly destroy this when it finds the .
if ((azstrnicmp(inputOutputBuffer, "./", 2) == 0) || (azstrnicmp(inputOutputBuffer, ".\\", 2) == 0))
{
memmove(inputOutputBuffer, inputOutputBuffer + 2, inputLength - 2);
inputOutputBuffer[inputLength - 2] = 0;
inputLength -= 2;
}
for (size_t pos = 0; pos < inputLength; ++pos)
{
if (inputOutputBuffer[pos] == '\\')
{
inputOutputBuffer[pos] = '/'; // unify slashes
}
else
{
inputOutputBuffer[pos] = tolower(inputOutputBuffer[pos]);
}
}
AZStd::string tempString(inputOutputBuffer);
AzFramework::StringFunc::Path::StripExtension(tempString);
AZ_Assert(tempString.length() <= inputLength, "Extension stripped string has to be smaller than/same size as original string!");
// real size of inputOutputBuffer is inputLength + 1 with Null character
azstrcpy(inputOutputBuffer, inputLength + 1, tempString.c_str());
#if defined(SUPPORT_LEGACY_MATERIAL_NAMES)
// LEGACY support Some files may start with ./ in front of them. This is not required anymore.
static const char* removals[2] = {
"engine/",
nullptr // reserved for game name
};
static size_t removalSize = sizeof(removals) / sizeof(removals[0]);
// LEGACY support. Some files may start with gamename in front of them. This is not required anymore.
static char cachedGameName[AZ_MAX_PATH_LEN] = { 0 };
if (!removals[removalSize - 1])
{
auto projectName = AZ::Utils::GetProjectName();
if (!projectName.empty())
{
azstrcpy(cachedGameName, AZ_MAX_PATH_LEN, projectName.c_str());
azstrcat(cachedGameName, AZ_MAX_PATH_LEN, "/");
}
if (cachedGameName[0] == 0)
{
// at least substitute something so that unit tests can make this assumption:
azstrcpy(cachedGameName, AZ_MAX_PATH_LEN, "AutomatedTesting/");
}
removals[removalSize - 1] = cachedGameName;
}
for (size_t pos = 0; pos < removalSize; ++pos)
{
if (removals[pos])
{
size_t removalLength = strlen(removals[pos]);
if (removalLength >= inputLength)
{
continue;
}
if (azstrnicmp(inputOutputBuffer, removals[pos], removalLength) == 0)
{
memmove(inputOutputBuffer, inputOutputBuffer + removalLength, inputLength - removalLength);
inputOutputBuffer[inputLength - removalLength] = 0;
inputLength -= removalLength;
}
}
}
// legacy: Files were saved into a mtl with many leading forward or back slashes, we eat them all here. We want it to start with a rel path.
const char* actualFileName = inputOutputBuffer;
size_t finalLength = inputLength;
while ((actualFileName[0]) && ((actualFileName[0] == '\\') || (actualFileName[0] == '/')))
{
++actualFileName;
--finalLength;
}
if (finalLength != inputLength)
{
memmove(inputOutputBuffer, actualFileName, finalLength);
inputOutputBuffer[finalLength] = 0;
inputLength = finalLength;
}
#endif
}
}
#endif // CRYINCLUDE_CRYCOMMON_MATERIALUTILS_H
Code/CryEngine/CryCommon/Mocks/IRendererMock.h
-13
View File
@@ -12,8 +12,6 @@
#pragma once
#include <IRenderer.h>
#include <IVideoRenderer.h>
#include <IImage.h>
#include <gmock/gmock.h>
struct SRendItemSorter {};
@@ -294,8 +292,6 @@ public:
bool(const char* szFileName));
MOCK_METHOD1(EF_ReloadFile_Request,
bool(const char* szFileName));
MOCK_METHOD2(EF_LoadImage,
_smart_ptr<IImageFile>(const char* szFileName, uint32 nFlags));
MOCK_METHOD3(EF_GetRemapedShaderMaskGen,
uint64(const char*, uint64, bool));
MOCK_METHOD3(EF_GetShaderGlobalMaskGenFromString,
@@ -533,8 +529,6 @@ public:
void(unsigned int TextureId));
MOCK_METHOD1(DeleteFont,
void(IFFont * font));
MOCK_METHOD2(BakeMesh,
bool(const SMeshBakingInputParams * pInputParams, SMeshBakingOutput * pReturnValues));
MOCK_METHOD3(CaptureFrameBufferFast,
bool(unsigned char* pDstRGBA8, int destinationWidth, int destinationHeight));
MOCK_METHOD3(CopyFrameBufferFast,
@@ -857,13 +851,6 @@ public:
MOCK_METHOD1(AddProfilerLabel,
void(const char*));
MOCK_METHOD1(InitializeVideoRenderer,
void(AZ::VideoRenderer::IVideoRenderer* pVideoRenderer));
MOCK_METHOD1(CleanupVideoRenderer,
void(AZ::VideoRenderer::IVideoRenderer* pVideoRenderer));
MOCK_METHOD2(DrawVideoRenderer,
void(AZ::VideoRenderer::IVideoRenderer* pVideoRenderer, const AZ::VideoRenderer::DrawArguments& drawArguments));
MOCK_METHOD5(EF_QueryImpl,
void(ERenderQueryTypes eQuery, void* pInOut0, uint32 nInOutSize0, void* pInOut1, uint32 nInOutSize1));
};
Code/CryEngine/CryCommon/Name_TypeInfo.h
-34
View File
@@ -1,34 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#ifndef CRYINCLUDE_CRYCOMMON_NAME_TYPEINFO_H
#define CRYINCLUDE_CRYCOMMON_NAME_TYPEINFO_H
#pragma once
#include "CryName.h"
// CCryName TypeInfo
TYPE_INFO_BASIC(CCryName)
string ToString(CCryName const& val)
{
return string(val.c_str());
}
bool FromString(CCryName& val, const char* s)
{
val = s;
return true;
}
#endif // CRYINCLUDE_CRYCOMMON_NAME_TYPEINFO_H
Code/CryEngine/CryCommon/OceanConstants.h
-85
View File
@@ -1,85 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#pragma once
#include <AzCore/Math/Color.h>
#include <AzCore/Math/MathUtils.h>
// Water level unknown.
#define WATER_LEVEL_UNKNOWN -1000000.f
#define BOTTOM_LEVEL_UNKNOWN -1000000.f
namespace AZ
{
/**
* Numeric constants that the editors should use for the ocean properties
*/
namespace OceanConstants
{
// Ocean Height consts are maintained for backwards compatibility
// @TODO: Remove height / depth related consts when feature toggle is removed.
static const float s_HeightMin = -AZ::Constants::MaxFloatBeforePrecisionLoss;
static const float s_HeightMax = AZ::Constants::MaxFloatBeforePrecisionLoss;
static const float s_HeightUnknown = WATER_LEVEL_UNKNOWN;
static const float s_BottomUnknown = BOTTOM_LEVEL_UNKNOWN;
static const float s_DefaultHeight = 16.0f;
static const float s_CausticsDistanceAttenMin = 0.0f;
static const float s_CausticsDistanceAttenDefault = 10.0f;
static const float s_CausticsDistanceAttenMax = 100.0f;
static const float s_CausticsDepthMin = 0.0f;
static const float s_CausticsDepthDefault = 8.0f;
static const float s_CausticsDepthMax = 100.0f;
static const float s_CausticsIntensityMin = 0.0f;
static const float s_CausticsIntensityDefault = 1.0f;
static const float s_CausticsIntensityMax = 10.0f;
static const float s_CausticsTilingMin = 0.10f;
static const float s_CausticsTilingDefault = 2.0f;
static const float s_CausticsTilingMax = 10.0f;
static const float s_animationWavesAmountMin = 0.2f;
static const float s_animationWavesAmountMax = 5.0f;
static const float s_animationWavesAmountDefault = 0.75f;
static const float s_animationWavesSizeMin = 0.0f;
static const float s_animationWavesSizeMax = 3.0f;
static const float s_animationWavesSizeDefault = 1.25f;
static const float s_animationWavesSpeedMin = 0.0f;
static const float s_animationWavesSpeedMax = 5.0f;
static const float s_animationWavesSpeedDefault = 1.0f;
static const float s_animationWindDirectionMin = 0.0f;
static const float s_animationWindDirectionMax = 6.2832f;
static const float s_animationWindDirectionDefault = 1;
static const float s_animationWindSpeedMin = 0.0f;
static const float s_animationWindSpeedMax = 1000.0f;
static const float s_animationWindSpeedDefault = 40.0f;
static const AZ::Color s_oceanFogColorDefault((AZ::u8)5, (AZ::u8)36, (AZ::u8)32, (AZ::u8)255);
static const AZ::Color s_oceanNearFogColorDefault((AZ::u8)1, (AZ::u8)7, (AZ::u8)5, (AZ::u8)255);
static const float s_oceanFogColorMultiplierDefault = 0.15f;
static const float s_oceanFogDensityDefault = 0.07f;
static const float s_OceanFogColorMultiplierMin = 0.0f;
static const float s_OceanFogColorMultiplierMax = 1.0f;
static const float s_OceanFogDensityMin = 0.0f;
static const float s_OceanFogDensityMax = 1.0f;
static const int s_waterTessellationAmountMin = 10;
static const int s_waterTessellationAmountMax = 500;
static const int s_waterTessellationDefault = 85;
static const bool s_UseOceanBottom = true;
static const bool s_GodRaysEnabled = true;
static const float s_UnderwaterDistortion = 1.0f;
static const float s_oceanIsVeryFarAway = 1000000.f;
};
}
Code/CryEngine/CryCommon/Pak/CryPakUtils.h
-363
View File
@@ -1,363 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#pragma once
#include <AzFramework/Archive/IArchive.h>
//! Everybody should use fxopen instead of fopen so it opens on all platforms
inline AZ::IO::HandleType fxopen(const char* file, const char* mode, bool bGameRelativePath = false)
{
if (gEnv && gEnv->pCryPak)
{
gEnv->pCryPak->CheckFileAccessDisabled(file, mode);
}
bool bWriteAccess = false;
for (const char* s = mode; *s; s++)
{
if (*s == 'w' || *s == 'W' || *s == 'a' || *s == 'A' || *s == '+')
{
bWriteAccess = true;
break;
}
;
}
if (gEnv && gEnv->pCryPak)
{
int nAdjustFlags = 0;
if (!bGameRelativePath)
{
nAdjustFlags |= AZ::IO::IArchive::FLAGS_PATH_REAL;
}
if (bWriteAccess)
{
nAdjustFlags |= AZ::IO::IArchive::FLAGS_FOR_WRITING;
}
char path[_MAX_PATH];
const char* szAdjustedPath = gEnv->pCryPak->AdjustFileName(file, path, AZ_ARRAY_SIZE(path), nAdjustFlags);
#if !AZ_TRAIT_LEGACY_CRYPAK_UNIX_LIKE_FILE_SYSTEM
if (bWriteAccess)
{
// Make sure folder is created.
gEnv->pCryPak->MakeDir(szAdjustedPath);
}
#endif
AZ::IO::HandleType fileHandle = AZ::IO::InvalidHandle;
AZ::IO::FileIOBase::GetInstance()->Open(szAdjustedPath, AZ::IO::GetOpenModeFromStringMode(mode), fileHandle);
return fileHandle;
}
else
{
return AZ::IO::InvalidHandle;
}
}
class CDebugAllowFileAccess
{
public:
#if defined(_RELEASE)
ILINE CDebugAllowFileAccess() { }
ILINE void End() { }
#else
CDebugAllowFileAccess()
{
m_threadId = AZStd::this_thread::get_id();
m_oldDisable = gEnv->pCryPak ? gEnv->pCryPak->DisableRuntimeFileAccess(false, m_threadId) : false;
m_active = true;
}
~CDebugAllowFileAccess()
{
End();
}
void End()
{
if (m_active)
{
if (gEnv && gEnv->pCryPak)
{
gEnv->pCryPak->DisableRuntimeFileAccess(m_oldDisable, m_threadId);
}
m_active = false;
}
}
protected:
AZStd::thread_id m_threadId;
bool m_oldDisable;
bool m_active;
#endif
};
//////////////////////////////////////////////////////////////////////////
class CInMemoryFileLoader
{
public:
CInMemoryFileLoader(AZ::IO::IArchive* pCryPak)
: m_pPak(pCryPak)
, m_fileHandle(AZ::IO::InvalidHandle)
, m_pBuffer(0)
, m_pCursor(0)
, m_nFileSize(0) {}
~CInMemoryFileLoader()
{
Close();
}
bool IsFileExists() const
{
return m_fileHandle != AZ::IO::InvalidHandle;
}
AZ::IO::HandleType GetFileHandle() const
{
return m_fileHandle;
}
bool FOpen(const char* name, const char* mode, bool bImmediateCloseFile = false)
{
if (m_pPak)
{
assert(m_fileHandle == AZ::IO::InvalidHandle);
m_fileHandle = m_pPak->FOpen(name, mode);
if (m_fileHandle == AZ::IO::InvalidHandle)
{
return false;
}
m_nFileSize = m_pPak->FGetSize(m_fileHandle);
if (m_nFileSize == 0)
{
Close();
return false;
}
m_pCursor = m_pBuffer = (char*)m_pPak->PoolMalloc(m_nFileSize);
size_t nReaded = m_pPak->FReadRawAll(m_pBuffer, m_nFileSize, m_fileHandle);
if (nReaded != m_nFileSize)
{
Close();
return false;
}
if (bImmediateCloseFile)
{
m_pPak->FClose(m_fileHandle);
m_fileHandle = AZ::IO::InvalidHandle;
}
return true;
}
return false;
}
void FClose()
{
Close();
}
size_t FReadRaw(void* data, size_t length, size_t elems)
{
ptrdiff_t dist = m_pCursor - m_pBuffer;
size_t count = length;
if (dist + count * elems > m_nFileSize)
{
count = (m_nFileSize - dist) / elems;
}
memmove(data, m_pCursor, count * elems);
m_pCursor += count * elems;
return count;
}
template<class T>
size_t FRead(T* data, size_t elems, bool bSwapEndian = eLittleEndian)
{
ptrdiff_t dist = m_pCursor - m_pBuffer;
size_t count = elems;
if (dist + count * sizeof(T) > m_nFileSize)
{
count = (m_nFileSize - dist) / sizeof(T);
}
memmove(data, m_pCursor, count * sizeof(T));
m_pCursor += count * sizeof(T);
SwapEndian(data, count, bSwapEndian);
return count;
}
size_t FTell()
{
ptrdiff_t dist = m_pCursor - m_pBuffer;
return dist;
}
int FSeek(int64_t origin, int command)
{
int retCode = -1;
int64_t newPos;
char* newPosBuf;
switch (command)
{
case SEEK_SET:
newPos = origin;
if (newPos <= (int64_t)m_nFileSize)
{
m_pCursor = m_pBuffer + newPos;
retCode = 0;
}
break;
case SEEK_CUR:
newPosBuf = m_pCursor + origin;
if (newPosBuf <= m_pBuffer + m_nFileSize)
{
m_pCursor = newPosBuf;
retCode = 0;
}
break;
case SEEK_END:
newPos = m_nFileSize - origin;
if (newPos <= (int64_t)m_nFileSize)
{
m_pCursor = m_pBuffer + newPos;
retCode = 0;
}
break;
default:
// Not valid disk operation!
AZ_Assert(false, "Invalid disk operation");
}
return retCode;
}
private:
void Close()
{
if (m_fileHandle != AZ::IO::InvalidHandle)
{
m_pPak->FClose(m_fileHandle);
}
if (m_pBuffer)
{
m_pPak->PoolFree(m_pBuffer);
}
m_pBuffer = m_pCursor = 0;
m_nFileSize = 0;
m_fileHandle = AZ::IO::InvalidHandle;
}
private:
AZ::IO::HandleType m_fileHandle;
char* m_pBuffer;
AZ::IO::IArchive* m_pPak;
char* m_pCursor;
size_t m_nFileSize;
};
//////////////////////////////////////////////////////////////////////////
// Helper class that can be used to recursively scan the directory.
//////////////////////////////////////////////////////////////////////////
struct SDirectoryEnumeratorHelper
{
public:
void ScanDirectoryRecursive(AZ::IO::IArchive* pIPak, const AZStd::string& root, const AZStd::string& pathIn, const AZStd::string& fileSpec, AZStd::vector<AZStd::string>& files)
{
auto AddSlash = [](AZStd::string_view path) -> AZStd::string
{
if (path.ends_with(AZ_CORRECT_DATABASE_SEPARATOR))
{
return path;
}
else if (path.ends_with(AZ_WRONG_DATABASE_SEPARATOR))
{
return AZStd::string{ path.substr(0, path.size() - 1) } + AZ_CORRECT_DATABASE_SEPARATOR;
}
return path.empty() ? AZStd::string(path) : AZStd::string(path) + AZ_CORRECT_DATABASE_SEPARATOR;
};
AZStd::string dir;
AZ::StringFunc::Path::Join(root.c_str(), pathIn.c_str(), dir);
dir = AddSlash(dir);
ScanDirectoryFiles(pIPak, "", dir, fileSpec, files);
AZStd::string findFilter;
AZ::StringFunc::Path::Join(dir.c_str(), "*", findFilter);
// Add all directories.
AZ::IO::ArchiveFileIterator pakFileIterator = pIPak->FindFirst(findFilter.c_str());
if (pakFileIterator)
{
do
{
// Skip back folders.
if (pakFileIterator.m_filename[0] == '.')
{
continue;
}
if (pakFileIterator.m_filename.empty())
{
AZ_Fatal("Archive", "IArchive FindFirst/FindNext returned empty name while looking for '%s'", findFilter.c_str());
continue;
}
if ((pakFileIterator.m_fileDesc.nAttrib & AZ::IO::FileDesc::Attribute::Subdirectory) == AZ::IO::FileDesc::Attribute::Subdirectory) // skip sub directories.
{
AZStd::string scanDir = AZStd::string::format("%s%.*s/", AddSlash(pathIn).c_str(), aznumeric_cast<int>(pakFileIterator.m_filename.size()), pakFileIterator.m_filename.data());
scanDir += AZ_CORRECT_DATABASE_SEPARATOR;
ScanDirectoryRecursive(pIPak, root, scanDir, fileSpec, files);
continue;
}
} while (pakFileIterator = pIPak->FindNext(pakFileIterator));
pIPak->FindClose(pakFileIterator);
}
}
private:
void ScanDirectoryFiles(AZ::IO::IArchive* pIPak, const AZStd::string& root, const AZStd::string& path, const AZStd::string& fileSpec, AZStd::vector<AZStd::string>& files)
{
AZStd::string dir;
AZ::StringFunc::Path::Join(root.c_str(), path.c_str(), dir);
AZStd::string findFilter;
AZ::StringFunc::Path::Join(dir.c_str(), fileSpec.c_str(), findFilter);
AZ::IO::ArchiveFileIterator pakFileIterator = pIPak->FindFirst(findFilter.c_str());
if (pakFileIterator)
{
do
{
// Skip back folders and subdirectories.
if (pakFileIterator.m_filename[0] == '.' || (pakFileIterator.m_fileDesc.nAttrib & AZ::IO::FileDesc::Attribute::Subdirectory) == AZ::IO::FileDesc::Attribute::Subdirectory)
{
continue;
}
AZStd::string fullPath;
AZ::StringFunc::Path::Join(path.c_str(), AZStd::string(pakFileIterator.m_filename).c_str(), fullPath);
files.push_back(fullPath);
} while (pakFileIterator = pIPak->FindNext(pakFileIterator));
pIPak->FindClose(pakFileIterator);
}
}
};
Code/CryEngine/CryCommon/PakLoadDataUtils.cpp
-57
View File
@@ -1,57 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <CryCommon/PakLoadDataUtils.h>
namespace PakLoadDataUtils
{
bool LoadDataFromFile_Seek(size_t elems, AZ::IO::HandleType& fileHandle, int& nDataSize, [[maybe_unused]] EEndian eEndian)
{
GetISystem()->GetIPak()->FSeek(fileHandle, elems, SEEK_CUR);
nDataSize -= elems;
AZ_Assert(nDataSize >= 0, "nDataSize must be equal or greater than 0");
return (nDataSize >= 0);
}
bool LoadDataFromFile_Seek(size_t elems, uint8*& f, int& nDataSize, [[maybe_unused]] EEndian eEndian)
{
nDataSize -= elems;
f += elems;
AZ_Assert(nDataSize >= 0, "nDataSize must be equal or greater than 0");
return true;
}
void LoadDataFromFile_FixAlignment(AZ::IO::HandleType& fileHandle, int& nDataSize)
{
while (nDataSize & 3)
{
[[maybe_unused]] size_t nRes = GetISystem()->GetIPak()->FSeek(fileHandle, 1, SEEK_CUR);
AZ_Assert(nRes == 0, "FSeek failed for 1 byte");
AZ_Assert(nDataSize, "nDataSize reached zero" );
nDataSize--;
}
AZ_Assert(nDataSize >= 0, "nDataSize must be equal or greater than 0");
}
void LoadDataFromFile_FixAlignment(uint8*& f, int& nDataSize)
{
while (nDataSize & 3)
{
AZ_Assert(*f == 222, "Found invalid data in buffer.");
f++;
AZ_Assert(nDataSize, "nDataSize reached zero");
nDataSize--;
}
AZ_Assert(nDataSize >= 0, "nDataSize must be equal or greater than 0");
}
} //namespace PakLoadDataUtils
Code/CryEngine/CryCommon/PakLoadDataUtils.h
-55
View File
@@ -1,55 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#pragma once
#include <ISystem.h>
#include <AzFramework/Archive/IArchive.h>
namespace PakLoadDataUtils
{
template <class T>
static bool LoadDataFromFile(T* data, size_t elems, AZ::IO::HandleType& fileHandle, int& nDataSize, EEndian eEndian, int* pSeek = 0)
{
auto ipak = GetISystem()->GetIPak();
if (pSeek)
{
*pSeek = aznumeric_cast<int>(ipak->FTell(fileHandle));
}
if (ipak->FRead(data, elems, fileHandle, eEndian) != elems)
{
AZ_Assert(false, "Failed to read %zu elements", elems);
return false;
}
nDataSize -= sizeof(T) * elems;
AZ_Assert(nDataSize >= 0, "nDataSize must be equal or greater than 0");
return true;
}
bool LoadDataFromFile_Seek(size_t elems, AZ::IO::HandleType& fileHandle, int& nDataSize, [[maybe_unused]] EEndian eEndian);
template <class T>
static bool LoadDataFromFile(T* data, size_t elems, uint8*& f, int& nDataSize, EEndian eEndian, [[maybe_unused]] int* pSeek = 0)
{
StepDataCopy(data, f, elems, eEndian);
nDataSize -= elems * sizeof(T);
AZ_Assert(nDataSize >= 0, "nDataSize must be equal or greater than 0");
return (nDataSize >= 0);
}
bool LoadDataFromFile_Seek(size_t elems, uint8*& f, int& nDataSize, [[maybe_unused]] EEndian eEndian);
void LoadDataFromFile_FixAlignment(AZ::IO::HandleType& fileHandle, int& nDataSize);
void LoadDataFromFile_FixAlignment(uint8*& f, int& nDataSize);
} //namespace PakLoadDataUtils
Code/CryEngine/CryCommon/ProjectDefines.h
-3
View File
@@ -242,9 +242,6 @@ typedef uint32 vtx_idx;
#endif // TESSELLATION
#endif // !defined(MOBILE)
#define USE_GEOM_CACHES
//------------------------------------------------------
// SVO GI
//------------------------------------------------------
Code/CryEngine/CryCommon/QTangent.h
-157
View File
@@ -1,157 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#ifndef CRYINCLUDE_CRYCOMMON_QTANGENT_H
#define CRYINCLUDE_CRYCOMMON_QTANGENT_H
#pragma once
namespace QTangent {
// Computes a QTangent from a frame and reflection scalar representing the
// tangent space.
// Will also ensure the resulting QTangent is suitable for 16bit quantization.
ILINE Quat FromFrameReflection(Quat frame, const float reflection)
{
frame.v = -frame.v;
if (frame.w < 0.0f)
{
frame = -frame;
}
// Make sure w is never 0 by applying the smallest possible bias.
// This is needed in order to have sign() never return 0 in the shaders.
static const float BIAS_16BIT = 1.0f / 32767.0f;
static const float BIAS_SCALE_16BIT = sqrtf(1.0f - BIAS_16BIT * BIAS_16BIT);
if (frame.w < BIAS_16BIT && frame.w > -BIAS_16BIT)
{
frame *= BIAS_SCALE_16BIT;
frame.w = BIAS_16BIT;
}
if (reflection < 0.0f)
{
frame = -frame;
}
return frame;
}
ILINE Quat FromFrameReflection(const Matrix33& frame, const float reflection)
{
Quat quat(frame);
quat.Normalize();
return FromFrameReflection(quat, reflection);
}
ILINE Quat FromFrameReflection16Safe(Matrix33 frame, const float reflection)
{
frame.OrthonormalizeFast();
if (!frame.IsOrthonormalRH(0.1f))
{
frame.SetIdentity();
}
return FromFrameReflection(frame, reflection);
}
ILINE void ToTangentBitangentReflection(const Quat& qtangent, Vec3& tangent, Vec3& bitangent, float& reflection)
{
tangent = qtangent.GetColumn0();
bitangent = qtangent.GetColumn1();
reflection = qtangent.w < 0.0f ? -1.0f : +1.0f;
}
} // namespace QTangent
// Auxiliary helper functions
#include <IIndexedMesh.h> // <> required for Interfuscator
ILINE Quat MeshTangentFrameToQTangent(const SMeshTangents& tangents)
{
SMeshTangents tb = tangents;
Vec3 tangent32, bitangent32;
int16 reflection;
tb.GetTB(tangent32, bitangent32);
tb.GetR(reflection);
Matrix33 frame;
frame.SetRow(0, tangent32);
frame.SetRow(1, bitangent32);
frame.SetRow(2, tangent32.Cross(bitangent32).GetNormalized());
return QTangent::FromFrameReflection16Safe(frame, reflection);
}
ILINE Quat MeshTangentFrameToQTangent(const Vec4sf& tangent, const Vec4sf& bitangent)
{
return MeshTangentFrameToQTangent(SMeshTangents(tangent, bitangent));
}
ILINE Quat MeshTangentFrameToQTangent(const SPipTangents& tangents)
{
return MeshTangentFrameToQTangent(SMeshTangents(tangents));
}
ILINE bool MeshTangentsFrameToQTangents(
const Vec4sf* pTangent, const uint tangentStride,
const Vec4sf* pBitangent, const uint bitangentStride, const uint count,
SPipQTangents* pQTangents, const uint qtangentStride)
{
Quat qtangent;
for (uint i = 0; i < count; ++i)
{
qtangent = MeshTangentFrameToQTangent(*pTangent, *pBitangent);
SMeshQTangents(qtangent).ExportTo(*pQTangents);
pTangent = (const Vec4sf*)(((const uint8*)pTangent) + tangentStride);
pBitangent = (const Vec4sf*)(((const uint8*)pBitangent) + bitangentStride);
pQTangents = (SPipQTangents*)(((uint8*)pQTangents) + qtangentStride);
}
return true;
}
ILINE bool MeshTangentsFrameToQTangents(
const SPipTangents* pTangents, const uint tangentStride, const uint count,
SPipQTangents* pQTangents, const uint qtangentStride)
{
Quat qtangent;
for (uint i = 0; i < count; ++i)
{
qtangent = MeshTangentFrameToQTangent(*pTangents);
SMeshQTangents(qtangent).ExportTo(*pQTangents);
pTangents = (const SPipTangents*)(((const uint8*)pTangents) + tangentStride);
pQTangents = (SPipQTangents*)(((uint8*)pQTangents) + qtangentStride);
}
return true;
}
ILINE bool MeshTangentsFrameToQTangents(
const SMeshTangents* pTangents, const uint tangentStride, const uint count,
SMeshQTangents* pQTangents, const uint qtangentStride)
{
Quat qtangent;
for (uint i = 0; i < count; ++i)
{
qtangent = MeshTangentFrameToQTangent(*pTangents);
*pQTangents = SMeshQTangents(qtangent);
pTangents = (const SMeshTangents*)(((const uint8*)pTangents) + tangentStride);
pQTangents = (SMeshQTangents*)(((uint8*)pQTangents) + qtangentStride);
}
return true;
}
#endif // CRYINCLUDE_CRYCOMMON_QTANGENT_H
Code/CryEngine/CryCommon/RenderContextConfig.h
-86
View File
@@ -1,86 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#pragma once
#include <AzCore/RTTI/RTTI.h>
#include <AzCore/Memory/SystemAllocator.h>
namespace AZ
{
class ReflectContext;
}
namespace AzRTT
{
typedef AZ::Uuid RenderContextId;
// various post screen effects will fail if we attempt to render the scene to very
// small render target sizes so provide a reasonable minimum (tile/icon size)
constexpr uint32_t MinRenderTargetWidth = 32;
constexpr uint32_t MinRenderTargetHeight = 32;
// this maximum recommended texture size applies to width and height
// using sizes larger than this can lead to performance issues and instability
constexpr uint32_t MaxRecommendedRenderTargetSize = 2048;
enum class AlphaMode {
ALPHA_DISABLED = 0,
ALPHA_OPAQUE,
ALPHA_DEPTH_BASED
};
// RenderContextConfig stores the render settings to use when rendering to texture.
// It also provides a more developer-friendly interface to deal with by exposing
// the most commonly used properties in one place.
struct RenderContextConfig
{
AZ_CLASS_ALLOCATOR(RenderContextConfig, AZ::SystemAllocator, 0);
AZ_RTTI(RenderContextConfig, "{6114F930-CBE4-4373-AF9D-3B5319471C8F}");
virtual ~RenderContextConfig() = default;
static void Reflect(AZ::ReflectContext* context);
//! render target width
uint32_t m_width = 256;
//! render target height
uint32_t m_height = 256;
//! write srgb or linear output
bool m_sRGBWrite = false;
//! alpha mode to use for the render target
AlphaMode m_alphaMode = AlphaMode::ALPHA_OPAQUE;
//! scene settings
bool m_oceanEnabled = true;
bool m_terrainEnabled = true;
bool m_vegetationEnabled = true;
//! shadow settings
bool m_shadowsEnabled = true;
int32_t m_shadowsNumCascades = -1;
float m_shadowsGSMRange = -1.f;
float m_shadowsGSMRangeStep = -1.f;
//! post-effects settings
bool m_depthOfFieldEnabled = false;
bool m_motionBlurEnabled = false;
int m_aaMode = 0;
//! visiblity for shadow settings
AZ::Crc32 GetShadowSettingsVisible();
//! confirm if user wants to use texture size larger than MaxRecommendedRenderTargetSize
bool ValidateTextureSize(void* newValue, const AZ::Uuid& valueType);
};
}
Code/CryEngine/CryCommon/RingBuffer.h
-273
View File
@@ -1,273 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright (C), Crytek, 1999-2015.
#pragma once
// A fixed-size type-safe ring buffer (ie, fixed-size double-ended queue).
// Note: It's possible to add support for iterators, indexing if needed.
template<typename T, size_t N, typename I = uint32>
class CRingBuffer
{
static_assert(std::is_integral<I>::value && std::is_unsigned<I>::value, "I is not unsigned integral type");
static_assert(N != 0 && N <= I(-1), "N is not a valid value (or I is too small)");
enum : I
{
kPowerOf2 = (N & (N - 1)) == 0,
kMaxSize = static_cast<I>(N),
};
public:
typedef T value_type;
typedef T& reference;
typedef const T& const_reference;
typedef T* pointer;
typedef const T* const_pointer;
typedef I size_type;
// Constructs an empty ring buffer.
CRingBuffer()
: m_begin(0)
, m_count(0)
{}
// Destroy a ring buffer.
~CRingBuffer()
{
clear();
}
// Retrieve the size of the collection.
size_type size() const
{
return m_count;
}
// Retrieve the maximum size of the collection.
size_type max_size() const
{
return kMaxSize;
}
// Test if the collection is empty.
bool empty() const
{
return m_count == 0;
}
// Test if the collection is full.
bool full() const
{
return m_count == kMaxSize;
}
// Get the front-most item of the collection.
// If the collection is empty, the behavior is undefined.
reference front()
{
CRY_ASSERT_MESSAGE(m_count != 0, "Container is empty");
return *ptr(m_begin);
}
// Get the front-most item of the collection.
// If the collection is empty, the behavior is undefined.
const_reference front() const
{
CRY_ASSERT_MESSAGE(m_count != 0, "Container is empty");
return *ptr(m_begin);
}
// Get the back-most item of the collection.
// If the collection is empty, the behavior is undefined.
reference back()
{
CRY_ASSERT_MESSAGE(m_count != 0, "Container is empty");
return *ptr(wrap(m_begin + m_count - 1));
}
// Get the back-most item of the collection.
// If the collection is empty, the behavior is undefined.
const_reference back() const
{
CRY_ASSERT_MESSAGE(m_count != 0, "Container is empty");
return *ptr(wrap(m_begin + m_count - 1));
}
// Adds an item to the front of the collection.
// In case the collection is full, the function returns false and the collection remains unmodified.
template<typename X>
bool push_front(X&& value)
{
static_assert(std::is_constructible<T, X&&>::value, "T cannot be constructed from the given type");
if (full())
{
return false;
}
const I index = decrement(m_begin);
::new(static_cast<void*>(ptr(index)))T(std::forward<X>(value));
m_begin = index;
++m_count;
return true;
}
// Adds an item to the front of the collection.
// In case the collection is full, the function overwrites the last item in the collection.
template<typename X>
void push_front_overwrite(X&& value)
{
static_assert(std::is_constructible<T, X&&>::value, "T cannot be constructed from the given type");
const I index = decrement(m_begin);
if (full())
{
ptr(index)->~T();
--m_count;
}
::new(static_cast<void*>(ptr(index)))T(std::forward<X>(value));
m_begin = index;
++m_count;
}
// Removes an item from the front of the collection.
// If the collection is empty, the behavior is undefined.
void pop_front()
{
CRY_ASSERT_MESSAGE(m_count != 0, "Container is empty");
ptr(m_begin)->~T();
m_begin = increment(m_begin);
--m_count;
}
// Attempts to remove an item from the front of the collection, and assigns it to 'value'.
// Returns true if an item was removed, false if the collection was empty (and 'value' remains unmodified).
bool try_pop_front(T& value)
{
if (m_count != 0)
{
T* const pItem = ptr(m_begin);
value = std::move(*pItem);
pItem->~T();
m_begin = increment(m_begin);
--m_count;
return true;
}
return false;
}
// Adds an item to the back of the collection.
// In case the collection is full, the function returns false and the collection remains unmodified.
template<typename X>
bool push_back(X&& value)
{
static_assert(std::is_constructible<T, X&&>::value, "T cannot be constructed from the given type");
if (full())
{
return false;
}
const I index = wrap(m_begin + m_count);
::new(static_cast<void*>(ptr(index)))T(std::forward<X>(value));
++m_count;
return true;
}
// Adds an item to the back of the collection.
// In case the collection is full, the function overwrites the first item in the collection.
template<typename X>
void push_back_overwrite(X&& value)
{
static_assert(std::is_constructible<T, X&&>::value, "T cannot be constructed from the given type");
const I index = wrap(m_begin + m_count);
if (full())
{
ptr(index)->~T();
m_begin = increment(index);
--m_count;
}
::new(static_cast<void*>(ptr(index)))T(std::forward<X>(value));
++m_count;
}
// Removes an item from the back of the collection.
// If the collection is empty, the behavior is undefined.
void pop_back()
{
CRY_ASSERT_MESSAGE(m_count != 0, "Container is empty");
const I index = wrap(m_begin + m_count - 1);
ptr(index)->~T();
--m_count;
}
// Attempts to remove an item from the back of the collection, and assigns it to 'value'.
// Returns true if an item was removed, false if the collection was empty (and 'value' remains unmodified).
bool try_pop_back(T& value)
{
if (m_count != 0)
{
const I index = wrap(m_begin + m_count - 1);
T* const pItem = ptr(index);
value = std::move(*pItem);
pItem->~T();
--m_count;
return true;
}
return false;
}
// Destroy all items in a ring buffer.
void clear()
{
size_type index = m_begin;
for (size_type i = 0; i < m_count; ++i, index = increment(index))
{
ptr(index)->~T();
}
m_begin = 0;
m_count = 0;
}
private:
// Decrements a given index, wrapping it around N.
static size_type decrement(size_type index)
{
return kPowerOf2 ? ((index - 1) & (kMaxSize - 1)) : index ? index - 1 : kMaxSize - 1;
}
// Increments a given index, wrapping it around N.
static size_type increment(size_type index)
{
++index;
return kPowerOf2 ? index & (kMaxSize - 1) : index == kMaxSize ? 0 : index;
}
// Wraps an index, which has a maximum value of 2N-1.
static size_type wrap(size_type index)
{
return kPowerOf2 ? index & (kMaxSize - 1) : index >= kMaxSize ? index - kMaxSize : index;
}
// Obtain pointer to raw storage at given index.
pointer ptr(size_type index)
{
return reinterpret_cast<pointer>(&m_storage) + index;
}
// Obtain pointer to raw storage at given index.
const_pointer ptr(size_type index) const
{
return reinterpret_cast<const_pointer>(&m_storage) + index;
}
// No copy/assign supported.
CRingBuffer(const CRingBuffer&);
void operator=(const CRingBuffer&);
size_type m_begin, m_count;
typename std::aligned_storage<sizeof(T)* N, std::alignment_of<T>::value>::type m_storage;
};
Code/CryEngine/CryCommon/ScopeGuard.h
-188
View File
@@ -1,188 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#pragma once
#include <type_traits>
#if defined(AZ_RESTRICTED_PLATFORM)
#undef AZ_RESTRICTED_SECTION
#define SCOPEGUARD_H_SECTION_1 1
#define SCOPEGUARD_H_SECTION_2 2
#endif
/**
This is from the c++17 working draft paper N3949 http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3949.pdf
It is a new library addition targeted for c++17. I didn't feel like waiting. Only modification is as required to get the
code compiling in the yet to be c++11 compliant visual studio. It is similar to boost scope exit, but in a modern and
more feature rich form. scope_guard just executes a lambda when it goes out of scope. unique_resource is a more complete
RAII wrapper. Its stands in for a resource (i.e. overloads cast operator to the wrapped resource) and frees it when it
goes out of scope. see the paper for more examples and a better description. Get rid of this once c++17 is available.
*/
namespace std17
{
template <typename D>
struct scope_guard_t
{
// construction
explicit scope_guard_t(D&& f)
: deleter(std::move(f))
, execute_on_destruction(true)
{
}
// move
scope_guard_t(scope_guard_t&& rhs)
: deleter(std::move(rhs.deleter))
, execute_on_destruction(rhs.execute_on_destruction)
{
rhs.release();
}
// release
~scope_guard_t()
{
if (execute_on_destruction)
{
deleter();
}
}
void release() { execute_on_destruction = false; }
private:
#if defined(AZ_RESTRICTED_PLATFORM)
#define AZ_RESTRICTED_SECTION SCOPEGUARD_H_SECTION_1
#include AZ_RESTRICTED_FILE(ScopeGuard_h)
#endif
#if defined(AZ_RESTRICTED_SECTION_IMPLEMENTED)
#undef AZ_RESTRICTED_SECTION_IMPLEMENTED
#else
scope_guard_t(scope_guard_t const&) = delete;
void operator=(scope_guard_t const&) = delete;
scope_guard_t& operator=(scope_guard_t&&) = delete;
#endif
D deleter;
bool execute_on_destruction;
// exposition only
};
template <typename D>
scope_guard_t<D> scope_guard(D&& deleter)
{
return scope_guard_t<D>(std::move(deleter));
// fails with curlies
}
enum class invoke_it
{
once, again
};
template<typename R, typename D>
class unique_resource_t
{
R resource;
D deleter;
bool execute_on_destruction;
// exposition only
#if defined(AZ_RESTRICTED_PLATFORM)
#define AZ_RESTRICTED_SECTION SCOPEGUARD_H_SECTION_2
#include AZ_RESTRICTED_FILE(ScopeGuard_h)
#endif
#if defined(AZ_RESTRICTED_SECTION_IMPLEMENTED)
#undef AZ_RESTRICTED_SECTION_IMPLEMENTED
#else
unique_resource_t& operator=(unique_resource_t const&) = delete;
unique_resource_t(unique_resource_t const&) = delete;
#endif
// no copies!
public:
// construction
explicit unique_resource_t(R&& _resource, D&& _deleter, bool _shouldrun = true)
: resource(std::move(_resource))
, deleter(std::move(_deleter))
, execute_on_destruction(_shouldrun)
{
}
// move
unique_resource_t(unique_resource_t&& other)
: resource(std::move(other.resource))
, deleter(std::move(other.deleter))
, execute_on_destruction(other.execute_on_destruction)
{
other.release();
}
unique_resource_t& operator=(unique_resource_t&& other)
{
this->invoke(invoke_it::once);
deleter = std::move(other.deleter);
resource = std::move(other.resource);
execute_on_destruction = other.execute_on_destruction;
other.release();
return *this;
}
// resource release
~unique_resource_t()
{
this->invoke(invoke_it::once);
}
void invoke(invoke_it const strategy = invoke_it::once)
{
if (execute_on_destruction)
{
get_deleter()(resource);
}
execute_on_destruction = strategy == invoke_it::again;
}
R const& release()
{
execute_on_destruction = false;
return this->get();
}
void reset(R&& newresource)
{
invoke(invoke_it::again);
resource = std::move(newresource);
}
// resource access
R const& get() const
{
return resource;
}
operator R const& () const
{
return resource;
}
R operator->() const
{
return resource;
}
typename std::add_lvalue_reference<typename std::remove_pointer<R>::type>::type operator*() const
{
return *resource;
}
// deleter access
const D& get_deleter() const
{
return deleter;
}
};
template<typename R, typename D>
unique_resource_t<R, D> unique_resource(R&& r, D t)
{
return unique_resource_t<R, D>(std::move(r), std::move(t), true);
}
template<typename R, typename D>
unique_resource_t<R, D> unique_resource_checked(R r, R invalid, D t)
{
bool shouldrun = (r != invalid);
return unique_resource_t<R, D>(std::move(r), std::move(t), shouldrun);
}
}
Code/CryEngine/CryCommon/SmartPointersHelpers.h
-27
View File
@@ -1,27 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
// This header is provided for backwards compatibility. Avoid including this header, instead
// include the needed smart ptr headers
#pragma once
#include <AzCore/std/smart_ptr/shared_ptr.h>
#include <AzCore/std/smart_ptr/make_shared.h>
#include <AzCore/std/smart_ptr/weak_ptr.h>
#define DECLARE_SMART_POINTERS(name) \
typedef AZStd::shared_ptr<name> name##Ptr; \
typedef AZStd::shared_ptr<const name> name##ConstPtr; \
typedef AZStd::weak_ptr<name> name##WeakPtr; \
typedef AZStd::weak_ptr<const name> name##ConstWeakPtr;
Code/CryEngine/CryCommon/StackContainer.h
-64
View File
@@ -1,64 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
// Description : Helper to enable inplace construction and destruction of objects
#ifndef CRYINCLUDE_CRYCOMMON_STACKCONTAINER_H
#define CRYINCLUDE_CRYCOMMON_STACKCONTAINER_H
#pragma once
#include <InplaceFactory.h>
// Class that contains a non-pod data type allocated on the stack via placement
// new. Constructor parameters up to an arity of 5 are forwarded over an
// inplace factory expression.
template<typename T>
class CStackContainer
{
// The backing storage
uint8 m_Storage[ sizeof (T) ];
// Constructs the object via an inplace factory
template<class Factory>
void construct (const Factory& factory)
{
factory.template apply<T>(m_Storage);
}
// Destructs the object. The destructor of the contained object is called
void destruct ()
{
reinterpret_cast<T*>(m_Storage)->~T();
}
// Prevent the object to be placed on the heap
// (.... it simply wouldn't make much sense)
void* operator new(size_t);
void operator delete(void*);
public:
// Constructs inside the object
template<class Expr>
CStackContainer (const Expr& expr)
{ construct(expr); }
// Destructs the object contained
~CStackContainer() { destruct(); }
// Accessor methods
T* get() { return reinterpret_cast<T*>(m_Storage); }
const T* get() const { return reinterpret_cast<const T*>(m_Storage); }
};
#endif // CRYINCLUDE_CRYCOMMON_STACKCONTAINER_H
Code/CryEngine/CryCommon/TPool.h
-88
View File
@@ -1,88 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#pragma once
#include <CrySizer.h>
#include <CryPodArray.h>
template <class T>
class TPool
{
public:
TPool(int nPoolSize)
{
m_nPoolSize = nPoolSize;
m_pPool = new T[nPoolSize];
m_lstFree.PreAllocate(nPoolSize, 0);
m_lstUsed.PreAllocate(nPoolSize, 0);
for (int i = 0; i < nPoolSize; i++)
{
m_lstFree.Add(&m_pPool[i]);
}
}
~TPool()
{
delete[] m_pPool;
}
void ReleaseObject(T* pInst)
{
if (m_lstUsed.Delete(pInst))
{
m_lstFree.Add(pInst);
}
}
int GetUsedInstancesCount(int& nAll)
{
nAll = m_nPoolSize;
return m_lstUsed.Count();
}
T* GetObject()
{
T* pInst = NULL;
if (m_lstFree.Count())
{
pInst = m_lstFree.Last();
m_lstFree.DeleteLast();
m_lstUsed.Add(pInst);
}
else
{
assert(!"TPool::GetObject: Out of free elements error");
}
return pInst;
}
void GetMemoryUsage(class ICrySizer* pSizer) const
{
pSizer->AddObject(m_lstFree);
pSizer->AddObject(m_lstUsed);
if (m_pPool)
{
for (int i = 0; i < m_nPoolSize; i++)
{
m_pPool[i].GetMemoryUsage(pSizer);
}
}
}
PodArray<T*> m_lstFree;
PodArray<T*> m_lstUsed;
T* m_pPool;
int m_nPoolSize;
};
Code/CryEngine/CryCommon/UnalignedBlit.h
-141
View File
@@ -1,141 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
// Generic unaligned memory access helpers.
#pragma once
#include <stddef.h>
#include <type_traits>
namespace Detail
{
template<typename RealType, typename BlittedElement>
struct Blitter
{
static_assert(std::is_trivial<BlittedElement>::value, "Blittable elements should be trivial (ie, integral types)");
static_assert((std::alignment_of<BlittedElement>::value < std::alignment_of<RealType>::value), "Blittable memory has sufficient alignment, do not use unaligned store or load");
static_assert(sizeof(RealType) > sizeof(BlittedElement), "Blittable element is larger than real type");
static_assert((sizeof(RealType) % sizeof(BlittedElement)) == 0, "Blitted element has the wrong size for the real type");
typedef std::integral_constant<size_t, sizeof(RealType) / sizeof(BlittedElement)> NumElements;
static void BlitLoad(const BlittedElement* pSource, RealType& target)
{
BlittedElement* pTarget = alias_cast<BlittedElement*>(&target);
for (size_t i = 0; i < NumElements::value; ++i, ++pSource, ++pTarget)
{
* pTarget = *pSource;
}
}
static void BlitStore(const RealType& source, BlittedElement* pTarget)
{
const BlittedElement* pSource = alias_cast<const BlittedElement*>(&source);
for (size_t i = 0; i < NumElements::value; ++i, ++pSource, ++pTarget)
{
* pTarget = *pSource;
}
}
};
}
// Load RealType from unaligned memory using some blittable type.
// The source memory must be suitably aligned for accessing BlittedElement.
// If no memory alignment can be guaranteed, use char for BlittedElement.
template<typename RealType, typename BlittedElement>
inline void LoadUnaligned(const BlittedElement* pMemory, RealType& value,
typename std::enable_if<(std::alignment_of<RealType>::value > std::alignment_of<BlittedElement>::value)>::type* = nullptr)
{
Detail::Blitter<RealType, BlittedElement>::BlitLoad(pMemory, value);
}
// Load RealType from aligned memory (fallback overload).
// This is used if there is no reason to call the blitter, because sufficient alignment is guaranteed by BlittedElement.
template<typename RealType, typename BlittedElement>
inline void LoadUnaligned(const BlittedElement* pMemory, RealType& value,
typename std::enable_if<(std::alignment_of<RealType>::value <= std::alignment_of<BlittedElement>::value)>::type* = nullptr)
{
value = *alias_cast<RealType*>(pMemory);
}
// Store to unaligned memory using some blittable type.
// The target memory must be suitably aligned for accessing BlittedElement.
// If no memory alignment can be guaranteed, use char for BlittedElement.
template<typename RealType, typename BlittedElement>
inline void StoreUnaligned(BlittedElement* pMemory, const RealType& value,
typename std::enable_if<(std::alignment_of<RealType>::value > std::alignment_of<BlittedElement>::value)>::type* = nullptr)
{
Detail::Blitter<RealType, BlittedElement>::BlitStore(value, pMemory);
}
// Store to aligned memory (fallback overload).
// This is used if there is no reason to call the blitter, because sufficient alignment is guaranteed by BlittedElement.
template<typename RealType, typename BlittedElement>
inline void StoreUnaligned(BlittedElement* pMemory, const RealType& value,
typename std::enable_if<(std::alignment_of<RealType>::value <= std::alignment_of<BlittedElement>::value)>::type* = nullptr)
{
*alias_cast<RealType*>(pMemory) = value;
}
// Pads the given pointer to the next possible aligned location for RealType
// Use this to ensure RealType can be referenced in some buffer of BlittedElement's, without using LoadUnaligned/StoreUnaligned
template<typename RealType, typename BlittedElement>
inline BlittedElement* AlignPointer(BlittedElement* pMemory,
typename std::enable_if<(std::alignment_of<RealType>::value % std::alignment_of<BlittedElement>::value) == 0>::type* = nullptr)
{
const size_t align = std::alignment_of<RealType>::value;
const size_t mask = align - 1;
const size_t address = reinterpret_cast<size_t>(pMemory);
const size_t offset = (align - (address & mask)) & mask;
return pMemory + (offset / sizeof(BlittedElement));
}
// Pads the given address to the next possible aligned location for RealType
// Use this to ensure RealType can be referenced inside memory, without using LoadUnaligned/StoreUnaligned
template<typename RealType>
inline size_t AlignAddress(size_t address)
{
return reinterpret_cast<size_t>(AlignPointer<RealType>(reinterpret_cast<char*>(address)));
}
// Provides aligned storage for T, optionally aligned at a specific boundary (default being the native alignment of T)
// The specified T is not initialized automatically, use of placement new/delete is the user's responsibility
template<typename T, size_t Align = std::alignment_of<T>::value>
struct SUninitialized
{
typedef typename std::aligned_storage<sizeof(T), Align>::type Storage;
Storage storage;
void DefaultConstruct()
{
new(static_cast<void*>(&storage))T();
}
void CopyConstruct(const T& value)
{
new(static_cast<void*>(&storage))T(value);
}
void MoveConstruct(T&& value)
{
new(static_cast<void*>(&storage))T(std::move(value));
}
void Destruct()
{
alias_cast<T*>(&storage)->~T();
}
operator T& ()
{
return *alias_cast<T*>(&storage);
}
};
Code/CryEngine/CryCommon/crycommon_files.cmake
-36
View File
@@ -10,23 +10,16 @@
#
set(FILES
QTangent.h
CryCommon.cpp
FinalizingSpline.h
IAudioInterfacesCommonData.h
IAudioSystem.h
IChunkFile.h
ICmdLine.h
IColorGradingController.h
IConsole.h
IEntityRenderState.h
IEntityRenderState_info.cpp
IFont.h
IFunctorBase.h
IFuncVariable.h
IGem.h
IGeomCache.h
IImage.h
IIndexedMesh.h
IIndexedMesh_info.cpp
ILevelSystem.h
@@ -35,11 +28,9 @@ set(FILES
LocalizationManagerBus.inl
ILog.h
IMaterial.h
IMeshBaking.h
IMiniLog.h
IMovieSystem.h
IPhysics.h
IPhysicsDebugRenderer.h
IPostEffectGroup.h
IProcess.h
IReadWriteXMLSink.h
@@ -48,7 +39,6 @@ set(FILES
IRenderMesh.h
ISerialize.h
IShader.h
IShader_info.h
ISplines.h
IStatObj.h
StatObjBus.h
@@ -58,18 +48,15 @@ set(FILES
ITexture.h
ITimer.h
IValidator.h
IVideoRenderer.h
IViewSystem.h
IWindowMessageHandler.h
IXml.h
IProximityTriggerSystem.h
MicrophoneBus.h
physinterface.h
HMDBus.h
VRCommon.h
StereoRendererBus.h
HeightmapUpdateNotificationBus.h
IObjManager.h
INavigationSystem.h
IMNM.h
SFunctor.h
@@ -82,18 +69,15 @@ set(FILES
CryRandomInternal.h
Random.h
LCGRandom.h
MaterialUtils.h
MTPseudoRandom.cpp
CryTypeInfo.cpp
BaseTypes.h
CompileTimeAssert.h
intrusive_list.hpp
MemoryAccess.h
AnimKey.h
BitFiddling.h
Common_TypeInfo.cpp
CryArray.h
CryArray2d.h
CryAssert.h
CryCrc32.h
CryCustomTypes.h
@@ -106,44 +90,31 @@ set(FILES
CryName.h
CryPath.h
CryPodArray.h
CryPtrArray.h
CrySizer.h
CryString.h
CrySystemBus.h
CryThread.h
CryThreadImpl.h
CryTypeInfo.h
CryUtils.h
CryVersion.h
CryZlib.h
FrameProfiler.h
HashGrid.h
HeapAllocator.h
HeapContainer.h
InplaceFactory.h
LegacyAllocator.h
MetaUtils.h
MiniQueue.h
MTPseudoRandom.h
MultiThread.h
MultiThread_Containers.h
Name_TypeInfo.h
NullAudioSystem.h
PNoise3.h
PoolAllocator.h
primitives.h
primitives_info.h
ProjectDefines.h
Range.h
RenderContextConfig.h
RingBuffer.h
ScopeGuard.h
ScopedVariableSetter.h
SerializeFwd.h
SimpleSerialize.h
SmartPointersHelpers.h
smartptr.h
StackContainer.h
StlUtils.h
StringUtils.h
Synchronization.h
@@ -153,7 +124,6 @@ set(FILES
TimeValue_info.h
TypeInfo_decl.h
TypeInfo_impl.h
UnalignedBlit.h
UnicodeBinding.h
UnicodeEncoding.h
UnicodeFunctions.h
@@ -164,10 +134,6 @@ set(FILES
XMLBinaryHeaders.h
RenderBus.h
MainThreadRenderRequestBus.h
OceanConstants.h
PakLoadDataUtils.cpp
PakLoadDataUtils.h
TPool.h
Cry_Matrix33.h
Cry_Matrix34.h
Cry_Matrix44.h
@@ -186,7 +152,6 @@ set(FILES
Cry_Vector3.h
Cry_XOptimise.h
CryHalf_info.h
GeomQuery.h
CryHalf.inl
MathConversion.h
Cry_HWMatrix.h
@@ -308,6 +273,5 @@ set(FILES
Maestro/Types/AssetBlends.h
Maestro/Types/SequenceType.h
StaticInstance.h
Pak/CryPakUtils.h
WinBase.cpp
)
Code/CryEngine/CryCommon/intrusive_list.hpp
-180
View File
@@ -1,180 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#ifndef _INTRUSIVE_LIST_HPP
#define _INTRUSIVE_LIST_HPP
#if !defined(WIN32)
#include <stdint.h>
#endif //!defined(WIN32)
namespace util
{
// Simple lightweight intrusive list utility
//
template<typename Host>
struct list
{
typedef Host value_type;
list* next;
list* prev;
// Default (initializing) constructor
list()
{
next = this;
prev = this;
}
// Inserts this list into a given list item between
// prev and next (note: they need to be sequential!)
void insert(list* _prev, list* _next)
{
_next->prev = this;
this->next = _next;
this->prev = _prev;
_prev->next = this;
}
// Should only be called on heads
void clear() { next = prev = this; }
// Removes from a list, then inserts this list item into a given list between
// prev and next (note: they need to be sequential!)
void re_insert(list* _prev, list* _next)
{
erase();
insert(_prev, _next);
}
// Remove this list instance from a list
// Safe to be called even if not attached to a list
void erase()
{
next->prev = prev;
prev->next = next;
next = prev = this;
}
// Predicate to determine if a list structure is linked to a list
bool empty() const { return prev == this && next == this; }
bool linked() const { return !empty(); }
// Get the host instance of the instrusive list
template<list Host::* member>
Host* item()
{
return ((Host*)((uintptr_t)(this) - (uintptr_t)(&(((Host*)0)->*member))));
}
template<list Host::* member>
const Host* item() const
{
return ((Host*)((uintptr_t)(this) - (uintptr_t)(&(((Host*)0)->*member))));
}
template<list (Host::* Member)[2]>
Host * item(int threadId)
{
uintptr_t value = (uintptr_t)this - (uintptr_t)&((((Host*)(NULL))->*Member)[threadId]);
return alias_cast<Host*>(value);
}
// Insert & relink functions
void insert_tail(list* _list) { insert(_list->prev, _list); }
void insert_tail(list& _list) { insert_tail(&_list); }
void insert_head(list* _list) { insert(_list, _list->next); }
void insert_head(list& _list) { insert_head(&_list); }
void relink_tail(list* _list) { erase(); insert_tail(_list); }
void relink_tail(list& _list) { relink_tail(&_list); }
void relink_head(list* _list) { erase(); insert_head(_list); }
void relink_head(list& _list) { relink_head(&_list); }
static inline void splice(const list* _list, list* prev, list* next)
{
list* first = _list->next;
list* last = _list->prev;
first->prev = prev;
prev->next = first;
last->next = next;
next->prev = last;
}
void splice_front(const list* _list)
{
if (!_list->empty())
{
splice(_list, this, this->next);
_list->clear();
}
}
void splice_tail(list* _list)
{
if (!_list->empty())
{
splice(_list, this->prev, this);
_list->clear();
}
}
// Accessors
list<Host>* tail() { return prev; }
const list<Host>* tail() const { return prev; }
list<Host>* head() { return head; }
const list<Host>* head() const { return head; }
};
// utility to extract the host type of an intrusive list at compile time
template<typename List>
struct list_value_type
{
typedef typename List::value_type value_type;
};
// Loops over the list in forward manner, pos will be of type list<T>*
# define list_for_each(pos, head) \
for (typeof(head)pos = (head)->next; pos != (head); \
pos = pos->next)
// Loops over the list in backward manner, pos will be of type list<T>*
# define list_for_each_backwards(pos, head) \
for (typeof(head)pos = (head)->prev; pos != (head); \
pos = pos->prev)
// Loops over the list in forward manner while safeguarding
// against list removal during iteration. pos will be of type list<T>*
# define list_for_each_safe(pos, head) \
for (typeof(head)pos = (head)->next, n = pos->next; pos != (head); \
pos = n, n = pos->next)
// Loops over the list in forward manner. pos will be of type list<T>*
# define list_for_each_entry(pos, head, member) \
for (util::list_value_type<typeof((head))>::value_type* pos = \
(head)->next->item<member>(); \
&(pos->*(member)) != &list; \
pos = ((pos->*(member)).next->item<member>()))
// Loops over the list in forward manner while safeguarding against list
// removal during iteratation. pos will be of type T*
# define list_for_each_entry_safe(pos, head, member) \
for (util::list_value_type<typeof((head))>::value_type* pos = \
(head)->next->item<member>(), \
* n = ((pos->*(member)).next->item<member>()); \
&(pos->*(member)) != &list; \
pos = n, n = ((n->*(member)).next->item<member>()))
} // end namespace util
#endif // ifndef _INTRUSIVE_LIST_HPP
Code/CryEngine/CryCommon/primitives_info.h
-50
View File
@@ -1,50 +0,0 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#ifndef CRYINCLUDE_CRYCOMMON_PRIMITIVES_INFO_H
#define CRYINCLUDE_CRYCOMMON_PRIMITIVES_INFO_H
#pragma once
#include "primitives.h"
STRUCT_INFO_TYPE_EMPTY(primitives::primitive)
STRUCT_INFO_BEGIN(primitives::box)
STRUCT_BASE_INFO(primitives::primitive)
STRUCT_VAR_INFO(Basis, TYPE_INFO(Matrix33))
STRUCT_VAR_INFO(bOriented, TYPE_INFO(int))
STRUCT_VAR_INFO(center, TYPE_INFO(Vec3))
STRUCT_VAR_INFO(size, TYPE_INFO(Vec3))
STRUCT_INFO_END(primitives::box)
STRUCT_INFO_BEGIN(primitives::sphere)
STRUCT_BASE_INFO(primitives::primitive)
STRUCT_VAR_INFO(center, TYPE_INFO(Vec3))
STRUCT_VAR_INFO(r, TYPE_INFO(float))
STRUCT_INFO_END(primitives::sphere)
STRUCT_INFO_BEGIN(primitives::cylinder)
STRUCT_BASE_INFO(primitives::primitive)
STRUCT_VAR_INFO(center, TYPE_INFO(Vec3))
STRUCT_VAR_INFO(axis, TYPE_INFO(Vec3))
STRUCT_VAR_INFO(r, TYPE_INFO(float))
STRUCT_VAR_INFO(hh, TYPE_INFO(float))
STRUCT_INFO_END(primitives::cylinder)
STRUCT_INFO_BEGIN(primitives::plane)
STRUCT_BASE_INFO(primitives::primitive)
STRUCT_VAR_INFO(n, TYPE_INFO(Vec3))
STRUCT_VAR_INFO(origin, TYPE_INFO(Vec3))
STRUCT_INFO_END(primitives::plane)
#endif // CRYINCLUDE_CRYCOMMON_PRIMITIVES_INFO_H
Code/CryEngine/CrySystem/LevelSystem/LevelSystem.cpp
-1
View File
@@ -19,7 +19,6 @@
#include "IMovieSystem.h"
#include <ILocalizationManager.h>
#include "CryPath.h"
#include <Pak/CryPakUtils.h>
#include <LoadScreenBus.h>
Code/CryEngine/CrySystem/LocalizedStringManager.cpp
-2
View File
@@ -28,8 +28,6 @@
#include <locale.h>
#include <time.h>
#include "CryZlib.h"
#include <AzCore/std/string/conversions.h>
#include <AzFramework/StringFunc/StringFunc.h>
Code/CryEngine/CrySystem/Log.cpp
-4
View File
@@ -22,7 +22,6 @@
#include <ISystem.h>
#include "System.h"
#include "CryPath.h" // PathUtil::ReplaceExtension()
#include <Pak/CryPakUtils.h>
#include "UnicodeFunctions.h"
#include <AzFramework/IO/FileOperations.h>
@@ -237,7 +236,6 @@ void CLog::CloseLogFile([[maybe_unused]] bool forceClose)
//////////////////////////////////////////////////////////////////////////
AZ::IO::HandleType CLog::OpenLogFile(const char* filename, const char* mode)
{
CDebugAllowFileAccess ignoreInvalidFileAccess;
using namespace AZ::IO;
AZ_Assert(m_logFileHandle == AZ::IO::InvalidHandle, "Attempt to open log file when one is already open. This would lead to a handle leak.");
@@ -1116,8 +1114,6 @@ void CLog::LogStringToFile(const char* szString, ELogType logType, bool bAdd, [[
if (logToFile)
{
CDebugAllowFileAccess dafa;
if (m_logFileHandle == AZ::IO::InvalidHandle)
{
OpenLogFile(m_szFilename, "w+t");
Code/CryEngine/CrySystem/SystemInit.cpp
-1
View File
@@ -91,7 +91,6 @@
#include <HMDBus.h>
#include <AzFramework/Archive/Archive.h>
#include <Pak/CryPakUtils.h>
#include "XConsole.h"
#include "Log.h"
#include "XML/xml.h"
Code/Framework/AtomCore/AtomCore/std/parallel/concurrency_checker.h
+22 -2
View File
@@ -20,10 +20,12 @@
namespace AZStd
{
//! Simple class for verifying that no concurrent access is occuring.
//! Simple class for verifying that no concurrent access is occurring.
//! This is *not* a synchronization primitive, and is intended simply for checking that no concurrency issues exist.
//! It will be compiled out in release builds.
//! Use concurrency_checker like a mutex (i.e. call soft_lock() and soft_unlock() around all instances of your data access).
//! Use soft_lock_shared and soft_unlock_shared around places where multiple threads are allowed to have read access
//! at the same time as long as nothing else already has a soft lock
//! It will assert if there are multiple threads accessing the locked code/data at the same time.
//! Expected use case is for defensive programming: when you do not expect any concurrent access within a system,
//! but want to verify that it stays that way in the future, without incurring the overhead of a mutex.
@@ -34,7 +36,7 @@ namespace AZStd
{
#ifdef AZ_CONCURRENCY_CHECKER_ENABLED
uint32_t count = ++m_concurrencyCounter;
AZ_Assert(count == 1, "Concurrency check failed. Multiple threads are trying to access data at the same time, or there is a lock/unlock mismatch.");
AZ_Assert(count == 1 && m_sharedConcurrencyCounter == 0, "Concurrency check failed. Multiple threads are trying to access data at the same time, or there is a lock/unlock mismatch.");
#endif
}
@@ -46,9 +48,27 @@ namespace AZStd
#endif
}
AZ_FORCE_INLINE void soft_lock_shared()
{
#ifdef AZ_CONCURRENCY_CHECKER_ENABLED
AZ_Assert(m_concurrencyCounter == 0, "Concurrency check failed. A soft_lock_shared was attempted when there was already a soft_lock.");
++m_sharedConcurrencyCounter;
#endif
}
AZ_FORCE_INLINE void soft_unlock_shared()
{
#ifdef AZ_CONCURRENCY_CHECKER_ENABLED
AZ_Assert(m_sharedConcurrencyCounter != 0, "Concurrency check failed. There is a shared_lock/shared_unlock mismatch.");
--m_sharedConcurrencyCounter;
#endif
}
private:
#ifdef AZ_CONCURRENCY_CHECKER_ENABLED
AZStd::atomic_uint32_t m_concurrencyCounter = 0;
AZStd::atomic_uint32_t m_sharedConcurrencyCounter = 0;
#endif
};
Code/Framework/AtomCore/Tests/ArrayView.cpp
+2 -5
View File
@@ -293,15 +293,12 @@ namespace UnitTest
{
array_view<int> view({ 1,2,3,4 });
UnitTest::TestRunner::Instance().StartAssertTests();
AZ_TEST_START_TRACE_SUPPRESSION;
EXPECT_EQ(0, UnitTest::TestRunner::Instance().m_numAssertsFailed);
view[4];
EXPECT_EQ(1, UnitTest::TestRunner::Instance().m_numAssertsFailed);
view[5];
EXPECT_EQ(2, UnitTest::TestRunner::Instance().m_numAssertsFailed);
UnitTest::TestRunner::Instance().StopAssertTests();
AZ_TEST_STOP_TRACE_SUPPRESSION(2);
}
}
Code/Framework/AtomCore/Tests/ConcurrencyCheckerTests.cpp
+100
View File
@@ -0,0 +1,100 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <AtomCore/std/parallel/concurrency_checker.h>
#include <AzCore/UnitTest/TestTypes.h>
using namespace AZStd;
namespace UnitTest
{
class ConcurrencyCheckerTestFixture
: public AllocatorsTestFixture
{
void SetUp() override
{
AllocatorsFixture::SetUp();
}
};
TEST_F(AllocatorsTestFixture, SoftLock_NoContention_NoAsserts)
{
concurrency_checker concurrencyChecker;
concurrencyChecker.soft_lock();
concurrencyChecker.soft_unlock();
concurrencyChecker.soft_lock();
concurrencyChecker.soft_unlock();
}
TEST_F(AllocatorsTestFixture, SoftLock_AlreadyLocked_Assert)
{
concurrency_checker concurrencyChecker;
concurrencyChecker.soft_lock();
AZ_TEST_START_TRACE_SUPPRESSION;
concurrencyChecker.soft_lock();
AZ_TEST_STOP_TRACE_SUPPRESSION(1);
}
TEST_F(AllocatorsTestFixture, SoftUnlock_NotAlreadyLocked_Assert)
{
concurrency_checker concurrencyChecker;
concurrencyChecker.soft_lock();
concurrencyChecker.soft_unlock();
AZ_TEST_START_TRACE_SUPPRESSION;
concurrencyChecker.soft_unlock();
AZ_TEST_STOP_TRACE_SUPPRESSION(1);
}
TEST_F(AllocatorsTestFixture, SoftLockShared_NoContention_NoAsserts)
{
concurrency_checker concurrencyChecker;
// Multiple shared locks can be made at once,
// as long as they are all unlocked before the next soft_lock
concurrencyChecker.soft_lock_shared();
concurrencyChecker.soft_lock_shared();
concurrencyChecker.soft_unlock_shared();
concurrencyChecker.soft_unlock_shared();
concurrencyChecker.soft_lock();
concurrencyChecker.soft_unlock();
concurrencyChecker.soft_lock_shared();
concurrencyChecker.soft_lock_shared();
concurrencyChecker.soft_unlock_shared();
concurrencyChecker.soft_unlock_shared();
concurrencyChecker.soft_lock();
concurrencyChecker.soft_unlock();
}
TEST_F(AllocatorsTestFixture, SoftLockShared_SharedLockAfterSoftLock_Assert)
{
concurrency_checker concurrencyChecker;
concurrencyChecker.soft_lock();
AZ_TEST_START_TRACE_SUPPRESSION;
concurrencyChecker.soft_lock_shared();
AZ_TEST_STOP_TRACE_SUPPRESSION(1);
}
TEST_F(AllocatorsTestFixture, SoftUnlockShared_NotAlreadyLocked_Assert)
{
concurrency_checker concurrencyChecker;
concurrencyChecker.soft_lock_shared();
concurrencyChecker.soft_unlock_shared();
AZ_TEST_START_TRACE_SUPPRESSION;
concurrencyChecker.soft_unlock_shared();
AZ_TEST_STOP_TRACE_SUPPRESSION(1);
}
}
Code/Framework/AtomCore/Tests/atomcore_tests_files.cmake
+1
View File
@@ -11,6 +11,7 @@
set(FILES
ArrayView.cpp
ConcurrencyCheckerTests.cpp
InstanceDatabase.cpp
JsonSerializationUtilsTests.cpp
lru_cache.cpp
Code/Framework/AzCore/AzCore/Memory/OverrunDetectionAllocator.cpp
+2 -2
View File
@@ -103,7 +103,7 @@ namespace AZ
}
}
/// Returns a pointer to the beginning of master vector of SmallAllocationGroups.
/// Returns a pointer to the beginning of vector of SmallAllocationGroups.
SmallAllocationGroup* ArrayHead()
{
return this - m_index;
@@ -169,7 +169,7 @@ namespace AZ
return m_marker == MARKER;
}
/// Returns the master index of the SmallAllocationGroup containing this allocation
/// Returns the index of the SmallAllocationGroup containing this allocation
uint32_t GetSmallAllocationIndex() const
{
return (uint32_t)(m_data & 0xFFFFFFFF);
Code/Framework/AzCore/AzCore/Slice/SliceComponent.cpp
+4 -1
View File
@@ -1740,7 +1740,10 @@ namespace AZ
if (!iter->IsInstantiated())
{
#if defined(AZ_ENABLE_TRACING)
Data::Asset<SliceAsset> thisAsset = Data::AssetManager::Instance().FindAsset(GetMyAsset()->GetId(), AZ::Data::AssetLoadBehavior::Default);
Data::Asset<SliceAsset> thisAsset = GetMyAsset()
? Data::Asset<SliceAsset>(Data::AssetManager::Instance().FindAsset(
GetMyAsset()->GetId(), AZ::Data::AssetLoadBehavior::Default))
: Data::Asset<SliceAsset>();
AZ_Warning("Slice", false, "Removing %d instances of slice asset %s from parent asset %s due to failed instantiation. "
"Saving parent asset will result in loss of slice data.",
iter->GetInstances().size(),
Code/Framework/AzCore/Platform/iOS/AzCore/Module/DynamicModuleHandle_iOS.cpp
+1 -1
View File
@@ -40,7 +40,7 @@ namespace AZ
// Afterwards use the AZ::IO::Path Append function append the filename as a child
// of the framework directory
AZ::IO::FixedMaxPathString fileName{ fullPath.Filename().Native() };
fullPath.ReplaceFilename(AZ::IO::PathView((fileName + ".framework").c_str()));
fullPath.ReplaceFilename(AZ::IO::PathView(AZStd::string_view(fileName + ".framework")));
fullPath /= fileName;
}
}
Code/Framework/AzFramework/AzFramework/Archive/IArchive.h
+1 -2
View File
@@ -115,7 +115,7 @@ namespace AZ::IO
// If used, the source path will be treated as the destination path
// and no transformations will be done. Pass this flag when the path is to be the actual
// path on the disk/in the packs and doesn't need adjustment (or after it has come through adjustments already)
// if this is set, AdjustFileName will not map the input path into the master folder (Ex: Shaders will not be converted to Game\Shaders)
// if this is set, AdjustFileName will not map the input path into the folder (Ex: Shaders will not be converted to Game\Shaders)
FLAGS_PATH_REAL = 1 << 16,
// AdjustFileName will always copy the file path to the destination path:
@@ -318,7 +318,6 @@ namespace AZ::IO
virtual ArchiveFileIterator FindFirst(AZStd::string_view pDir, uint32_t nFlags = 0, bool bAllowUseFileSystem = false) = 0;
virtual ArchiveFileIterator FindNext(AZ::IO::ArchiveFileIterator handle) = 0;
virtual bool FindClose(AZ::IO::ArchiveFileIterator handle) = 0;
// virtual bool IsOutOfDate(const char * szCompiledName, const char * szMasterFile)=0;
//returns file modification time
virtual IArchive::FileTime GetModificationTime(AZ::IO::HandleType fileHandle) = 0;
Code/Framework/AzFramework/AzFramework/Archive/INestedArchive.h
+1 -1
View File
@@ -47,7 +47,7 @@ namespace AZ::IO
enum EPakFlags
{
// support for absolute and other complex path specifications -
// all paths will be treated relatively to the current directory (normally MasterCD)
// all paths will be treated relatively to the current directory
FLAGS_ABSOLUTE_PATHS = 1,
// if this is set, the object will only understand relative to the zip file paths,
Code/Framework/AzFramework/AzFramework/Physics/Character.h
+2 -1
View File
@@ -18,6 +18,7 @@
#include <AzFramework/Physics/Collision/CollisionGroups.h>
#include <AzFramework/Physics/Collision/CollisionLayers.h>
#include <AzFramework/Physics/Common/PhysicsTypes.h>
#include <AzFramework/Physics/Common/PhysicsSimulatedBody.h>
#include <AzFramework/Physics/Configuration/SimulatedBodyConfiguration.h>
@@ -36,7 +37,7 @@ namespace Physics
static void Reflect(AZ::ReflectContext* context);
AZStd::string m_name;
ShapeConfigurationList m_shapes;
AzPhysics::ShapeColliderPairList m_shapes;
};
class CharacterColliderConfiguration
Code/Framework/AzFramework/AzFramework/Physics/ClassConverters.cpp
+6 -4
View File
@@ -57,7 +57,7 @@ namespace Physics
classElement.RemoveElement(shapesIndex);
// add a new vector in the new format
const int newShapesIndex = classElement.AddElement<ShapeConfigurationList>(context, "shapes");
const int newShapesIndex = classElement.AddElement<AzPhysics::ShapeColliderPairList>(context, "shapes");
if (newShapesIndex != -1)
{
AZ::SerializeContext::DataElementNode& newShapesElement = classElement.GetSubElement(newShapesIndex);
@@ -65,7 +65,9 @@ namespace Physics
// convert the old shapes into the new format and add to the vector
for (AZ::SerializeContext::DataElementNode shape : shapesCopy)
{
const int pairIndex = newShapesElement.AddElementWithData<ShapeConfigurationPair>(context, "element", ShapeConfigurationPair());
const int pairIndex = newShapesElement.AddElementWithData<AzPhysics::ShapeColliderPair>(
context, "element", AzPhysics::ShapeColliderPair());
AZ::SerializeContext::DataElementNode& pairElement = newShapesElement.GetSubElement(pairIndex);
ColliderConfiguration colliderConfig;
@@ -131,8 +133,8 @@ namespace Physics
AZ::SerializeContext::DataElementNode* baseBaseClass1 = baseClass1->FindSubElement(AZ_CRC("BaseClass1", 0xd4925735));
if (baseBaseClass1 && baseBaseClass1->FindSubElementAndGetData<AZStd::string>(AZ_CRC("name", 0x5e237e06), name))
{
ShapeConfigurationList shapes;
if (nodeElement.FindSubElementAndGetData<ShapeConfigurationList>(AZ_CRC("shapes", 0x93dba512), shapes))
AzPhysics::ShapeColliderPairList shapes;
if (nodeElement.FindSubElementAndGetData<AzPhysics::ShapeColliderPairList>(AZ_CRC("shapes", 0x93dba512), shapes))
{
CharacterColliderNodeConfiguration newColliderNodeConfig;
newColliderNodeConfig.m_name = name;
Code/Framework/AzFramework/AzFramework/Physics/Common/PhysicsTypes.h
+4 -1
View File
@@ -70,7 +70,10 @@ namespace AzPhysics
using SimulatedBodyHandleList = AZStd::vector<SimulatedBodyHandle>;
//! Helper used for pairing the ShapeConfiguration and ColliderConfiguration together which is used when creating a Simulated Body.
using ShapeColliderPair = AZStd::pair<Physics::ColliderConfiguration*, Physics::ShapeConfiguration*>;
using ShapeColliderPair = AZStd::pair<
AZStd::shared_ptr<Physics::ColliderConfiguration>,
AZStd::shared_ptr<Physics::ShapeConfiguration>>;
using ShapeColliderPairList = AZStd::vector<ShapeColliderPair>;
//! Flags used to specifying which properties of a body to compute.
enum class MassComputeFlags : AZ::u8
Code/Framework/AzFramework/AzFramework/Physics/Shape.h
-3
View File
@@ -80,9 +80,6 @@ namespace Physics
void OnContactOffsetChanged();
};
using ShapeConfigurationPair = AZStd::pair<AZStd::shared_ptr<ColliderConfiguration>, AZStd::shared_ptr<ShapeConfiguration>>;
using ShapeConfigurationList = AZStd::vector<ShapeConfigurationPair>;
struct RayCastRequest;
class Shape
Code/Framework/AzFramework/AzFramework/Script/ScriptComponent.cpp
+4 -4
View File
@@ -264,12 +264,12 @@ namespace AzFramework
// SampleRPC =
// {
// // Two callbacks can be registered to the NetRPC
// // A function to be invoked on the Master - OnMaster
// // A function to be invoked on the main server - OnServer
// // and a function to be invoked on the Proxy - OnProxy
// //
// // Every NetRPC needs to have a valid OnMaster function, while OnProxy is optional.
// OnMaster = function()
// Debug.Log("Function to be invoked on the Master.");
// // Every NetRPC needs to have a valid OnServer function, while OnProxy is optional.
// OnServer = function()
// Debug.Log("Function to be invoked on the server.");
// end
//
// OnProxy = function()
Code/Framework/AzFramework/AzFramework/Spawnable/SpawnableEntitiesInterface.h
+4 -2
View File
@@ -84,6 +84,7 @@ namespace AzFramework
};
using EntitySpawnCallback = AZStd::function<void(EntitySpawnTicket&, SpawnableConstEntityContainerView)>;
using EntityPreInsertionCallback = AZStd::function<void(EntitySpawnTicket&, SpawnableEntityContainerView)>;
using EntityDespawnCallback = AZStd::function<void(EntitySpawnTicket&)>;
using ReloadSpawnableCallback = AZStd::function<void(EntitySpawnTicket&, SpawnableConstEntityContainerView)>;
using ListEntitiesCallback = AZStd::function<void(EntitySpawnTicket&, SpawnableConstEntityContainerView)>;
@@ -110,7 +111,8 @@ namespace AzFramework
//! @param completionCallback Optional callback that's called when spawning entities has completed. This can be called from
//! a different thread than the one that made the function call. The returned list of entities contains all the newly
//! created entities.
virtual void SpawnAllEntities(EntitySpawnTicket& ticket, EntitySpawnCallback completionCallback = {}) = 0;
virtual void SpawnAllEntities(EntitySpawnTicket& ticket, EntityPreInsertionCallback preInsertionCallback = {},
EntitySpawnCallback completionCallback = {}) = 0;
//! Spawn instances of some entities in the spawnable.
//! @param ticket Stores the results of the call. Use this ticket to spawn additional entities or to despawn them.
//! @param entityIndices The indices into the template entities stored in the spawnable that will be used to spawn entities from.
@@ -118,7 +120,7 @@ namespace AzFramework
//! a different thread than the one that made this function call. The returned list of entities contains all the newly
//! created entities.
virtual void SpawnEntities(EntitySpawnTicket& ticket, AZStd::vector<size_t> entityIndices,
EntitySpawnCallback completionCallback = {}) = 0;
EntityPreInsertionCallback preInsertionCallback = {}, EntitySpawnCallback completionCallback = {}) = 0;
//! Removes all entities in the provided list from the environment.
//! @param ticket The ticket previously used to spawn entities with.
//! @param completionCallback Optional callback that's called when despawning entities has completed. This can be called from
Code/Framework/AzFramework/AzFramework/Spawnable/SpawnableEntitiesManager.cpp
+114 -20
View File
@@ -14,17 +14,20 @@
#include <AzCore/Serialization/SerializeContext.h>
#include <AzCore/std/parallel/scoped_lock.h>
#include <AzCore/std/smart_ptr/make_shared.h>
#include <AzFramework/Components/TransformComponent.h>
#include <AzFramework/Entity/GameEntityContextBus.h>
#include <AzFramework/Spawnable/Spawnable.h>
#include <AzFramework/Spawnable/SpawnableEntitiesManager.h>
namespace AzFramework
{
void SpawnableEntitiesManager::SpawnAllEntities(EntitySpawnTicket& ticket, EntitySpawnCallback completionCallback)
void SpawnableEntitiesManager::SpawnAllEntities(EntitySpawnTicket& ticket, EntityPreInsertionCallback preInsertionCallback,
EntitySpawnCallback completionCallback)
{
SpawnAllEntitiesCommand queueEntry;
queueEntry.m_ticket = &ticket;
queueEntry.m_completionCallback = AZStd::move(completionCallback);
queueEntry.m_preInsertionCallback = AZStd::move(preInsertionCallback);
{
AZStd::scoped_lock queueLock(m_pendingRequestQueueMutex);
queueEntry.m_ticketId = GetTicketPayload<Ticket>(ticket).m_nextTicketId++;
@@ -32,13 +35,15 @@ namespace AzFramework
}
}
void SpawnableEntitiesManager::SpawnEntities(EntitySpawnTicket& ticket, AZStd::vector<size_t> entityIndices,
EntitySpawnCallback completionCallback)
void SpawnableEntitiesManager::SpawnEntities(
EntitySpawnTicket& ticket, AZStd::vector<size_t> entityIndices,
EntityPreInsertionCallback preInsertionCallback, EntitySpawnCallback completionCallback)
{
SpawnEntitiesCommand queueEntry;
queueEntry.m_ticket = &ticket;
queueEntry.m_entityIndices = AZStd::move(entityIndices);
queueEntry.m_completionCallback = AZStd::move(completionCallback);
queueEntry.m_preInsertionCallback = AZStd::move(preInsertionCallback);
{
AZStd::scoped_lock queueLock(m_pendingRequestQueueMutex);
queueEntry.m_ticketId = GetTicketPayload<Ticket>(ticket).m_nextTicketId++;
@@ -205,6 +210,7 @@ namespace AzFramework
AZ::Entity* clone = serializeContext.CloneObject(&entityTemplate);
AZ_Assert(clone != nullptr, "Failed to clone spawnable entity.");
clone->SetId(AZ::Entity::MakeId());
GameEntityContextRequestBus::Broadcast(&GameEntityContextRequestBus::Events::AddGameEntity, clone);
return clone;
}
@@ -214,23 +220,79 @@ namespace AzFramework
Ticket& ticket = GetTicketPayload<Ticket>(*request.m_ticket);
if (ticket.m_spawnable.IsReady() && request.m_ticketId == ticket.m_currentTicketId)
{
size_t spawnedEntitiesCount = ticket.m_spawnedEntities.size();
AZStd::vector<AZ::Entity*>& spawnedEntities = ticket.m_spawnedEntities;
AZStd::vector<size_t>& spawnedEntityIndices = ticket.m_spawnedEntityIndices;
const Spawnable::EntityList& entities = ticket.m_spawnable->GetEntities();
size_t entitiesSize = entities.size();
ticket.m_spawnedEntities.reserve(ticket.m_spawnedEntities.size() + entitiesSize);
ticket.m_spawnedEntityIndices.reserve(ticket.m_spawnedEntityIndices.size() + entitiesSize);
// Keep track how many entities there were in the array initially
size_t spawnedEntitiesInitialCount = spawnedEntities.size();
for(size_t i=0; i<entitiesSize; ++i)
// These are 'template' entities we'll be cloning from
const Spawnable::EntityList& entitiesToSpawn = ticket.m_spawnable->GetEntities();
size_t entitiesToSpawnSize = entitiesToSpawn.size();
// Reserve buffers
spawnedEntities.reserve(spawnedEntities.size() + entitiesToSpawnSize);
ticket.m_spawnedEntityIndices.reserve(ticket.m_spawnedEntityIndices.size() + entitiesToSpawnSize);
// TEMP: To be replaced by IdUtils::Remapper
using EntityIdMap = AZStd::unordered_map<AZ::EntityId, AZ::EntityId>;
EntityIdMap templateToCloneIdMap;
// \TEMP
// Clone the entities from Spawnable
for (size_t i = 0; i < entitiesToSpawnSize; ++i)
{
ticket.m_spawnedEntities.push_back(SpawnSingleEntity(*entities[i], serializeContext));
ticket.m_spawnedEntityIndices.push_back(i);
const AZ::Entity& entityTemplate = *entitiesToSpawn[i];
AZ::Entity* clone = serializeContext.CloneObject(&entityTemplate);
AZ_Assert(clone != nullptr, "Failed to clone spawnable entity.");
clone->SetId(AZ::Entity::MakeId());
spawnedEntities.push_back(clone);
spawnedEntityIndices.push_back(i);
// TEMP: To be replaced by IdUtils::Remapper
templateToCloneIdMap[entityTemplate.GetId()] = clone->GetId();
// Update TransformComponent parent Id. It is guaranteed for the entities array to be sorted from parent->child here.
auto* transformComponent = clone->FindComponent<AzFramework::TransformComponent>();
AZ::EntityId parentId = transformComponent->GetParentId();
if (parentId.IsValid())
{
auto it = templateToCloneIdMap.find(parentId);
if (it != templateToCloneIdMap.end())
{
transformComponent->SetParentRelative(it->second);
}
else
{
AZ_Warning(
"SpawnableEntitiesManager", false, "Entity %s doesn't have the parent entity %s present in the spawnable",
clone->GetName().c_str(), parentId.ToString().data());
}
}
// \TEMP
}
// Let other systems know about newly spawned entities for any pre-processing before adding to the scene/game context.
if (request.m_preInsertionCallback)
{
request.m_preInsertionCallback(*request.m_ticket, SpawnableEntityContainerView(
ticket.m_spawnedEntities.begin() + spawnedEntitiesInitialCount, ticket.m_spawnedEntities.end()));
}
// Add to the game context, now the entities are active
AZStd::for_each(ticket.m_spawnedEntities.begin() + spawnedEntitiesInitialCount, ticket.m_spawnedEntities.end(),
[](AZ::Entity* entity)
{
GameEntityContextRequestBus::Broadcast(&GameEntityContextRequestBus::Events::AddGameEntity, entity);
});
// Let other systems know about newly spawned entities for any post-processing after adding to the scene/game context.
if (request.m_completionCallback)
{
request.m_completionCallback(*request.m_ticket, SpawnableConstEntityContainerView(
ticket.m_spawnedEntities.begin() + spawnedEntitiesCount, ticket.m_spawnedEntities.end()));
ticket.m_spawnedEntities.begin() + spawnedEntitiesInitialCount, ticket.m_spawnedEntities.end()));
}
m_onSpawnedEvent.Signal(ticket.m_spawnable);
@@ -249,24 +311,56 @@ namespace AzFramework
Ticket& ticket = GetTicketPayload<Ticket>(*request.m_ticket);
if (ticket.m_spawnable.IsReady() && request.m_ticketId == ticket.m_currentTicketId)
{
size_t spawnedEntitiesCount = ticket.m_spawnedEntities.size();
AZStd::vector<AZ::Entity*>& spawnedEntities = ticket.m_spawnedEntities;
AZStd::vector<size_t>& spawnedEntityIndices = ticket.m_spawnedEntityIndices;
const Spawnable::EntityList& entities = ticket.m_spawnable->GetEntities();
size_t entitiesSize = entities.size();
ticket.m_spawnedEntities.reserve(ticket.m_spawnedEntities.size() + entitiesSize);
ticket.m_spawnedEntityIndices.reserve(ticket.m_spawnedEntityIndices.size() + entitiesSize);
// Keep track how many entities there were in the array initially
size_t spawnedEntitiesInitialCount = spawnedEntities.size();
// These are 'template' entities we'll be cloning from
const Spawnable::EntityList& entitiesToSpawn = ticket.m_spawnable->GetEntities();
size_t entitiesToSpawnSize = request.m_entityIndices.size();
spawnedEntities.reserve(spawnedEntities.size() + entitiesToSpawnSize);
spawnedEntityIndices.reserve(spawnedEntityIndices.size() + entitiesToSpawnSize);
for (size_t index : request.m_entityIndices)
{
ticket.m_spawnedEntities.push_back(SpawnSingleEntity(*entities[index], serializeContext));
ticket.m_spawnedEntityIndices.push_back(index);
if (index < entitiesToSpawn.size())
{
const AZ::Entity& entityTemplate = *entitiesToSpawn[index];
AZ::Entity* clone = serializeContext.CloneObject(&entityTemplate);
AZ_Assert(clone != nullptr, "Failed to clone spawnable entity.");
clone->SetId(AZ::Entity::MakeId());
spawnedEntities.push_back(clone);
spawnedEntityIndices.push_back(index);
}
}
ticket.m_loadAll = false;
// Let other systems know about newly spawned entities for any pre-processing before adding to the scene/game context.
if (request.m_preInsertionCallback)
{
request.m_preInsertionCallback(
*request.m_ticket,
SpawnableEntityContainerView(
ticket.m_spawnedEntities.begin() + spawnedEntitiesInitialCount, ticket.m_spawnedEntities.end()));
}
// Add to the game context, now the entities are active
AZStd::for_each(ticket.m_spawnedEntities.begin() + spawnedEntitiesInitialCount, ticket.m_spawnedEntities.end(),
[](AZ::Entity* entity)
{
GameEntityContextRequestBus::Broadcast(&GameEntityContextRequestBus::Events::AddGameEntity, entity);
});
if (request.m_completionCallback)
{
request.m_completionCallback(*request.m_ticket, SpawnableConstEntityContainerView(
ticket.m_spawnedEntities.begin() + spawnedEntitiesCount, ticket.m_spawnedEntities.end()));
ticket.m_spawnedEntities.begin() + spawnedEntitiesInitialCount, ticket.m_spawnedEntities.end()));
}
m_onSpawnedEvent.Signal(ticket.m_spawnable);
Code/Framework/AzFramework/AzFramework/Spawnable/SpawnableEntitiesManager.h
+4 -2
View File
@@ -47,8 +47,8 @@ namespace AzFramework
// The following functions are thread safe
//
void SpawnAllEntities(EntitySpawnTicket& ticket, EntitySpawnCallback completionCallback = {}) override;
void SpawnEntities(EntitySpawnTicket& ticket, AZStd::vector<size_t> entityIndices,
void SpawnAllEntities(EntitySpawnTicket& ticket, EntityPreInsertionCallback preInsertionCallback = {}, EntitySpawnCallback completionCallback = {}) override;
void SpawnEntities(EntitySpawnTicket& ticket, AZStd::vector<size_t> entityIndices, EntityPreInsertionCallback preInsertionCallback = {},
EntitySpawnCallback completionCallback = {}) override;
void DespawnAllEntities(EntitySpawnTicket& ticket, EntityDespawnCallback completionCallback = {}) override;
@@ -90,6 +90,7 @@ namespace AzFramework
struct SpawnAllEntitiesCommand
{
EntitySpawnCallback m_completionCallback;
EntityPreInsertionCallback m_preInsertionCallback;
EntitySpawnTicket* m_ticket;
uint32_t m_ticketId;
};
@@ -97,6 +98,7 @@ namespace AzFramework
{
AZStd::vector<size_t> m_entityIndices;
EntitySpawnCallback m_completionCallback;
EntityPreInsertionCallback m_preInsertionCallback;
EntitySpawnTicket* m_ticket;
uint32_t m_ticketId;
};
Code/Framework/AzFramework/AzFramework/TargetManagement/NeighborhoodAPI.cpp
+2 -2
View File
@@ -41,7 +41,7 @@ namespace Neighborhood {
//---------------------------------------------------------------------
void NeighborReplica::OnReplicaActivate(const GridMate::ReplicaContext& /*rc*/)
{
// TODO: Should we send the message to ourselves as well (master)?
// TODO: Should we send the message to ourselves as well?
if (IsProxy())
{
AZ_Assert(m_persistentName.Get().c_str(), "Received NeighborReplica with missing persistent name!");
@@ -52,7 +52,7 @@ namespace Neighborhood {
//---------------------------------------------------------------------
void NeighborReplica::OnReplicaDeactivate(const GridMate::ReplicaContext& /*rc*/)
{
// TODO: Should we send the message to ourselves as well (master)?
// TODO: Should we send the message to ourselves as well?
if (IsProxy())
{
EBUS_EVENT(NeighborhoodBus, OnNodeLeft, *this);
Code/Framework/AzFramework/AzFramework/Viewport/CameraInput.cpp
+33 -13
View File
@@ -30,7 +30,8 @@ namespace AzFramework
AZ_CVAR(float, ed_cameraSystemOrbitDollyScrollSpeed, 0.02f, nullptr, AZ::ConsoleFunctorFlags::Null, "");
AZ_CVAR(float, ed_cameraSystemOrbitDollyCursorSpeed, 0.01f, nullptr, AZ::ConsoleFunctorFlags::Null, "");
AZ_CVAR(float, ed_cameraSystemScrollTranslateSpeed, 0.02f, nullptr, AZ::ConsoleFunctorFlags::Null, "");
AZ_CVAR(float, ed_cameraSystemMaxOrbitDistance, 60.0f, nullptr, AZ::ConsoleFunctorFlags::Null, "");
AZ_CVAR(float, ed_cameraSystemMinOrbitDistance, 6.0f, nullptr, AZ::ConsoleFunctorFlags::Null, "");
AZ_CVAR(float, ed_cameraSystemMaxOrbitDistance, 50.0f, nullptr, AZ::ConsoleFunctorFlags::Null, "");
AZ_CVAR(float, ed_cameraSystemLookSmoothness, 5.0f, nullptr, AZ::ConsoleFunctorFlags::Null, "");
AZ_CVAR(float, ed_cameraSystemTranslateSmoothness, 5.0f, nullptr, AZ::ConsoleFunctorFlags::Null, "");
AZ_CVAR(float, ed_cameraSystemRotateSpeed, 0.005f, nullptr, AZ::ConsoleFunctorFlags::Null, "");
@@ -532,20 +533,39 @@ namespace AzFramework
if (Beginning())
{
float hit_distance = 0.0f;
AZ::Plane::CreateFromNormalAndPoint(AZ::Vector3::CreateAxisZ(), AZ::Vector3::CreateAxisZ(ed_cameraSystemDefaultPlaneHeight))
.CastRay(targetCamera.Translation(), targetCamera.Rotation().GetBasisY(), hit_distance);
const auto hasLookAt = [&nextCamera, &targetCamera, lookAtFn = m_lookAtFn] {
if (lookAtFn)
{
if (const auto lookAt = lookAtFn())
{
auto transform = AZ::Transform::CreateLookAt(targetCamera.m_lookAt, *lookAt);
nextCamera.m_lookDist = -lookAt->GetDistance(targetCamera.m_lookAt);
UpdateCameraFromTransform(nextCamera, transform);
if (hit_distance > 0.0f)
return true;
}
}
return false;
}();
if (!hasLookAt)
{
hit_distance = AZStd::min<float>(hit_distance, ed_cameraSystemMaxOrbitDistance);
nextCamera.m_lookDist = -hit_distance;
nextCamera.m_lookAt = targetCamera.Translation() + targetCamera.Rotation().GetBasisY() * hit_distance;
}
else
{
nextCamera.m_lookDist = -ed_cameraSystemMaxOrbitDistance;
nextCamera.m_lookAt = targetCamera.Translation() + targetCamera.Rotation().GetBasisY() * ed_cameraSystemMaxOrbitDistance;
float hit_distance = 0.0f;
AZ::Plane::CreateFromNormalAndPoint(AZ::Vector3::CreateAxisZ(), AZ::Vector3::CreateAxisZ(ed_cameraSystemDefaultPlaneHeight))
.CastRay(targetCamera.Translation(), targetCamera.Rotation().GetBasisY(), hit_distance);
if (hit_distance > 0.0f)
{
hit_distance = AZStd::min<float>(hit_distance, ed_cameraSystemMaxOrbitDistance);
nextCamera.m_lookDist = -hit_distance;
nextCamera.m_lookAt = targetCamera.Translation() + targetCamera.Rotation().GetBasisY() * hit_distance;
}
else
{
nextCamera.m_lookDist = -ed_cameraSystemMinOrbitDistance;
nextCamera.m_lookAt =
targetCamera.Translation() + targetCamera.Rotation().GetBasisY() * ed_cameraSystemMinOrbitDistance;
}
}
}
Code/Framework/AzFramework/AzFramework/Viewport/CameraInput.h
+26 -4
View File
@@ -199,6 +199,7 @@ namespace AzFramework
public:
explicit RotateCameraInput(InputChannelId rotateChannelId);
// CameraInput overrides ...
void HandleEvents(const InputEvent& event, const ScreenVector& cursorDelta, float scrollDelta) override;
Camera StepCamera(const Camera& targetCamera, const ScreenVector& cursorDelta, float scrollDelta, float deltaTime) override;
@@ -239,6 +240,7 @@ namespace AzFramework
public:
PanCameraInput(InputChannelId panChannelId, PanAxesFn panAxesFn);
// CameraInput overrides ...
void HandleEvents(const InputEvent& event, const ScreenVector& cursorDelta, float scrollDelta) override;
Camera StepCamera(const Camera& targetCamera, const ScreenVector& cursorDelta, float scrollDelta, float deltaTime) override;
@@ -279,6 +281,7 @@ namespace AzFramework
public:
explicit TranslateCameraInput(TranslationAxesFn translationAxesFn);
// CameraInput overrides ...
void HandleEvents(const InputEvent& event, const ScreenVector& cursorDelta, float scrollDelta) override;
Camera StepCamera(const Camera& targetCamera, const ScreenVector& cursorDelta, float scrollDelta, float deltaTime) override;
void ResetImpl() override;
@@ -348,6 +351,7 @@ namespace AzFramework
class OrbitDollyScrollCameraInput : public CameraInput
{
public:
// CameraInput overrides ...
void HandleEvents(const InputEvent& event, const ScreenVector& cursorDelta, float scrollDelta) override;
Camera StepCamera(const Camera& targetCamera, const ScreenVector& cursorDelta, float scrollDelta, float deltaTime) override;
};
@@ -357,6 +361,7 @@ namespace AzFramework
public:
explicit OrbitDollyCursorMoveCameraInput(InputChannelId dollyChannelId);
// CameraInput overrides ...
void HandleEvents(const InputEvent& event, const ScreenVector& cursorDelta, float scrollDelta) override;
Camera StepCamera(const Camera& targetCamera, const ScreenVector& cursorDelta, float scrollDelta, float deltaTime) override;
@@ -367,6 +372,7 @@ namespace AzFramework
class ScrollTranslationCameraInput : public CameraInput
{
public:
// CameraInput overrides ...
void HandleEvents(const InputEvent& event, const ScreenVector& cursorDelta, float scrollDelta) override;
Camera StepCamera(const Camera& targetCamera, const ScreenVector& cursorDelta, float scrollDelta, float deltaTime) override;
};
@@ -374,16 +380,32 @@ namespace AzFramework
class OrbitCameraInput : public CameraInput
{
public:
using LookAtFn = AZStd::function<AZStd::optional<AZ::Vector3>()>;
// CameraInput overrides ...
void HandleEvents(const InputEvent& event, const ScreenVector& cursorDelta, float scrollDelta) override;
Camera StepCamera(const Camera& targetCamera, const ScreenVector& cursorDelta, float scrollDelta, float deltaTime) override;
bool Exclusive() const override
{
return true;
}
bool Exclusive() const override;
Cameras m_orbitCameras;
//! Override the default behavior for how a look-at point is calculated.
void SetLookAtFn(const LookAtFn& lookAtFn);
private:
LookAtFn m_lookAtFn;
};
inline void OrbitCameraInput::SetLookAtFn(const LookAtFn& lookAtFn)
{
m_lookAtFn = lookAtFn;
}
inline bool OrbitCameraInput::Exclusive() const
{
return true;
}
struct WindowSize;
//! Map from a generic InputChannel event to a camera specific InputEvent.
Code/Framework/AzNetworking/Platform/Linux/AzNetworking/AzNetworking_Traits_Platform.h
+2 -2
View File
@@ -14,8 +14,8 @@
#define AZ_TRAIT_OS_USE_WINSOCK 0
#define AZ_TRAIT_OS_USE_MACH 0
#define AZ_TRAIT_USE_SOCKET_SERVER_EPOLL 1
#define AZ_TRAIT_USE_SOCKET_SERVER_SELECT 0
#define AZ_TRAIT_USE_SOCKET_SERVER_EPOLL 0
#define AZ_TRAIT_USE_SOCKET_SERVER_SELECT 1
#define AZ_TRAIT_USE_OPENSSL 1
#define AZ_TRAIT_NEEDS_HTONLL 1
Code/Framework/AzQtComponents/AzQtComponents/Utilities/SelectionProxyModel.cpp
+167
View File
@@ -0,0 +1,167 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <AzQtComponents/Utilities/SelectionProxyModel.h>
#include <QAbstractProxyModel>
namespace AzQtComponents
{
SelectionProxyModel::SelectionProxyModel(QItemSelectionModel* sourceSelectionModel, QAbstractProxyModel* proxyModel, QObject* parent)
: QItemSelectionModel(proxyModel, parent)
, m_sourceSelectionModel(sourceSelectionModel)
{
connect(sourceSelectionModel, &QItemSelectionModel::selectionChanged, this, &SelectionProxyModel::OnSourceSelectionChanged);
connect(sourceSelectionModel, &QItemSelectionModel::currentChanged, this, &SelectionProxyModel::OnSourceSelectionCurrentChanged);
connect(proxyModel, &QAbstractItemModel::rowsInserted, this, &SelectionProxyModel::OnProxyModelRowsInserted);
connect(this, &QItemSelectionModel::selectionChanged, this, &SelectionProxyModel::OnProxySelectionChanged);
// Find the chain of proxy models
QAbstractProxyModel* sourceProxyModel = proxyModel;
while (sourceProxyModel)
{
m_proxyModels.push_back(sourceProxyModel);
sourceProxyModel = qobject_cast<QAbstractProxyModel*>(sourceProxyModel->sourceModel());
}
const QItemSelection currentSelection = mapFromSource(m_sourceSelectionModel->selection());
QItemSelectionModel::select(currentSelection, QItemSelectionModel::ClearAndSelect);
const QModelIndex currentModelIndex = mapFromSource(m_sourceSelectionModel->currentIndex());
QItemSelectionModel::setCurrentIndex(currentModelIndex, QItemSelectionModel::ClearAndSelect);
}
void SelectionProxyModel::setCurrentIndex(const QModelIndex &index, QItemSelectionModel::SelectionFlags command)
{
const QModelIndex sourcetIndex = mapToSource(index);
m_sourceSelectionModel->setCurrentIndex(sourcetIndex, command);
}
void SelectionProxyModel::select(const QModelIndex &index, QItemSelectionModel::SelectionFlags command)
{
const QModelIndex sourceIndex = mapToSource(index);
m_sourceSelectionModel->select(sourceIndex, command);
}
void SelectionProxyModel::select(const QItemSelection &selection, QItemSelectionModel::SelectionFlags command)
{
const QItemSelection sourceSelection = mapToSource(selection);
m_sourceSelectionModel->select(sourceSelection, command);
}
void SelectionProxyModel::clear()
{
m_sourceSelectionModel->clear();
}
void SelectionProxyModel::reset()
{
m_sourceSelectionModel->reset();
}
void SelectionProxyModel::clearCurrentIndex()
{
m_sourceSelectionModel->clearCurrentIndex();
}
void SelectionProxyModel::OnSourceSelectionCurrentChanged(const QModelIndex& current, [[maybe_unused]] const QModelIndex& previous)
{
QModelIndex targetCurrent = mapFromSource(current);
QItemSelectionModel::setCurrentIndex(targetCurrent, QItemSelectionModel::NoUpdate);
}
void SelectionProxyModel::OnSourceSelectionChanged(const QItemSelection& selected, const QItemSelection& deselected)
{
QItemSelection targetSelected = mapFromSource(selected);
QItemSelection targetDeselected = mapFromSource(deselected);
QItemSelectionModel::select(targetSelected, QItemSelectionModel::Select);
QItemSelectionModel::select(targetDeselected, QItemSelectionModel::Deselect);
}
void SelectionProxyModel::OnProxySelectionChanged(const QItemSelection& selected, const QItemSelection& deselected)
{
const QItemSelection sourceSelected = mapToSource(selected);
const QItemSelection sourceDeselected = mapToSource(deselected);
// Disconnect from the selectionChanged signal in the source model to prevent recursion. We could also block the signals
// of the source selection model, but someone else may be connected to its signals and expect to get an update.
disconnect(m_sourceSelectionModel, &QItemSelectionModel::selectionChanged, this, &SelectionProxyModel::OnSourceSelectionChanged);
if (selected.empty() && deselected.empty())
{
// Force the signal to fire
emit m_sourceSelectionModel->selectionChanged({}, {});
}
else
{
m_sourceSelectionModel->select(sourceSelected, QItemSelectionModel::Select);
m_sourceSelectionModel->select(sourceDeselected, QItemSelectionModel::Deselect);
}
connect(m_sourceSelectionModel, &QItemSelectionModel::selectionChanged, this, &SelectionProxyModel::OnSourceSelectionChanged);
}
void SelectionProxyModel::OnProxyModelRowsInserted([[maybe_unused]] const QModelIndex& parent, [[maybe_unused]] int first, [[maybe_unused]] int last)
{
QModelIndex sourceIndex = m_sourceSelectionModel->currentIndex();
QModelIndex targetIndex = mapFromSource(sourceIndex);
if (targetIndex != currentIndex())
{
QItemSelectionModel::setCurrentIndex(targetIndex, QItemSelectionModel::SelectCurrent | QItemSelectionModel::Rows);
}
QItemSelection sourceSelection = m_sourceSelectionModel->selection();
QItemSelection targetSelection = mapFromSource(sourceSelection);
if (targetSelection != selection())
{
QItemSelectionModel::select(targetSelection, QItemSelectionModel::ClearAndSelect | QItemSelectionModel::Rows);
}
}
QModelIndex SelectionProxyModel::mapFromSource(const QModelIndex& sourceIndex)
{
QModelIndex mappedIndex = sourceIndex;
for (QVector<QAbstractProxyModel*>::const_reverse_iterator itProxy = m_proxyModels.rbegin(); itProxy != m_proxyModels.rend(); ++itProxy)
{
mappedIndex = (*itProxy)->mapFromSource(mappedIndex);
}
return mappedIndex;
}
QItemSelection SelectionProxyModel::mapFromSource(const QItemSelection& sourceSelection)
{
QItemSelection mappedSelection = sourceSelection;
for (QVector<QAbstractProxyModel*>::const_reverse_iterator itProxy = m_proxyModels.rbegin(); itProxy != m_proxyModels.rend(); ++itProxy)
{
mappedSelection = (*itProxy)->mapSelectionFromSource(mappedSelection);
}
return mappedSelection;
}
QModelIndex SelectionProxyModel::mapToSource(const QModelIndex& targetIndex)
{
QModelIndex mappedIndex = targetIndex;
for (QVector<QAbstractProxyModel*>::const_iterator itProxy = m_proxyModels.begin(); itProxy != m_proxyModels.end(); ++itProxy)
{
mappedIndex = (*itProxy)->mapToSource(mappedIndex);
}
return mappedIndex;
}
QItemSelection SelectionProxyModel::mapToSource(const QItemSelection& targetSelection)
{
QItemSelection mappedSelection = targetSelection;
for (QVector<QAbstractProxyModel*>::const_iterator itProxy = m_proxyModels.begin(); itProxy != m_proxyModels.end(); ++itProxy)
{
mappedSelection = (*itProxy)->mapSelectionToSource(mappedSelection);
}
return mappedSelection;
}
} // namespace AzQtComponents
Code/Framework/AzQtComponents/AzQtComponents/Utilities/SelectionProxyModel.h
+66
View File
@@ -0,0 +1,66 @@
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#pragma once
#if !defined(Q_MOC_RUN)
#include <AzQtComponents/AzQtComponentsAPI.h>
#include <QtCore/QItemSelectionModel>
#include <QVector>
#endif
QT_FORWARD_DECLARE_CLASS(QAbstractProxyModel)
namespace AzQtComponents
{
//! This class is a QItemSelectionModel that syncs through proxy models and maintains
//! selection. In Qt we can have a model being filtered/sorted by proxy models. If the
//! selection model is connected to the original model, the view needs a new selection
//! model that understands the filtering. This class does that conversion.
//! @Note: this class does not support changing proxy models (anywhere in the chain).
//! The class will have to be recreated with the new proxy model.
class AZ_QT_COMPONENTS_API SelectionProxyModel
: public QItemSelectionModel
{
Q_OBJECT // AUTOMOC
public:
SelectionProxyModel(QItemSelectionModel* sourceSelectionModel, QAbstractProxyModel* proxyModel, QObject* parent = nullptr);
void setCurrentIndex(const QModelIndex &index, QItemSelectionModel::SelectionFlags command) override;
void select(const QModelIndex &index, QItemSelectionModel::SelectionFlags command) override;
void select(const QItemSelection &selection, QItemSelectionModel::SelectionFlags command) override;
void clear() override;
void reset() override;
void clearCurrentIndex() override;
private slots:
void OnSourceSelectionChanged(const QItemSelection& selected, const QItemSelection& deselected);
void OnSourceSelectionCurrentChanged(const QModelIndex& current, const QModelIndex& previous);
void OnProxySelectionChanged(const QItemSelection& selected, const QItemSelection& deselected);
void OnProxyModelRowsInserted(const QModelIndex& parent, int first, int last);
private:
QModelIndex mapFromSource(const QModelIndex& sourceIndex);
QItemSelection mapFromSource(const QItemSelection& sourceSelection);
QModelIndex mapToSource(const QModelIndex& targetIndex);
QItemSelection mapToSource(const QItemSelection& targetSelection);
// Contains the chain of proxy models that leads us to the real model. The outer-most proxy model
// comes first and is followed by inner proxy models.
AZ_PUSH_DISABLE_DLL_EXPORT_MEMBER_WARNING
QVector<QAbstractProxyModel*> m_proxyModels;
AZ_POP_DISABLE_DLL_EXPORT_MEMBER_WARNING
QItemSelectionModel* m_sourceSelectionModel;
};
} // namespace AzQtComponents

Some files were not shown because too many files have changed in this diff Show More