From 7e136297bc7f297969c5abc2660970757f8af9ca Mon Sep 17 00:00:00 2001 From: Volkan Date: Mon, 10 Aug 2020 13:53:45 -0700 Subject: [PATCH 01/67] Restructure the file/folder hierarchy for packaging and developing: no longer duplicate Data/ and Shaders/ directory --- Build/PackageEngine.bat | 38 ++++++++++------ CMakeLists.txt | 45 +++++++++---------- Scripts/TestVQE.bat | 10 ++--- .../FullscreenTriangle.hlsl | 0 {Source/Shaders => Shaders}/Skydome.hlsl | 0 {Source/Shaders => Shaders}/Tonemapper.hlsl | 0 {Source/Shaders => Shaders}/hello-cube.hlsl | 0 .../Shaders => Shaders}/hello-triangle.hlsl | 0 8 files changed, 52 insertions(+), 41 deletions(-) rename {Source/Shaders => Shaders}/FullscreenTriangle.hlsl (100%) rename {Source/Shaders => Shaders}/Skydome.hlsl (100%) rename {Source/Shaders => Shaders}/Tonemapper.hlsl (100%) rename {Source/Shaders => Shaders}/hello-cube.hlsl (100%) rename {Source/Shaders => Shaders}/hello-triangle.hlsl (100%) diff --git a/Build/PackageEngine.bat b/Build/PackageEngine.bat index a6b1a7b5..3178f1c8 100644 --- a/Build/PackageEngine.bat +++ b/Build/PackageEngine.bat @@ -27,9 +27,17 @@ set SKIP_DOWNLOADS=0 set DBG_BUILD_DIRECTORY=../Bin/DEBUG set RLS_BUILD_DIRECTORY=../Bin/RELEASE set RWD_BUILD_DIRECTORY=../Bin/RELWITHDEBINFO -set SHADER_DIRECTORY=../Source/Shaders +set SHADER_DIRECTORY=../Shaders set DATA_DIRECTORY=../Data +::prepare ignore directory list +pushd %cd% +cd ../Data/Icons +set IGNORE_DIRS=%cd% +cd ../Resources +set IGNORE_DIRS=%IGNORE_DIRS% %cd% +popd + :: Keep track of # build tasks. build, clean, copy/move, etc. :: assume 2 for build+copy, add more depending on prebuild+clean tasks set BUILD_NUM_TASKS=2 @@ -280,16 +288,17 @@ exit /b 0 :PackageBuild set SRC=%~1 set DST=%~2 -::prepare ignore directory list -pushd %cd% -cd !SRC!/Data/Icons -set IGNORE_DIRS=%cd% -cd ../Resources -set IGNORE_DIRS=%IGNORE_DIRS% %cd% -popd :: move files to final destination robocopy !SRC! !DST! /xf *.lib *.ilk /E /xd !IGNORE_DIRS! +exit /b 0 + +:: +:: PackageBuild(source, dest) +:: +:PackageResources +set DST=%~1 robocopy !SHADER_DIRECTORY! !DST!/Shaders /E +robocopy !DATA_DIRECTORY! !DST!/Data /E /xd !IGNORE_DIRS! exit /b 0 :: @@ -307,14 +316,17 @@ if exist !ENGINE_PACKAGE_OUTPUT_DIRECTORY! ( rmdir /S /Q !ENGINE_PACKAGE_OUTPUT_DIRECTORY! ) -:: make artifacts directory +:: create artifacts directory mkdir !ENGINE_PACKAGE_OUTPUT_DIRECTORY! -:: move builds +:: move data +call :PackageResources !ENGINE_PACKAGE_OUTPUT_DIRECTORY! + +:: move built binaries echo [VQPackage] Moving build artifacts to package output directory... -call :PackageBuild !RLS_BUILD_DIRECTORY!, !ENGINE_PACKAGE_OUTPUT_DIRECTORY!/Win64 -if !BUILD_CONFIG_DEBUG! NEQ 0 call :PackageBuild !DBG_BUILD_DIRECTORY!, !ENGINE_PACKAGE_OUTPUT_DIRECTORY!/Win64-Debug -if !BUILD_CONFIG_REL_WITH_DBG! NEQ 0 call :PackageBuild !RWD_BUILD_DIRECTORY!, !ENGINE_PACKAGE_OUTPUT_DIRECTORY!/Win64-PDB +call :PackageBuild !RLS_BUILD_DIRECTORY!, !ENGINE_PACKAGE_OUTPUT_DIRECTORY! +if !BUILD_CONFIG_DEBUG! NEQ 0 call :PackageBuild !DBG_BUILD_DIRECTORY!, !ENGINE_PACKAGE_OUTPUT_DIRECTORY! +if !BUILD_CONFIG_REL_WITH_DBG! NEQ 0 call :PackageBuild !RWD_BUILD_DIRECTORY!, !ENGINE_PACKAGE_OUTPUT_DIRECTORY! exit /b 0 :: -------------------------------------------------------------------------- diff --git a/CMakeLists.txt b/CMakeLists.txt index 8f3c26a2..cb3da083 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -11,13 +11,6 @@ add_compile_options(/MP) set_property(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT ${PROJECT_NAME}) -# ouput exe to bin directory -SET(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_HOME_DIRECTORY}/Bin) -foreach( OUTPUTCONFIG ${CMAKE_CONFIGURATION_TYPES} ) - string( TOUPPER ${OUTPUTCONFIG} OUTPUTCONFIG ) - set( CMAKE_RUNTIME_OUTPUT_DIRECTORY_${OUTPUTCONFIG} ${CMAKE_HOME_DIRECTORY}/Bin/${OUTPUTCONFIG} ) -endforeach( OUTPUTCONFIG CMAKE_CONFIGURATION_TYPES ) - set (Resource "Data/Resources/VQE.rc" "Data/Resources/resource.h" @@ -32,11 +25,11 @@ set (Config ) set (Shaders - "Source/Shaders/hello-triangle.hlsl" - "Source/Shaders/hello-cube.hlsl" - "Source/Shaders/FullscreenTriangle.hlsl" - "Source/Shaders/Tonemapper.hlsl" - "Source/Shaders/Skydome.hlsl" + "Shaders/hello-triangle.hlsl" + "Shaders/hello-cube.hlsl" + "Shaders/FullscreenTriangle.hlsl" + "Shaders/Tonemapper.hlsl" + "Shaders/Skydome.hlsl" ) set (HeaderVQE @@ -74,8 +67,13 @@ set (SourceVQE "Source/Application/Input.cpp" ) -add_link_options(/SUBSYSTEM:WINDOWS) +# ouput exe to bin directory +foreach( OUTPUTCONFIG ${CMAKE_CONFIGURATION_TYPES} ) + string( TOUPPER ${OUTPUTCONFIG} OUTPUTCONFIG ) + set( CMAKE_RUNTIME_OUTPUT_DIRECTORY_${OUTPUTCONFIG} ${CMAKE_HOME_DIRECTORY}/Bin/${OUTPUTCONFIG} ) +endforeach( OUTPUTCONFIG CMAKE_CONFIGURATION_TYPES ) +add_link_options(/SUBSYSTEM:WINDOWS) add_subdirectory(Libs/VQUtils) add_subdirectory(Libs/D3D12MA) @@ -96,18 +94,19 @@ link_directories(${CMAKE_CURRENT_SOURCE_DIR}/Libs/VQUtils/Bin/) # Create a library with the project name that is build with the Headers and Source files add_executable( ${PROJECT_NAME} ${HeaderVQE} ${SourceVQE} ${Config} ${Resource} ${Shaders} ) -set_target_properties(${PROJECT_NAME} PROPERTIES VS_DEBUGGER_WORKING_DIRECTORY ${CMAKE_HOME_DIRECTORY}/Bin/ ) - -set_property(TARGET ${PROJECT_NAME} PROPERTY CXX_STANDARD 17) +set_target_properties(${PROJECT_NAME} PROPERTIES VS_DEBUGGER_WORKING_DIRECTORY ${CMAKE_HOME_DIRECTORY} ) -add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_SOURCE_DIR}/Data ${CMAKE_SOURCE_DIR}/Bin/Data) -add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_SOURCE_DIR}/Source/Shaders ${CMAKE_SOURCE_DIR}/Bin/Shaders) -add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_SOURCE_DIR}/Data $/Data) -add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_directory ${CMAKE_SOURCE_DIR}/Source/Shaders $/Shaders) +# set target executable name for debug/releasewithdebug builds, release is VQE.exe +foreach( OUTPUTCONFIG ${CMAKE_CONFIGURATION_TYPES} ) + string( TOUPPER ${OUTPUTCONFIG} OUTPUTCONFIG ) + if (${OUTPUTCONFIG} MATCHES "DEBUG") + set_target_properties(${PROJECT_NAME} PROPERTIES ${OUTPUTCONFIG}_OUTPUT_NAME "VQE-d") + elseif (${OUTPUTCONFIG} MATCHES "RELWITHDEBINFO") + set_target_properties(${PROJECT_NAME} PROPERTIES ${OUTPUTCONFIG}_OUTPUT_NAME "VQE-rwd") + endif() +endforeach( OUTPUTCONFIG CMAKE_CONFIGURATION_TYPES ) -# TODO: the above commands must run even if the project is up to date which is not the case now. -# if Data/EngineSettings.ini is updated, the copy in the target destination of the commands above -# is not updated. +set_property(TARGET ${PROJECT_NAME} PROPERTY CXX_STANDARD 17) # Make sure the compiler can find include files for the libraries target_include_directories(${PROJECT_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR} ${Includes}) diff --git a/Scripts/TestVQE.bat b/Scripts/TestVQE.bat index c5eeeaca..9090cc33 100644 --- a/Scripts/TestVQE.bat +++ b/Scripts/TestVQE.bat @@ -6,9 +6,9 @@ setlocal enabledelayedexpansion cd ../Build/_artifacts set DIR_BUILD=!CD! -set VQE_REL_DIR=!DIR_BUILD!/Win64 -set VQE_DBG_DIR=!DIR_BUILD!/Win64-Debug -set VQE_RWD_DIR=!DIR_BUILD!/Win64-PDB +set VQE_REL_DIR=!DIR_BUILD! +set VQE_DBG_DIR=!DIR_BUILD! +set VQE_RWD_DIR=!DIR_BUILD! set RUN_TEST_REL=1 set RUN_TEST_DBG=0 @@ -40,9 +40,9 @@ if !errorlevel! NEQ 0 ( exit /b -1 ) -if !RUN_TEST_DBG! NEQ 0 call :RunTest !VQE_DBG_DIR!, VQE.exe +if !RUN_TEST_DBG! NEQ 0 call :RunTest !VQE_DBG_DIR!, VQE-d.exe if !RUN_TEST_REL! NEQ 0 call :RunTest !VQE_REL_DIR!, VQE.exe -if !RUN_TEST_RWD! NEQ 0 call :RunTest !VQE_RWD_DIR!, VQE.exe +if !RUN_TEST_RWD! NEQ 0 call :RunTest !VQE_RWD_DIR!, VQE-rwd.exe exit /b 0 diff --git a/Source/Shaders/FullscreenTriangle.hlsl b/Shaders/FullscreenTriangle.hlsl similarity index 100% rename from Source/Shaders/FullscreenTriangle.hlsl rename to Shaders/FullscreenTriangle.hlsl diff --git a/Source/Shaders/Skydome.hlsl b/Shaders/Skydome.hlsl similarity index 100% rename from Source/Shaders/Skydome.hlsl rename to Shaders/Skydome.hlsl diff --git a/Source/Shaders/Tonemapper.hlsl b/Shaders/Tonemapper.hlsl similarity index 100% rename from Source/Shaders/Tonemapper.hlsl rename to Shaders/Tonemapper.hlsl diff --git a/Source/Shaders/hello-cube.hlsl b/Shaders/hello-cube.hlsl similarity index 100% rename from Source/Shaders/hello-cube.hlsl rename to Shaders/hello-cube.hlsl diff --git a/Source/Shaders/hello-triangle.hlsl b/Shaders/hello-triangle.hlsl similarity index 100% rename from Source/Shaders/hello-triangle.hlsl rename to Shaders/hello-triangle.hlsl From 753726de2ec19b02e8527e645673f43c6b6de7ed Mon Sep 17 00:00:00 2001 From: Volkan Date: Wed, 12 Aug 2020 23:24:00 -0700 Subject: [PATCH 02/67] Hello Scenes: Scene initialization from xml files, scene-specific update logic, WIP object rendering, WIP Material/Light/Model loading code --- CMakeLists.txt | 23 +- Data/EngineSettings.ini | 3 +- Data/Levels/Default.xml | 79 + Data/Levels/DefaultScene.xml | 17 - Data/Levels/Sponza.xml | 80 + Data/Scenes.ini | 5 + Source/Application/AssetLoader.cpp | 28 + Source/Application/AssetLoader.h | 29 + Source/Application/Camera.cpp | 20 +- Source/Application/Camera.h | 34 +- Source/Application/GameObject.cpp | 143 ++ Source/Application/GameObject.h | 119 ++ Source/Application/Light.cpp | 227 +++ Source/Application/Light.h | 250 +++ Source/Application/Main.cpp | 6 + Source/Application/Mesh.cpp | 4 +- Source/Application/Mesh.h | 4 +- Source/Application/Model.cpp | 449 ++++ Source/Application/Model.h | 134 ++ Source/Application/Platform.h | 3 +- Source/Application/Quaternion.h | 2 +- Source/Application/Scene.cpp | 1806 +++++++++++++++++ Source/Application/Scene.h | 536 +++++ Source/Application/Settings.h | 4 + Source/Application/Types.h | 6 +- Source/Application/VQEngine.h | 91 +- Source/Application/VQEngine_EventHandlers.cpp | 27 +- Source/Application/VQEngine_Main.cpp | 368 +++- Source/Application/VQEngine_Render.cpp | 51 +- Source/Application/VQEngine_Update.cpp | 221 +- Source/Scenes/DefaultScene.cpp | 79 + Source/Scenes/Scenes.h | 39 + Source/Scenes/Sponza.cpp | 18 + 33 files changed, 4535 insertions(+), 370 deletions(-) create mode 100644 Data/Levels/Default.xml delete mode 100644 Data/Levels/DefaultScene.xml create mode 100644 Data/Levels/Sponza.xml create mode 100644 Data/Scenes.ini create mode 100644 Source/Application/AssetLoader.cpp create mode 100644 Source/Application/AssetLoader.h create mode 100644 Source/Application/GameObject.cpp create mode 100644 Source/Application/GameObject.h create mode 100644 Source/Application/Light.cpp create mode 100644 Source/Application/Light.h create mode 100644 Source/Application/Model.cpp create mode 100644 Source/Application/Model.h create mode 100644 Source/Application/Scene.cpp create mode 100644 Source/Application/Scene.h create mode 100644 Source/Scenes/DefaultScene.cpp create mode 100644 Source/Scenes/Scenes.h create mode 100644 Source/Scenes/Sponza.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index cb3da083..71c4f9ed 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -17,11 +17,20 @@ set (Resource "Data/Icons/VQE32.ico" ) +set (Scenes + "Data/Levels/Default.xml" + "Data/Levels/Sponza.xml" + "Source/Scenes/Scenes.h" + "Source/Scenes/DefaultScene.cpp" + "Source/Scenes/Sponza.cpp" +) + set (Config "Data/EngineSettings.ini" "Data/RendererSettings.ini" "Data/HDRDisplayProfiles.ini" "Data/EnvironmentMaps.ini" + "Data/Scenes.ini" ) set (Shaders @@ -41,11 +50,16 @@ set (HeaderVQE "Source/Application/VQEngine.h" "Source/Application/Events.h" "Source/Application/Mesh.h" + "Source/Application/Model.h" "Source/Application/Geometry.h" "Source/Application/Transform.h" "Source/Application/Quaternion.h" "Source/Application/Camera.h" "Source/Application/Input.h" + "Source/Application/AssetLoader.h" + "Source/Application/Scene.h" + "Source/Application/Light.h" + "Source/Application/GameObject.h" ) set (SourceVQE @@ -59,12 +73,17 @@ set (SourceVQE "Source/Application/VQEngine_EventHandlers.cpp" "Source/Application/Events.cpp" "Source/Application/Mesh.cpp" + "Source/Application/Model.cpp" "Source/Application/Geometry.cpp" "Source/Application/Transform.cpp" "Source/Application/Math.cpp" "Source/Application/Quaternion.cpp" "Source/Application/Camera.cpp" "Source/Application/Input.cpp" + "Source/Application/AssetLoader.cpp" + "Source/Application/Scene.cpp" + "Source/Application/Light.cpp" + "Source/Application/GameObject.cpp" ) # ouput exe to bin directory @@ -83,8 +102,10 @@ source_group("Config" FILES ${Config}) source_group("Resource" FILES ${Resource}) source_group("Icons" FILES ${Icons}) source_group("Shaders" FILES ${Shaders}) +source_group("Scenes" FILES ${Scenes}) set_source_files_properties(${Config} PROPERTIES VS_TOOL_OVERRIDE "Text") +set_source_files_properties(${Scenes} PROPERTIES VS_TOOL_OVERRIDE "Text") set_source_files_properties(${Shaders} PROPERTIES VS_TOOL_OVERRIDE "Text") set_source_files_properties(Data/Resources/VQE.rc PROPERTIES VS_TOOL_OVERRIDE "Resource compiler") set_source_files_properties(Data/Icons/VQE32.ico PROPERTIES VS_TOOL_OVERRIDE "Image") @@ -92,7 +113,7 @@ set_source_files_properties(Data/Icons/VQE32.ico PROPERTIES VS_TOOL_OVERRIDE "I link_directories(${CMAKE_CURRENT_SOURCE_DIR}/Libs/VQUtils/Bin/) # Create a library with the project name that is build with the Headers and Source files -add_executable( ${PROJECT_NAME} ${HeaderVQE} ${SourceVQE} ${Config} ${Resource} ${Shaders} ) +add_executable( ${PROJECT_NAME} ${HeaderVQE} ${SourceVQE} ${Config} ${Scenes} ${Resource} ${Shaders} ) set_target_properties(${PROJECT_NAME} PROPERTIES VS_DEBUGGER_WORKING_DIRECTORY ${CMAKE_HOME_DIRECTORY} ) diff --git a/Data/EngineSettings.ini b/Data/EngineSettings.ini index 5211887e..050f09b5 100644 --- a/Data/EngineSettings.ini +++ b/Data/EngineSettings.ini @@ -6,13 +6,14 @@ RenderScale=1.0 TripleBuffer=true AntiAliasing=true MaxFrameRate=Auto -HDR=true +HDR=false [Engine] Width=768 Height=432 DisplayMode=Windowed PreferredDisplay=0 +Scene=Default DebugWindow=false DebugWindowWidth=450 diff --git a/Data/Levels/Default.xml b/Data/Levels/Default.xml new file mode 100644 index 00000000..624d33b1 --- /dev/null +++ b/Data/Levels/Default.xml @@ -0,0 +1,79 @@ + + + + + + Stadium01 + + + + 0.0 3.0 -5 + 15 + 0 + + Perspective + 60.0 + 0.01 + 1000 + + + 1000 + 0.05 + 9.5 + + + + + + 0 0 4 + 0 0 0 1 + 3 3 3 + + + Cube + + + + + + + + + 6.0 3.0 -5 + 65 + 6 + + Orthographic + 90.0 + 0.01 + 1000 + + + 1000 + 0.05 + 9.5 + + + + + -1.0 5 2 + 0 3.14 0 1 + 3 4 5 + + + Cube + + + + + + + + \ No newline at end of file diff --git a/Data/Levels/DefaultScene.xml b/Data/Levels/DefaultScene.xml deleted file mode 100644 index e75c1a0d..00000000 --- a/Data/Levels/DefaultScene.xml +++ /dev/null @@ -1,17 +0,0 @@ - - - - - - Stadium01 - - - - \ No newline at end of file diff --git a/Data/Levels/Sponza.xml b/Data/Levels/Sponza.xml new file mode 100644 index 00000000..6b577621 --- /dev/null +++ b/Data/Levels/Sponza.xml @@ -0,0 +1,80 @@ + + + + + + + + + + + + 0.0 3.0 -5 + 15 + 0 + Perspective + 60.0 + 0.01 + 1000 + + + 1000 + 0.05 + 9.5 + + + + + + + 0 0 0 + 0 0 0 1 + 1 1 1 + + + Data/Models/sponza/sponza.obj + Sponza + + + + + + 0 0 0 + 0 0 0 1 + 1 1 1 + + + Cube + + + + + + + + + + + diff --git a/Data/Scenes.ini b/Data/Scenes.ini new file mode 100644 index 00000000..f824eb96 --- /dev/null +++ b/Data/Scenes.ini @@ -0,0 +1,5 @@ +[SceneMapping] +Default=0 +Sponza=1 +HelloGeometry=2 +HelloLights=3 \ No newline at end of file diff --git a/Source/Application/AssetLoader.cpp b/Source/Application/AssetLoader.cpp new file mode 100644 index 00000000..372a1c8a --- /dev/null +++ b/Source/Application/AssetLoader.cpp @@ -0,0 +1,28 @@ +// VQE +// Copyright(C) 2020 - Volkan Ilbeyli +// +// This program is free software : you can redistribute it and / or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program.If not, see . +// +// Contact: volkanilbeyli@gmail.com + +#include "AssetLoader.h" + +Model AssetLoader::ImportModel_obj(const std::string& objFilePath, std::string ModelName) +{ + Model::Data modelData; + + // TODO: assimp model import + + return Model(objFilePath, ModelName, std::move(modelData)); +} \ No newline at end of file diff --git a/Source/Application/AssetLoader.h b/Source/Application/AssetLoader.h new file mode 100644 index 00000000..4bcd09b6 --- /dev/null +++ b/Source/Application/AssetLoader.h @@ -0,0 +1,29 @@ +// VQE +// Copyright(C) 2020 - Volkan Ilbeyli +// +// This program is free software : you can redistribute it and / or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program.If not, see . +// +// Contact: volkanilbeyli@gmail.com +#pragma once + +#include "Model.h" + +class AssetLoader +{ + + +public: + static Model ImportModel_obj(const std::string& objFilePath, std::string ModelName = "NONE"); // TODO: rename to LoadModel_obj() ? + +}; \ No newline at end of file diff --git a/Source/Application/Camera.cpp b/Source/Application/Camera.cpp index fd966eaf..9faff36a 100644 --- a/Source/Application/Camera.cpp +++ b/Source/Application/Camera.cpp @@ -39,31 +39,31 @@ Camera::Camera() Camera::~Camera(void) {} -void Camera::InitializeCamera(const FCameraData& data) +void Camera::InitializeCamera(const FCameraParameters& data) { - const auto& NEAR_PLANE = data.nearPlane; - const auto& FAR_PLANE = data.farPlane; - const float AspectRatio = data.width / data.height; - const float VerticalFoV = data.fovV_Degrees * DEG2RAD; - const float& ViewportX = data.width; - const float& ViewportY = data.height; + const auto& NEAR_PLANE = data.NearPlane; + const auto& FAR_PLANE = data.FarPlane; + const float AspectRatio = data.Width / data.Height; + const float VerticalFoV = data.FovV_Degrees * DEG2RAD; + const float& ViewportX = data.Width; + const float& ViewportY = data.Height; this->mProjParams.NearZ = NEAR_PLANE; this->mProjParams.FarZ = FAR_PLANE; this->mProjParams.ViewporHeight = ViewportY; this->mProjParams.ViewporWidth = ViewportX; - this->mProjParams.FieldOfView = data.fovV_Degrees * DEG2RAD; + this->mProjParams.FieldOfView = data.FovV_Degrees * DEG2RAD; this->mProjParams.bPerspectiveProjection = data.bPerspectiveProjection; mYaw = mPitch = 0; SetProjectionMatrix(this->mProjParams); SetPosition(data.x, data.y, data.z); - Rotate(data.yaw * DEG2RAD, data.pitch * DEG2RAD, 1.0f); + Rotate(data.Yaw * DEG2RAD, data.Pitch * DEG2RAD, 1.0f); UpdateViewMatrix(); } -void Camera::SetProjectionMatrix(const ProjectionMatrixParameters& params) +void Camera::SetProjectionMatrix(const FProjectionMatrixParameters& params) { assert(params.ViewporHeight > 0.0f); const float AspectRatio = params.ViewporWidth / params.ViewporHeight; diff --git a/Source/Application/Camera.h b/Source/Application/Camera.h index f58d19b7..d25b35e4 100644 --- a/Source/Application/Camera.h +++ b/Source/Application/Camera.h @@ -90,21 +90,27 @@ struct FFrustumPlaneset } }; -struct FCameraData +struct FCameraParameters { float x, y, z; // position - float width; - float height; - float nearPlane; - float farPlane; - float fovV_Degrees; - float yaw, pitch; // in degrees - bool bPerspectiveProjection; + float Yaw, Pitch; // in degrees + + bool bPerspectiveProjection; // perspective / orthographic + float Width; + float Height; + float NearPlane; + float FarPlane; + float FovV_Degrees; + + bool FirstPerson; // First Person / orbit + float TranslationSpeed; + float AngularSpeed; + float Drag; }; -struct ProjectionMatrixParameters +struct FProjectionMatrixParameters { - float ViewporWidth; - float ViewporHeight; + float ViewporWidth; // needed for orthographic projection + float ViewporHeight; // needed for orthographic projection float NearZ; float FarZ; float FieldOfView; @@ -126,9 +132,9 @@ class Camera Camera(); ~Camera(void); - void InitializeCamera(const FCameraData& data); + void InitializeCamera(const FCameraParameters& data); - void SetProjectionMatrix(const ProjectionMatrixParameters& params); + void SetProjectionMatrix(const FProjectionMatrixParameters& params); void UpdateViewMatrix(); // updates View Matrix @mMatView @@ -156,7 +162,7 @@ class Camera DirectX::XMFLOAT3 mVelocity; float mPitch = 0.0f; // ------------------------- - ProjectionMatrixParameters mProjParams; + FProjectionMatrixParameters mProjParams; // ------------------------- float Drag; float AngularSpeedDeg; diff --git a/Source/Application/GameObject.cpp b/Source/Application/GameObject.cpp new file mode 100644 index 00000000..2d25a6f4 --- /dev/null +++ b/Source/Application/GameObject.cpp @@ -0,0 +1,143 @@ +// VQEngine | DirectX11 Renderer +// Copyright(C) 2018 - Volkan Ilbeyli +// +// This program is free software : you can redistribute it and / or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program.If not, see . +// +// Contact: volkanilbeyli@gmail.com + +#include "GameObject.h" +#if 0 +#include "Renderer/Renderer.h" +#include "RenderPasses/RenderPasses.h" +#include "SceneResourceView.h" +#include "SceneView.h" + +#include "Engine.h" + +GameObject::GameObject(Scene* pScene) : mpScene(pScene) {}; + +void GameObject::AddMesh(MeshID meshID) +{ + //if (meshID >= 0 && meshID < EGeometry::MESH_TYPE_COUNT) + mModel.mbLoaded = true; + + mModel.mData.mMeshIDs.push_back(meshID); +} + + +void GameObject::AddMesh(MeshID meshID, const MeshRenderSettings& renderSettings) +{ + mModel.mbLoaded = true; + mModel.mData.mMeshRenderSettingsLookup[meshID] = renderSettings; + mModel.mData.mMeshIDs.push_back(meshID); +} + +void GameObject::AddMaterial(Material * pMat) +{ + if (mModel.mbLoaded) + mModel.AddMaterialToMesh(mModel.mData.mMeshIDs.back(), pMat->ID, pMat->IsTransparent()); + else + mModel.mMaterialAssignmentQueue.push(pMat->ID); +} + + +void GameObject::SetMeshMaterials(const Material* pMat) +{ + if (mModel.mbLoaded) + mModel.OverrideMaterials(pMat->ID); + else + assert(false); // TODO: impl mesh override queue or resolve the ambiguity between material assignment queue and this case +} + +void GameObject::RenderTransparent( + Renderer * pRenderer + , const FSceneView& sceneView + , bool UploadMaterialDataToGPU + , const MaterialPool& materialBuffer) const +{ + const EShaders shader = static_cast(pRenderer->GetActiveShader()); + const XMMATRIX world = mTransform.WorldTransformationMatrix(); + const XMMATRIX wvp = world * sceneView.viewProj; + + // SET MATRICES + switch (shader) + { + case EShaders::TBN: + pRenderer->SetConstant4x4f("world", world); + pRenderer->SetConstant4x4f("viewProj", sceneView.viewProj); + pRenderer->SetConstant4x4f("normalMatrix", mTransform.NormalMatrix(world)); + break; + case EShaders::NORMAL: + pRenderer->SetConstant4x4f("normalMatrix", mTransform.NormalMatrix(world)); + case EShaders::UNLIT: + case EShaders::TEXTURE_COORDINATES: + pRenderer->SetConstant4x4f("worldViewProj", wvp); + break; + default: // lighting shaders + pRenderer->SetConstant4x4f("world", world); + pRenderer->SetConstant4x4f("normalMatrix", mTransform.NormalMatrix(world)); + pRenderer->SetConstant4x4f("worldViewProj", wvp); + break; + } + + // SET GEOMETRY & MATERIAL, THEN DRAW + for(MeshID id : mModel.mData.mTransparentMeshIDs) + { + const auto IABuffer = SceneResourceView::GetVertexAndIndexBufferIDsOfMesh(mpScene, id, this); + + // SET MATERIAL CONSTANTS + if (UploadMaterialDataToGPU) + { + const bool bMeshHasMaterial = mModel.mData.mMaterialLookupPerMesh.find(id) != mModel.mData.mMaterialLookupPerMesh.end(); + + if (bMeshHasMaterial) + { + const MaterialID materialID = mModel.mData.mMaterialLookupPerMesh.at(id); + const Material* pMat = materialBuffer.GetMaterial_const(materialID); + pMat->SetMaterialConstants(pRenderer, shader, sceneView.bIsDeferredRendering && shader != FORWARD_BRDF); + } + else + { + materialBuffer.GetDefaultMaterial(GGX_BRDF)->SetMaterialConstants(pRenderer, shader, sceneView.bIsDeferredRendering); + } + } + + pRenderer->SetVertexBuffer(IABuffer.first); + pRenderer->SetIndexBuffer(IABuffer.second); + pRenderer->Apply(); + pRenderer->DrawIndexed(); + }; +} + +void GameObject::Clear() +{ + mTransform = Transform(); + mModel = Model(); + mBoundingBox = BoundingBox(); + mRenderSettings = GameObjectRenderSettings(); +} + + + + +DirectX::XMMATRIX BoundingBox::GetWorldTransformationMatrix() const +{ + Transform tf; + const vec3 diag = this->hi - this->low; + const vec3 pos = (this->hi + this->low) * 0.5f; + tf.SetScale(diag * 0.5f); + tf.SetPosition(pos); + return tf.WorldTransformationMatrix(); +} +#endif \ No newline at end of file diff --git a/Source/Application/GameObject.h b/Source/Application/GameObject.h new file mode 100644 index 00000000..99328d05 --- /dev/null +++ b/Source/Application/GameObject.h @@ -0,0 +1,119 @@ +// VQEngine | DirectX11 Renderer +// Copyright(C) 2018 - Volkan Ilbeyli +// +// This program is free software : you can redistribute it and / or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program.If not, see . +// +// Contact: volkanilbeyli@gmail.com + +#pragma once + +#include "Types.h" + +#include + +struct BoundingBox {}; +class GameObject +{ + TransformID mTransformID; + ModelID mModelID; + + // Todo: move to scene and rename to @BoundingBoxes_GameObjects; + BoundingBox mBoundingBox; + std::vector mMeshBoundingBoxes; +}; + +#if 0 +#include "Engine/ObjectCullingSystem.h" + +#include + +struct FSceneView; +class Renderer; +class Scene; +class Parser; + +struct GameObjectRenderSettings +{ + bool bRender = true; + bool bRenderTBN = false; + bool bCastShadow = true; +}; + +class GameObject +{ +// GameObjects only contain Transform data, and the rest of +// the members are references to data either in Scene or Renderer. +// +public: + ~GameObject() { mpScene = nullptr; } + void RenderTransparent(Renderer* pRenderer, const FSceneView& sceneView, bool UploadMaterialDataToGPU, const MaterialPool& materialBuffer) const; + void Clear(); + + inline void SetTransform(const Transform& transform) { mTransform = transform; } + + inline const Transform& GetTransform() const { return mTransform; } + inline const vec3& GetPosition() const { return mTransform._position; } + inline const ModelData& GetModelData() const { return mModel.mData; } + inline const std::string& GetModelName() const { return mModel.mModelName; } + + inline Transform& GetTransform() { return mTransform; } + + void AddMesh(MeshID meshID); + void AddMesh(MeshID meshID, const MeshRenderSettings& renderSettings); + + // Adds materialID to the newest meshID (meshes.back()) + // + void AddMaterial(Material* pMat); + void SetMeshMaterials(const Material* pMat); + + inline const Model& GetModel() const { return mModel; } + inline Model& GetModel() { return mModel; } + inline void SetModel(const Model& model) { mModel = model; } // i don't like this setter... + inline const BoundingBox& GetAABB() const { return mBoundingBox; } + inline const std::vector& GetMeshBBs() const { return mMeshBoundingBoxes; } + + +//--------------------------------------------------------------------------------------------------- + +public: + GameObjectRenderSettings mRenderSettings; + // After a game object is created, we use the pointer field + // as the Scene*. Otherwise, we keep a pointer for the object pool + // to the next available object - a free list of GameObject pointers + union + { + GameObject* pNextFreeObject; + Scene* mpScene; + }; + +private: + // friend std::shared_ptr Scene::CreateNewGameObject(); // #TODO: clean up: use either friend functions or ... + // friend std::shared_ptr FSceneRepresentation::CreateNewGameObject(); + // friend void Parser::ParseScene(Renderer*, const std::vector&, FSceneRepresentation&); + friend class Scene; + friend struct FSceneRepresentation; + friend class Parser; + friend class GameObjectPool; + GameObject(Scene* pScene); + + private: + Transform mTransform; + Model mModel; + BoundingBox mBoundingBox; + std::vector mMeshBoundingBoxes; + +}; + + +#endif \ No newline at end of file diff --git a/Source/Application/Light.cpp b/Source/Application/Light.cpp new file mode 100644 index 00000000..5c469c39 --- /dev/null +++ b/Source/Application/Light.cpp @@ -0,0 +1,227 @@ +// VQEngine | DirectX11 Renderer +// Copyright(C) 2018 - Volkan Ilbeyli +// +// This program is free software : you can redistribute it and / or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program.If not, see . +// +// Contact: volkanilbeyli@gmail.com + +#include "Light.h" + +#if 0 +#include "Engine/GameObject.h" + +#include "Utilities/Log.h" + +#include + +using std::string; + +// [OPTIMIZATION] +// +// caching light matrices will make the Scene calculate matrices once and +// store them in the mViewMatrix[6] and mProjectionMatrix. This way, we avoid +// matrix creation function calls during point light shadow view culling phase +// and just return the cached float16. Saves ~25% from point light culling CPU time. +// +#define CACHE_LIGHT_MATRICES 1 + + +// I want my parameter names, Windows... +#ifdef near +#undef near +#endif +#ifdef far +#undef far +#endif + + +DirectX::XMMATRIX Light::CalculateSpotLightViewMatrix(const Transform& mTransform) +{ + XMVECTOR up = vec3::Up; + XMVECTOR lookAt = vec3::Forward; // spot light default orientation looks up + lookAt = XMVector3TransformCoord(lookAt, mTransform.RotationMatrix()); + up = XMVector3TransformCoord(up, mTransform.RotationMatrix()); + XMVECTOR pos = mTransform._position; + XMVECTOR taraget = pos + lookAt; + return XMMatrixLookAtLH(pos, taraget, up); +} + +DirectX::XMMATRIX Light::CalculatePointLightViewMatrix(Texture::CubemapUtility::ECubeMapLookDirections lookDir, const vec3& position) +{ + return Texture::CubemapUtility::CalculateViewMatrix(lookDir, position); +} + +DirectX::XMMATRIX Light::CalculateDirectionalLightViewMatrix(const Light& mDirLight) +{ + if (mDirLight.mViewportX < 1.0f) + { + return XMMatrixIdentity(); + } + + const XMVECTOR up = vec3::Up; + const XMVECTOR lookAt = vec3::Zero; + const XMMATRIX mRot = mDirLight.mTransform.RotationMatrix(); + const vec3 direction = XMVector3Transform(vec3::Forward, mRot); + const XMVECTOR lightPos = direction * -mDirLight.mDistanceFromOrigin; // away from the origin along the direction vector + return XMMatrixLookAtLH(lightPos, lookAt, up); +} + +DirectX::XMMATRIX Light::CalculateProjectionMatrix(ELightType lightType, float near, float far, vec2 viewPortSize /*= vec2(0, 0)*/) +{ + switch (lightType) + { + case Light::POINT: + { + constexpr float ASPECT_RATIO = 1.0f; // cubemap aspect ratio + return XMMatrixPerspectiveFovLH(PI_DIV2, ASPECT_RATIO, near, far); + } + case Light::SPOT: + { + constexpr float ASPECT_RATIO = 1.0f; + //return XMMatrixPerspectiveFovLH(mSpotOuterConeAngleDegrees * DEG2RAD, ASPECT_RATIO, mNearPlaneDistance, mFarPlaneDistance); + return XMMatrixPerspectiveFovLH(PI_DIV2, ASPECT_RATIO, near, far); + } + case Light::DIRECTIONAL: + { + if (viewPortSize.x() < 1.0f) return XMMatrixIdentity(); + return XMMatrixOrthographicLH(viewPortSize.x(), viewPortSize.y(), near, far); + } + default: + Log::Warning("GetProjectionMatrix() called on invalid light type!"); + return XMMatrixIdentity(); + } +} + + + +DirectX::XMMATRIX Light::GetProjectionMatrix() const +{ +#if CACHE_LIGHT_MATRICES + return mProjectionMatrix; +#else + return CalculateProjectionMatrix(mType, mNearPlaneDistance, mFarPlaneDistance, vec2(mViewportX, mViewportY)); +#endif +} + +DirectX::XMMATRIX Light::GetViewMatrix(Texture::CubemapUtility::ECubeMapLookDirections lookDir /*= DEFAULT_POINT_LIGHT_LOOK_DIRECTION*/) const +{ +#if CACHE_LIGHT_MATRICES + switch (mType) + { + case Light::POINT: return mViewMatrix[lookDir]; + case Light::SPOT: return mViewMatrix[0]; + case Light::DIRECTIONAL: return mViewMatrix[0]; + default: + Log::Warning("GetViewMatrix() called on invalid light type!"); + return mViewMatrix[0]; + } +#else + switch (mType) + { + case Light::POINT: return CalculatePointLightViewMatrix(lookDir, mTransform._position); + case Light::SPOT: return CalculateSpotLightViewMatrix(mTransform); + case Light::DIRECTIONAL: return CalculateDirectionalLightViewMatrix(*this); + default: + Log::Warning("GetViewMatrix() called on invalid light type!"); + return XMMatrixIdentity(); + } +#endif +} + + + +void Light::GetGPUData(DirectionalLightGPU& l) const +{ + assert(mType == ELightType::DIRECTIONAL); + const XMMATRIX mRot = mTransform.RotationMatrix(); + const vec3 direction = XMVector3Transform(vec3::Forward, mRot); + + l.brightness = this->mBrightness; + l.color = this->mColor; + + l.lightDirection = direction; + l.depthBias = this->mDepthBias; + + l.shadowing = this->mbCastingShadows; + l.enabled = this->mbEnabled; +} +void Light::GetGPUData(SpotLightGPU& l) const +{ + assert(mType == ELightType::SPOT); + const vec3 spotDirection = XMVector3TransformCoord(vec3::Forward, mTransform.RotationMatrix()); + + l.position = mTransform._position; + l.halfAngle = mSpotOuterConeAngleDegrees * DEG2RAD; + + l.color = mColor.Value(); + l.brightness = mBrightness; + + l.spotDir = spotDirection; + l.depthBias = mDepthBias; + + l.innerConeAngle = mSpotInnerConeAngleDegrees * DEG2RAD; +} +void Light::GetGPUData(PointLightGPU& l) const +{ + assert(mType == ELightType::POINT); + + l.position = mTransform._position; + l.range = mRange; + + l.color = mColor.Value(); + l.brightness = mBrightness; + + l.attenuation = vec3(mAttenuationConstant, mAttenuationLinear, mAttenuationQuadratic); + l.depthBias = mDepthBias; +} + + + +Settings::ShadowMap Light::GetSettings() const +{ + Settings::ShadowMap settings; + settings.directionalShadowMapDimensions = static_cast(mViewportX); + return settings; +} + + + +void Light::SetMatrices() +{ +#if !CACHE_LIGHT_MATRICES + return; +#endif + + // VIEW + switch (mType) + { + case Light::POINT: + { + for(int i=0; i<6; ++i) + mViewMatrix[i] = CalculatePointLightViewMatrix(static_cast(i), mTransform._position); + break; + } + case Light::SPOT: mViewMatrix[0] = CalculateSpotLightViewMatrix(mTransform); break; + case Light::DIRECTIONAL: mViewMatrix[0] = CalculateDirectionalLightViewMatrix(*this); break; + default: + Log::Warning("SetViewMatrix() called on invalid light type!"); + mViewMatrix[0] = XMMatrixIdentity(); + break; + } + + // PROJ + mProjectionMatrix = CalculateProjectionMatrix(mType, mNearPlaneDistance, mFarPlaneDistance, vec2(mViewportX, mViewportY)); +} + +#endif \ No newline at end of file diff --git a/Source/Application/Light.h b/Source/Application/Light.h new file mode 100644 index 00000000..57f3e0e0 --- /dev/null +++ b/Source/Application/Light.h @@ -0,0 +1,250 @@ +// VQEngine | DirectX11 Renderer +// Copyright(C) 2018 - Volkan Ilbeyli +// +// This program is free software : you can redistribute it and / or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program.If not, see . +// +// Contact: volkanilbeyli@gmail.com + +#pragma once + + +#include "Transform.h" +#include "Settings.h" +//#include "DataStructures.h" +// +//#include "Renderer/RenderingEnums.h" +//#include "Renderer/Texture.h" +// +//#include "Utilities/Color.h" + +#include + + +// Only used for point lights when querying LightSpaceMatrix, ViewMatrix and ViewFrustumPlanes. +// +#define DEFAULT_POINT_LIGHT_LOOK_DIRECTION Texture::CubemapUtility::ECubeMapLookDirections::CUBEMAP_LOOK_FRONT + + +// Design considerations here: +// +// INHERITANCE +// - if we were to use inheritance for different types of lights, then we can utilize pure virtual functions +// to enforce class-specific behavior. However, now, we cannot store a vector due to pure virtuality. +// most likely solution is the store pointers to derived types, which now requires a memory manager for lights +// if we want to iterate over lights in a linear-memory-access fashion. +// +// C-STYLE +// - instead, we can collect the light-specific data under a union and enforce light-specific behavior +// through the ELightType enum. Currently favoring this approach over inheritance to avoid maintaining the memory +// of the derived types and simply making use of a vector to hold all light data. +// + +struct Light +{ + enum ELightType : int + { + POINT = 0, + SPOT, + DIRECTIONAL, + + LIGHT_TYPE_COUNT + }; + + // returns a view matrix for each light type that supports shadow mapping + // + static DirectX::XMMATRIX CalculateDirectionalLightViewMatrix(const Light& mDirLight); + static DirectX::XMMATRIX CalculateSpotLightViewMatrix(const Transform& mTransform); + //static DirectX::XMMATRIX CalculatePointLightViewMatrix(Texture::CubemapUtility::ECubeMapLookDirections lookDir, const vec3& position); + +#if 0 + // returns a projection matrix based on @lightType, @near, @far and in the directional light case, @viewPortSize as well. + // + static DirectX::XMMATRIX CalculateProjectionMatrix(Light::ELightType lightType, float near, float far, vec2 viewPortSize = vec2(0, 0)); + + + //-------------------------------------------------------------------------------------------------------------- + // INTERFACE + //-------------------------------------------------------------------------------------------------------------- + Light() // DEFAULTS + : mColor(LinearColor::white) + , mbEnabled(true) + , mType(LIGHT_TYPE_COUNT) + , mBrightness(300.0f) + , mbCastingShadows(false) + , mDepthBias(0.0f) + , mNearPlaneDistance(0.0f) + , mFarPlaneDistance(0.0f) + , mRange(100.0f) + , mTransform() + , mMeshID(EGeometry::SPHERE) + {} + Light + ( + LinearColor color + , ELightType type + , float brightness + , bool bCastShadows + , float depthBias + , float nearPlaneDistance + , float range + , Transform transform + , EGeometry mesh + ) + : mColor(color) + , mType(type) + , mBrightness(brightness) + , mbCastingShadows(bCastShadows) + , mDepthBias(depthBias) + , mNearPlaneDistance(nearPlaneDistance) + , mRange(range) + , mTransform(transform) + , mMeshID(mesh) + {} + + + // returns the projection matrix for the light space transformation. + // + DirectX::XMMATRIX GetProjectionMatrix() const; + + // returns the view matrix for Directional/Spot lights. + // Use 'Texture::CubemapUtility::ECubeMapLookDirections' to get view matrices for cubemap faces for PointLight. + // + DirectX::XMMATRIX GetViewMatrix(Texture::CubemapUtility::ECubeMapLookDirections lookDir = DEFAULT_POINT_LIGHT_LOOK_DIRECTION) const; + + // returns the frustum plane data for the light. + // Use 'Texture::CubemapUtility::ECubeMapLookDirections' to get frustum planes for each direction for PointLight. + // + inline FrustumPlaneset GetViewFrustumPlanes(Texture::CubemapUtility::ECubeMapLookDirections lookDir = DEFAULT_POINT_LIGHT_LOOK_DIRECTION) const + { + return FrustumPlaneset::ExtractFromMatrix(GetLightSpaceMatrix(lookDir)); + } + + // Returns the View*Projection matrix that describes the light-space transformation of a world space position. + // Use 'Texture::CubemapUtility::ECubeMapLookDirections' to get the light space matrix for each direction for PointLight. + // + inline DirectX::XMMATRIX GetLightSpaceMatrix(Texture::CubemapUtility::ECubeMapLookDirections lookDir = DEFAULT_POINT_LIGHT_LOOK_DIRECTION) const + { + return GetViewMatrix(lookDir) * GetProjectionMatrix(); + } + + + void GetGPUData(PointLightGPU& refData) const; + void GetGPUData(SpotLightGPU& refData) const; + void GetGPUData(DirectionalLightGPU& refData) const; + + // TODO: remove this arbitrary function for directional lights + Settings::ShadowMap GetSettings() const; // ? + +private: + // cache the View and Projection matrices in the struct as computing a lot + // of them is quite expensive (many point lights) during frustum culling. + DirectX::XMMATRIX mProjectionMatrix; + std::array mViewMatrix; + +public: + void SetMatrices(); + + inline const Transform& GetTransform() const { return mTransform; } + const void SetTransform(const Transform& transform); + +public: + //-------------------------------------------------------------------------------------------------------------- + // DATA + //-------------------------------------------------------------------------------------------------------------- + ELightType mType; + LinearColor mColor; + float mBrightness; + + bool mbCastingShadows; + float mDepthBias; + float mNearPlaneDistance; + union + { + // well, they're not essentially the same but good enough for saving space for now + float mFarPlaneDistance; + float mRange; + }; + + Transform mTransform; + EGeometry mMeshID; + + bool mbEnabled; + + union // LIGHT-SPECIFIC DATA + { + // DIRECTIONAL LIGHT ---------------------------------------- + // + // | | | | | + // | | | | | + // v v v v v + // + struct + { + float mViewportX; + float mViewportY; + float mDistanceFromOrigin; + }; + + + + // POINT LIGHT ----------------------------------------------- + // + // \|/ + // --*-- + // /|\ + // + struct // Point + { + float mAttenuationConstant ; // Currently Unused: attenuation = 1/distance^2 in the shaders + float mAttenuationLinear ; // Currently Unused: attenuation = 1/distance^2 in the shaders + float mAttenuationQuadratic; // Currently Unused: attenuation = 1/distance^2 in the shaders + }; + + + + // SPOT LIGHT -------------------------------------------------- + // + // * + // / \ + // /_____\ + // ' ' ' ' ' + // + struct // Spot + { + float mSpotOuterConeAngleDegrees; + float mSpotInnerConeAngleDegrees; + float dummy1; + }; + + + + // TODO: v0.6.0 linear lights from GPU Zen + // Eric Heitz Slides: https://drive.google.com/file/d/0BzvWIdpUpRx_Z2pZWWFtam5xTFE/view + // LINEAR LIGHT ------------------------------------------------ + // + // + // + // + // + // + struct // Area + { + float dummy2; + float dummy3; + float dummy4; + }; + }; +#endif +}; +constexpr size_t SZ_LIGHT_STRUCT = sizeof(Light); diff --git a/Source/Application/Main.cpp b/Source/Application/Main.cpp index 1181a92a..9e463778 100644 --- a/Source/Application/Main.cpp +++ b/Source/Application/Main.cpp @@ -158,6 +158,12 @@ void ParseCommandLineParameters(FStartupParameters& refStartupParams, PSTR pScmd else refStartupParams.EngineSettings.gfx.MaxFrameRate = StrUtil::ParseInt(paramValue); } + + if (paramName == "-Scene") + { + refStartupParams.bOverrideENGSetting_StartupScene = true; + refStartupParams.EngineSettings.StartupScene = paramValue; + } } } diff --git a/Source/Application/Mesh.cpp b/Source/Application/Mesh.cpp index 8977cdd3..09ff23e6 100644 --- a/Source/Application/Mesh.cpp +++ b/Source/Application/Mesh.cpp @@ -1,5 +1,5 @@ -// VQEngine | DirectX11 Renderer -// Copyright(C) 2018 - Volkan Ilbeyli +// VQE +// Copyright(C) 2020 - Volkan Ilbeyli // // This program is free software : you can redistribute it and / or modify // it under the terms of the GNU General Public License as published by diff --git a/Source/Application/Mesh.h b/Source/Application/Mesh.h index 93a8be54..6143ddcf 100644 --- a/Source/Application/Mesh.h +++ b/Source/Application/Mesh.h @@ -1,5 +1,5 @@ -// VQEngine | DirectX11 Renderer -// Copyright(C) 2018 - Volkan Ilbeyli +// VQE +// Copyright(C) 2020 - Volkan Ilbeyli // // This program is free software : you can redistribute it and / or modify // it under the terms of the GNU General Public License as published by diff --git a/Source/Application/Model.cpp b/Source/Application/Model.cpp new file mode 100644 index 00000000..5e760bda --- /dev/null +++ b/Source/Application/Model.cpp @@ -0,0 +1,449 @@ +// VQE +// Copyright(C) 2020 - Volkan Ilbeyli +// +// This program is free software : you can redistribute it and / or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program.If not, see . +// +// Contact: volkanilbeyli@gmail.com + +#include "Model.h" + +#if 0 +#include "Utilities/Log.h" +#include "Utilities/PerfTimer.h" + +#include "Renderer/Renderer.h" + +#include "Scene.h" + +#include +#include +#include + +#include "Engine.h" + +#include + + +const char* ModelLoader::sRootFolderModels = "Data/Models/"; + +using namespace Assimp; +using fnTypeProcessNode = std::function&)>; +using fnTypeProcessMesh = std::function; + + + +bool Model::Data::AddMaterial(MeshID meshID, MaterialID matID, bool bTransparent) +{ + auto it = mMaterialLookupPerMesh.find(meshID); + if (it == mMaterialLookupPerMesh.end()) + { + mMaterialLookupPerMesh[meshID] = matID; + } + else + { +#if _DEBUG + Log::Warning("Overriding Material"); +#endif + mMaterialLookupPerMesh[meshID] = matID; + + if (bTransparent) + { + mTransparentMeshIDs.push_back(meshID); + } + } + + return true; +} + + +void Model::AddMaterialToMesh(MeshID meshID, MaterialID materialID, bool bTransparent) +{ + mData.AddMaterial(meshID, materialID); +} + +void Model::OverrideMaterials(MaterialID materialID) +{ + for (MeshID mesh : mData.mMeshIDs) + { + mData.AddMaterial(mesh, materialID); + } +} + + +//---------------------------------------------------------------------------------------------------------------- +// ASSIMP HELPER FUNCTIONS +//---------------------------------------------------------------------------------------------------------------- +std::vector LoadMaterialTextures( + aiMaterial* pMaterial, + aiTextureType type, + const std::string& textureName, + VQRenderer* mpRenderer, + const std::string& modelDirectory +) +{ + std::vector textures; + for (unsigned int i = 0; i < pMaterial->GetTextureCount(type); i++) + { + aiString str; + pMaterial->GetTexture(type, i, &str); + std::string path = str.C_Str(); + { + std::unique_lock lock(Engine::mLoadRenderingMutex); + textures.push_back(mpRenderer->CreateTextureFromFile(path, modelDirectory, true)); + } + } + return textures; +} + + +Mesh ProcessMesh(aiMesh * mesh, const aiScene * scene) +{ + std::vector Vertices; + std::vector Indices; + + // Walk through each of the mesh's vertices + for (unsigned int i = 0; i < mesh->mNumVertices; i++) + { + DefaultVertexBufferData Vert; + + // POSITIONS + Vert.position = vec3( + mesh->mVertices[i].x, + mesh->mVertices[i].y, + mesh->mVertices[i].z + ); + + // NORMALS + if (mesh->mNormals) + { + Vert.normal = vec3( + mesh->mNormals[i].x, + mesh->mNormals[i].y, + mesh->mNormals[i].z + ); + } + + // TEXTURE COORDINATES + // a vertex can contain up to 8 different texture coordinates. We thus make the assumption that we won't + // use models where a vertex can have multiple texture coordinates so we always take the first set (0). + Vert.uv = mesh->mTextureCoords[0] + ? vec2(mesh->mTextureCoords[0][i].x, mesh->mTextureCoords[0][i].y) + : vec2(0, 0); + + // TANGENT + if (mesh->mTangents) + { + Vert.tangent = vec3( + mesh->mTangents[i].x, + mesh->mTangents[i].y, + mesh->mTangents[i].z + ); + } + + + // BITANGENT ( NOT USED ) + // Vert.bitangent = vec3( + // mesh->mBitangents[i].x, + // mesh->mBitangents[i].y, + // mesh->mBitangents[i].z + // ); + Vertices.push_back(Vert); + } + + // now walk through each of the mesh's faces (a face is a mesh its triangle) and retrieve the corresponding vertex indices. + for (unsigned int i = 0; i < mesh->mNumFaces; i++) + { + aiFace face = mesh->mFaces[i]; + // retrieve all indices of the face and store them in the indices vector + for (unsigned int j = 0; j < face.mNumIndices; j++) + Indices.push_back(face.mIndices[j]); + } + + // TODO: mesh name + + Mesh newMesh = [&]() + { + std::unique_lock lck(Engine::mLoadRenderingMutex); + return Mesh(Vertices, Indices, "ImportedModelMesh0"); // return a mesh object created from the extracted mesh data + }(); + return newMesh; +} + +Model::Data ProcessNode( + aiNode* const pNode, + const aiScene* pAiScene, + const std::string& modelDirectory, + VQRenderer* mpRenderer, // creates resources + Scene* pScene // write +) +{ + Model::Data modelData; + std::vector& ModelMeshIDs = modelData.mMeshIDs; + + for (unsigned int i = 0; i < pNode->mNumMeshes; i++) + { // process all the node's meshes (if any) + aiMesh* pAiMesh = pAiScene->mMeshes[pNode->mMeshes[i]]; + + // MATERIAL - http://assimp.sourceforge.net/lib_html/materials.html + aiMaterial* material = pAiScene->mMaterials[pAiMesh->mMaterialIndex]; + std::vector diffuseMaps = LoadMaterialTextures(material, aiTextureType_DIFFUSE , "texture_diffuse" , mpRenderer, modelDirectory); + std::vector specularMaps = LoadMaterialTextures(material, aiTextureType_SPECULAR , "texture_specular", mpRenderer, modelDirectory); + std::vector normalMaps = LoadMaterialTextures(material, aiTextureType_NORMALS , "texture_normal" , mpRenderer, modelDirectory); + std::vector heightMaps = LoadMaterialTextures(material, aiTextureType_HEIGHT , "texture_height" , mpRenderer, modelDirectory); + std::vector alphaMaps = LoadMaterialTextures(material, aiTextureType_OPACITY , "texture_alpha" , mpRenderer, modelDirectory); + + BRDF_Material* pBRDF = static_cast(pScene->CreateNewMaterial(GGX_BRDF)); + assert(diffuseMaps.size() <= 1); assert(normalMaps.size() <= 1); + assert(specularMaps.size() <= 1); assert(heightMaps.size() <= 1); + assert(alphaMaps.size() <= 1); + if (!diffuseMaps.empty()) pBRDF->diffuseMap = diffuseMaps[0]; + if (!normalMaps.empty()) pBRDF->normalMap = normalMaps[0]; + if (!specularMaps.empty()) pBRDF->specularMap = specularMaps[0]; + if (!heightMaps.empty()) pBRDF->heightMap = heightMaps[0]; + if (!alphaMaps.empty()) pBRDF->mask = alphaMaps[0]; + + aiString name; + if (aiReturn_SUCCESS == material->Get(AI_MATKEY_NAME, name)) + { + // we don't store names for materials. probably best to store them in a lookup somewhere, + // away from the material data. + // + // pBRDF-> + } + + aiColor3D color(0.f, 0.f, 0.f); + if (aiReturn_SUCCESS == material->Get(AI_MATKEY_COLOR_DIFFUSE, color)) + { + pBRDF->diffuse = vec3(color.r, color.g, color.b); + } + + aiColor3D specular(0.f, 0.f, 0.f); + if (aiReturn_SUCCESS == material->Get(AI_MATKEY_COLOR_SPECULAR, specular)) + { + pBRDF->specular = vec3(specular.r, specular.g, specular.b); + } + + aiColor3D transparent(0.0f, 0.0f, 0.0f); + if (aiReturn_SUCCESS == material->Get(AI_MATKEY_COLOR_TRANSPARENT, transparent)) + { // Defines the transparent color of the material, this is the color to be multiplied + // with the color of translucent light to construct the final 'destination color' + // for a particular position in the screen buffer. T + // + //pBRDF->specular = vec3(specular.r, specular.g, specular.b); + } + + float opacity = 0.0f; + if (aiReturn_SUCCESS == material->Get(AI_MATKEY_OPACITY, opacity)) + { + pBRDF->alpha = opacity; + } + + float shininess = 0.0f; + if (aiReturn_SUCCESS == material->Get(AI_MATKEY_SHININESS, shininess)) + { + // Phong Shininess -> Beckmann BRDF Roughness conversion + // + // https://simonstechblog.blogspot.com/2011/12/microfacet-brdf.html + // https://computergraphics.stackexchange.com/questions/1515/what-is-the-accepted-method-of-converting-shininess-to-roughness-and-vice-versa + // + pBRDF->roughness = sqrtf(2.0f / (2.0f + shininess)); + } + +#if MAKE_IRONMAN_METALLIC || MAKE_ZENBALL_METALLIC + + // --- + // quick hack to assign metallic value to the loaded mesh + // + std::string fileName(pAiScene->mRootNode->mName.C_Str()); + std::transform(RANGE(fileName), fileName.begin(), ::tolower); + auto tokens = StrUtil::split(fileName, '.'); + if (!tokens.empty() && (tokens[0] == "ironman" || tokens[0] == "zen_orb")) + { + pBRDF->metalness = 1.0f; + } + //--- +#endif + + // other material keys to consider + // + // AI_MATKEY_TWOSIDED + // AI_MATKEY_ENABLE_WIREFRAME + // AI_MATKEY_BLEND_FUNC + // AI_MATKEY_BUMPSCALING + + Mesh mesh = ProcessMesh(pAiMesh, pAiScene); + { + MeshID id = pScene->AddMesh_Async(mesh); + ModelMeshIDs.push_back(id); + } + + modelData.mMaterialLookupPerMesh[ModelMeshIDs.back()] = pBRDF->ID; + if (pBRDF->IsTransparent()) + { + modelData.mTransparentMeshIDs.push_back(ModelMeshIDs.back()); + } + } + for (unsigned int i = 0; i < pNode->mNumChildren; i++) + { // then do the same for each of its children + Model::Data childModelData = ProcessNode(pNode->mChildren[i], pAiScene, modelDirectory, mpRenderer, pScene); + std::vector& ChildMeshes = childModelData.mMeshIDs; + std::vector& ChildMeshesTransparent = childModelData.mTransparentMeshIDs; + + std::copy(ChildMeshes.begin(), ChildMeshes.end(), std::back_inserter(ModelMeshIDs)); + std::copy(ChildMeshesTransparent.begin(), ChildMeshesTransparent.end(), std::back_inserter(modelData.mTransparentMeshIDs)); + for (auto& kvp : childModelData.mMaterialLookupPerMesh) + { +#if _DEBUG + assert(modelData.mMaterialLookupPerMesh.find(kvp.first) == modelData.mMaterialLookupPerMesh.end()); +#endif + modelData.mMaterialLookupPerMesh[kvp.first] = kvp.second; + } + } + return modelData; +} + +#endif + +#if 0 +//---------------------------------------------------------------------------------------------------------------- +// MODEL LOADER +//---------------------------------------------------------------------------------------------------------------- +constexpr auto ASSIMP_LOAD_FLAGS += aiProcess_Triangulate +| aiProcess_CalcTangentSpace +| aiProcess_MakeLeftHanded +| aiProcess_FlipUVs +| aiProcess_FlipWindingOrder +//| aiProcess_TransformUVCoords +//| aiProcess_FixInfacingNormals +| aiProcess_JoinIdenticalVertices +| aiProcess_GenSmoothNormals; + +Model ModelLoader::LoadModel(const std::string & modelPath, Scene* pScene) +{ + assert(mpRenderer); + const std::string fullPath = sRootFolderModels + modelPath; + const std::string modelDirectory = DirectoryUtil::GetFolderPath(fullPath); + const std::string modelName = DirectoryUtil::GetFileNameWithoutExtension(fullPath); + + // CHECK CACHE FIRST - don't load the same model more than once + // + if (mLoadedModels.find(fullPath) != mLoadedModels.end()) + { + return mLoadedModels.at(fullPath); + } + + + PerfTimer t; + t.Start(); + + Log::Info("Loading Model: %s ...", modelName.c_str()); + + // IMPORT SCENE + // + Importer importer; + const aiScene* scene = importer.ReadFile(fullPath, ASSIMP_LOAD_FLAGS); + if (!scene || scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode) + { + Log::Error("Assimp error: %s", importer.GetErrorString()); + return Model(); + } + Model::Data data = ProcessNode(scene->mRootNode, scene, modelDirectory, mpRenderer, pScene); + + // cache the model + const Model model = Model(modelDirectory, modelName, std::move(data)); + mLoadedModels[fullPath] = model; + + // register scene and the model loaded + if (mSceneModels.find(pScene) == mSceneModels.end()) // THIS BEGS FOR TEMPLATE PROGRAMMING + { // first + mSceneModels[pScene] = std::vector { fullPath }; + } + else + { + mSceneModels.at(pScene).push_back(fullPath); + } + t.Stop(); + Log::Info("Loaded Model '%s' in %.2f seconds.", modelName.c_str(), t.DeltaTime()); + return model; +} + + +Model ModelLoader::LoadModel_Async(const std::string& modelPath, Scene* pScene) +{ + assert(mpRenderer); + const std::string fullPath = sRootFolderModels + modelPath; + const std::string modelDirectory = DirectoryUtil::GetFolderPath(fullPath); + const std::string modelName = DirectoryUtil::GetFileNameWithoutExtension(fullPath); + + // CHECK CACHE FIRST - don't load the same model more than once + // + { + std::unique_lock l(mLoadedModelMutex); + if (mLoadedModels.find(fullPath) != mLoadedModels.end()) + { + return mLoadedModels.at(fullPath); + } + } + + PerfTimer t; + t.Start(); + + //Log::Info("Loading Model: %s ...", modelName.c_str()); + + // IMPORT SCENE + // + Importer importer; + const aiScene* scene = importer.ReadFile(fullPath, ASSIMP_LOAD_FLAGS); + if (!scene || scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode) + { + Log::Error("Assimp error: %s", importer.GetErrorString()); + return Model(); + } + Model::Data data = ProcessNode(scene->mRootNode, scene, modelDirectory, mpRenderer, pScene); + + // cache the model + const Model model = Model(modelDirectory, modelName, std::move(data)); + { + std::unique_lock l(mLoadedModelMutex); + mLoadedModels[fullPath] = model; + } + + // register scene and the model loaded + { + std::unique_lock l(mSceneModelsMutex); + if (mSceneModels.find(pScene) == mSceneModels.end()) // THIS BEGS FOR TEMPLATE PROGRAMMING + { // first + mSceneModels[pScene] = std::vector{ fullPath }; + } + else + { + mSceneModels.at(pScene).push_back(fullPath); + } + } + + t.Stop(); + //Log::Info("Loaded Model '%s' in %.2f seconds.", modelName.c_str(), t.DeltaTime()); + return model; +} + +void ModelLoader::UnloadSceneModels(Scene * pScene) +{ + if (mSceneModels.find(pScene) == mSceneModels.end()) return; + for (std::string& modelDirectory : mSceneModels.at(pScene)) + { + mLoadedModels.erase(modelDirectory); + } +} +#endif \ No newline at end of file diff --git a/Source/Application/Model.h b/Source/Application/Model.h new file mode 100644 index 00000000..73b80caf --- /dev/null +++ b/Source/Application/Model.h @@ -0,0 +1,134 @@ +// VQE +// Copyright(C) 2020 - Volkan Ilbeyli +// +// This program is free software : you can redistribute it and / or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program.If not, see . +// +// Contact: volkanilbeyli@gmail.com +#pragma once + +//#include "Material.h" // TODO +#include "Mesh.h" +#include "Types.h" + +#include +#include +#include + +#include + +struct aiScene; +struct aiNode; +struct aiMesh; +struct aiMaterial; +class VQRenderer; +// class GameObject; // TODO +// class Scene; // TODO + +struct MeshRenderSettings +{ + enum EMeshRenderMode + { + FILL = 0, + WIREFRAME, + + NUM_MESH_RENDER_MODES + }; + static EMeshRenderMode DefaultRenderSettings() { return { EMeshRenderMode::FILL }; } + EMeshRenderMode renderMode = EMeshRenderMode::FILL; +}; + +using MeshMaterialLookup_t = std::unordered_map; +using MeshRenderSettingsLookup_t = std::unordered_map; + + +// +// MODEL +// +struct Model +{ +public: + struct Data + { + std::vector mMeshIDs; + MeshMaterialLookup_t mOpaqueMaterials; + MeshMaterialLookup_t mTransparentMaterials; + inline bool HasMaterial() const { return !mOpaqueMaterials.empty() || !mTransparentMaterials.empty(); } + bool AddMaterial(MeshID meshID, MaterialID matID, bool bTransparent = false); + }; + + void AddMaterialToMesh(MeshID meshID, MaterialID materialID, bool bTransparent); + void OverrideMaterials(MaterialID materialID); + + Model() = default; + Model(const std::string& directoryFullPath, const std::string& modelName, Data&& modelDataIn) + : mData(modelDataIn) + , mModelName(modelName) + , mModelDirectory(directoryFullPath) + , mbLoaded(true) + {} + + //--------------------------------------- + + Data mData; + std::string mModelName; + std::string mModelDirectory; + bool mbLoaded = false; + +private: + friend class GameObject; + friend class Scene; + + // queue of materials to be assigned in case the model has not been loaded yet. + std::queue mMaterialAssignmentQueue; +}; + + + + +// +// MODEL LOADER +// +class ModelLoader +{ +public: + inline void Initialize(VQRenderer* pRenderer) { mpRenderer = pRenderer; } + + // Loads the Model in a serial fashion - blocks thread + // + Model LoadModel(const std::string& modelPath, Scene* pScene); + + // Ends async loading. + // + Model LoadModel_Async(const std::string& modelPath, Scene* pScene); + + + void UnloadSceneModels(Scene* pScene); + + +private: + static const char* sRootFolderModels; + + + using ModelLookUpTable = std::unordered_map; + using PerSceneModelNameLookupTable = std::unordered_map>; + + +private: + VQRenderer* mpRenderer; + ModelLookUpTable mLoadedModels; + PerSceneModelNameLookupTable mSceneModels; + + std::mutex mLoadedModelMutex; + std::mutex mSceneModelsMutex; +}; \ No newline at end of file diff --git a/Source/Application/Platform.h b/Source/Application/Platform.h index 341dd716..8537f14f 100644 --- a/Source/Application/Platform.h +++ b/Source/Application/Platform.h @@ -57,8 +57,7 @@ struct FStartupParameters uint8 bOverrideENGSetting_bAutomatedTest : 1; uint8 bOverrideENGSetting_bTestFrames : 1; - - std::string LevelNameToLoad = "DefaultScene"; + uint8 bOverrideENGSetting_StartupScene : 1; }; LRESULT CALLBACK WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam); diff --git a/Source/Application/Quaternion.h b/Source/Application/Quaternion.h index 087aec0f..23676ece 100644 --- a/Source/Application/Quaternion.h +++ b/Source/Application/Quaternion.h @@ -33,6 +33,7 @@ class Quaternion Quaternion(const DirectX::XMMATRIX& rotMatrix); Quaternion(float s, const DirectX::XMVECTOR& v); + Quaternion(float s, const DirectX::XMFLOAT3& v) : S(s), V(v) {}; Quaternion operator+(const Quaternion& q) const; Quaternion operator*(const Quaternion& q) const; @@ -48,7 +49,6 @@ class Quaternion DirectX::XMFLOAT3 TransformVector(const DirectX::XMFLOAT3& v) const; DirectX::XMVECTOR TransformVector(const DirectX::XMVECTOR& v) const; private: // used by operator()s - Quaternion(float s, const DirectX::XMFLOAT3& v) : S(s), V(v) {}; Quaternion() = default; public: diff --git a/Source/Application/Scene.cpp b/Source/Application/Scene.cpp new file mode 100644 index 00000000..267fe004 --- /dev/null +++ b/Source/Application/Scene.cpp @@ -0,0 +1,1806 @@ +// VQEngine | DirectX11 Renderer +// Copyright(C) 2018 - Volkan Ilbeyli +// +// This program is free software : you can redistribute it and / or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program.If not, see . +// +// Contact: volkanilbeyli@gmail.com + +#define NOMINMAX + +#include "Scene.h" +#include "Window.h" + +using namespace DirectX; + +void Scene::Update(float dt, int FRAME_DATA_INDEX) +{ + assert(FRAME_DATA_INDEX < mFrameSceneViews.size()); + FSceneView& SceneView = mFrameSceneViews[FRAME_DATA_INDEX]; + + this->UpdateScene(dt, SceneView); +} + +void Scene::PostUpdate(int FRAME_DATA_INDEX, int FRAME_DATA_NEXT_INDEX) +{ + assert(FRAME_DATA_INDEX < mFrameSceneViews.size()); + FSceneView& SceneView = mFrameSceneViews[FRAME_DATA_INDEX]; + + const Camera& cam = mCameras[mIndex_SelectedCamera]; + const XMFLOAT3 camPos = cam.GetPositionF(); + + // extract scene view + SceneView.proj = cam.GetProjectionMatrix(); + SceneView.projInverse = XMMatrixInverse(NULL, SceneView.proj); + SceneView.view = cam.GetViewMatrix(); + SceneView.viewInverse = cam.GetViewInverseMatrix(); + SceneView.viewProj = SceneView.view * SceneView.proj; + SceneView.cameraPosition = XMLoadFloat3(&camPos); +} + +void Scene::StartLoading(FSceneRepresentation& scene) +{ + // scene-specific load + this->LoadScene(scene); + + // dispatch workers + + // initialize cameras + for (FCameraParameters& param : scene.Cameras) + { + param.Width = mpWindow->GetWidth(); + param.Height = mpWindow->GetHeight(); + + Camera c; + c.InitializeCamera(param); + mCameras.push_back(c); + } + + // assign scene rep + mSceneRepresentation = scene; +} + +void Scene::OnLoadComplete() +{ + Log::Info("[Scene] %s loaded.", mSceneRepresentation.SceneName.c_str()); + mSceneRepresentation.loadSuccess = 1; +} + +void Scene::Unload() +{ + mSceneRepresentation = {}; + + const size_t sz = mFrameSceneViews.size(); + mFrameSceneViews.clear(); + mFrameSceneViews.resize(sz); + + mMeshIDs.clear(); + mObjects.clear(); + mGameObjectTransforms.clear(); + mCameras.clear(); + + mDirectionalLight = {}; + mLightsStatic.clear(); + mLightsDynamic.clear(); + + mSceneBoundingBox = {}; + mMeshBoundingBoxes.clear(); + mGameObjectBoundingBoxes.clear(); + + mIndex_SelectedCamera + = mIndex_ActiveEnvironmentMapPreset + = 0; +} + +void Scene::RenderUI() +{ + // TODO +} + + +#if 0 +#include "SceneResourceView.h" +#include "Engine.h" +#include "ObjectCullingSystem.h" + +#include "Application/Input.h" +#include "Application/ThreadPool.h" +#include "Renderer/GeometryGenerator.h" +#include "Utilities/Log.h" + +#include +#include + +#define THREADED_FRUSTUM_CULL 0 // uses workers to cull the render lists (not implemented yet) + +Scene::Scene(const BaseSceneParams& params) + : mpRenderer(params.pRenderer) + , mpTextRenderer(params.pTextRenderer) + , mSelectedCamera(0) + , mpCPUProfiler(params.pCPUProfiler) + , mLODManager(this->mMeshIDs, this->mpRenderer) + , mActiveSkyboxPreset(ENVIRONMENT_MAP_PRESET_COUNT) +{ + mModelLoader.Initialize(mpRenderer); +} + + +//---------------------------------------------------------------------------------------------------------------- +// LOAD / UNLOAD FUNCTIONS +//---------------------------------------------------------------------------------------------------------------- +void Scene::LoadScene(FSceneRepresentation& scene, const Settings::Window& windowSettings) +{ + // + // Allocate GameObject & Material memory + // +#ifdef _DEBUG + mObjectPool.Initialize(4096); + mMaterials.Initialize(4096); +#else + mObjectPool.Initialize(4096 * 8); + mMaterials.Initialize(4096 * 8); +#endif + + mMeshIDs.clear(); + mpObjects.clear(); + mMeshIDs.resize(mBuiltinMeshes.size()); + std::copy(RANGE(mBuiltinMeshes), mMeshIDs.begin()); + + + // + // Lights + // + for (Light& l : scene.lights) this->AddLight(std::move(l)); + //mLights = std::move(scene.lights); + + mMaterials = std::move(scene.materials); + mDirectionalLight = std::move(scene.directionalLight); + mSceneRenderSettings = scene.settings; + + + // + // Cameras + // + for (const Settings::Camera& camSetting : scene.cameras) + { + Camera c; + c.ConfigureCamera(camSetting, windowSettings, mpRenderer); + mCameras.push_back(c); + } + + + // + // Game Objects + // + for (size_t i = 0; i < scene.objects.size(); ++i) + { + GameObject* pObj = mObjectPool.Create(this); + *pObj = scene.objects[i]; + pObj->mpScene = this; + + // if the game object has a model that is not loaded yet + // call the async load function + if (!pObj->mModel.mbLoaded && !pObj->mModel.mModelName.empty()) + { + LoadModel_Async(pObj, pObj->mModel.mModelName); + } + mpObjects.push_back(pObj); + } + + + Load(scene); // Scene-specific load + StartLoadingModels(); // async model loading + + SetLightCache(); + + EndLoadingModels(); + + // initialize LOD manager + { + std::vector pSceneObjects; + for (GameObject* pObj : mpObjects) + { + if (pObj->mpScene == this) + { + pSceneObjects.push_back(pObj); + } + } + + mLODManager.Initialize(GetActiveCamera(), pSceneObjects); + } + CalculateSceneBoundingBox(); // needs to happen after models are loaded +} + + +void Scene::UnloadScene() +{ + //--------------------------------------------------------------------------- + // if we clear materials and don't clear the models loaded with them, + // we'll crash in lookups. this can be improved by only reloading + // the materials instead of the whole mesh data. #TODO: more granular reload + mModelLoader.UnloadSceneModels(this); + mMaterials.Clear(); + //--------------------------------------------------------------------------- + mCameras.clear(); + mObjectPool.Cleanup(); + mMeshIDs.clear(); + mObjectPool.Cleanup(); + ClearLights(); + mLODManager.Reset(); + Unload(); + mpObjects.clear(); +} + +void Scene::RenderUI() +{ +} + + +MeshID Scene::AddMesh_Async(Mesh mesh) +{ + std::unique_lock l(mSceneMeshMutex); + mMeshIDs.push_back(mesh); + return MeshID(mMeshIDs.size() - 1); +} + +void Scene::StartLoadingModels() +{ + // can have multiple objects pointing to the same path + // get all the unique paths + // + std::set uniqueModelList; + + std::for_each(RANGE(mModelLoadQueue.objectModelMap), [&](auto kvp) + { // 'value' (.second) of the 'key value pair' (kvp) contains the model path + uniqueModelList.emplace(kvp.second); + }); + + if (uniqueModelList.empty()) return; + + Log::Info("Async Model Load List: "); + + // so we load the models only once + // + std::for_each(RANGE(uniqueModelList), [&](const std::string& modelPath) + { + Log::Info("\t%s", modelPath.c_str()); + mModelLoadQueue.asyncModelResults[modelPath] = mpThreadPool->AddTask([=]() + { + return mModelLoader.LoadModel_Async(modelPath, this); + }); + }); +} + +void Scene::EndLoadingModels() +{ + std::unordered_map loadedModels; + std::for_each(RANGE(mModelLoadQueue.objectModelMap), [&](auto kvp) + { + const std::string& modelPath = kvp.second; + GameObject* pObj = kvp.first; + + // this will wait on the longest item. + Model m = {}; + if (loadedModels.find(modelPath) == loadedModels.end()) + { + m = mModelLoadQueue.asyncModelResults.at(modelPath).get(); + loadedModels[modelPath] = m; + } + else + { + m = loadedModels.at(modelPath); + } + + // override material if any. + if (!pObj->mModel.mMaterialAssignmentQueue.empty()) + { + MaterialID matID = pObj->mModel.mMaterialAssignmentQueue.front(); + pObj->mModel.mMaterialAssignmentQueue.pop(); // we only use the first material for now... + m.OverrideMaterials(matID); + } + + // assign the model to object + pObj->SetModel(m); + }); +} + +void Scene::AddStaticLight(const Light& l) +{ + mLightsStatic.push_back(l); + + // Note: Static light cache is initialized after the loading is done. + // So we just push the light to the static light container here. +} + +void Scene::AddDynamicLight(const Light& l) +{ + mLightsDynamic.push_back(l); +} + +Model Scene::LoadModel(const std::string & modelPath) +{ + return mModelLoader.LoadModel(modelPath, this); +} + +void Scene::LoadModel_Async(GameObject* pObject, const std::string& modelPath) +{ + std::unique_lock lock(mModelLoadQueue.mutex); + mModelLoadQueue.objectModelMap[pObject] = modelPath; +} + + +//---------------------------------------------------------------------------------------------------------------- +// UPDATE FUNCTIONS +//---------------------------------------------------------------------------------------------------------------- +void Scene::UpdateScene(float dt) +{ + // CYCLE THROUGH CAMERAS + // + if (ENGINE->INP()->IsKeyTriggered("C")) + { + mSelectedCamera = (mSelectedCamera + 1) % mCameras.size(); + mLODManager.SetViewer(this->GetActiveCamera()); + } + + + // OPTIMIZATION SETTINGS TOGGLES + // +//#if _DEBUG +#if 1 + if (ENGINE->INP()->IsKeyTriggered("F7")) + { + bool& toggle = ENGINE->INP()->IsKeyDown("Shift") + ? mSceneRenderSettings.optimization.bViewFrustumCull_LocalLights + : mSceneRenderSettings.optimization.bViewFrustumCull_MainView; + + toggle = !toggle; + } + if (ENGINE->INP()->IsKeyTriggered("F8")) + { + mSceneRenderSettings.optimization.bViewFrustumCull_LocalLights = !mSceneRenderSettings.optimization.bViewFrustumCull_LocalLights; + } +#endif + + + + // UPDATE CAMERA & WORLD + // + mpCPUProfiler->BeginEntry("Scene::Update()"); + mCameras[mSelectedCamera].Update(dt); + Update(dt); + mpCPUProfiler->EndEntry(); + + // UPDATE LOD MANAGER + // + mpCPUProfiler->BeginEntry("LODManager::Update()"); + mLODManager.Update(); + mpCPUProfiler->EndEntry(); + + + // Note: + // this could be moved outside this function to allow for more time + // for concurrency of lod manager update operations (if it takes that long). + mpCPUProfiler->BeginEntry("LODManager::LateUpdate()"); + mLODManager.LateUpdate(); + mpCPUProfiler->EndEntry(); +} + +static void ResetSceneStatCounters(SceneStats& stats) +{ + stats.numSpots = 0; + stats.numPoints = 0; + //stats.numDirectionalCulledObjects = 0; + stats.numPointsCulledObjects = 0; + stats.numSpotsCulledObjects = 0; +} + +void Scene::PreRender(FrameStats& stats, SceneLightingConstantBuffer& outLightingData) +{ + using namespace VQEngine; + + // containers we'll work on for preparing draw lists + std::vector mainViewRenderList; // Shadow casters + non-shadow casters + std::vector mainViewShadowCasterRenderList; + SceneShadowingLightIndexCollection shadowingLightIndexCollection; + + + //---------------------------------------------------------------------------- + // SET SCENE VIEW / SETTINGS + //---------------------------------------------------------------------------- + SetSceneViewData(); + ResetSceneStatCounters(stats.scene); + + + //---------------------------------------------------------------------------- + // PREPARE RENDER LISTS + //---------------------------------------------------------------------------- + mpCPUProfiler->BeginEntry("GatherSceneObjects"); + GatherSceneObjects(mainViewShadowCasterRenderList, stats.scene.numObjects); + mpCPUProfiler->EndEntry(); + + //---------------------------------------------------------------------------- + // CULL LIGHTS + //---------------------------------------------------------------------------- + mpCPUProfiler->BeginEntry("Cull_Lights"); + shadowingLightIndexCollection = CullShadowingLights(stats.scene.numCulledShadowingPointLights, stats.scene.numCulledShadowingSpotLights); + mpCPUProfiler->EndEntry(); + + //---------------------------------------------------------------------------- + // CULL MAIN VIEW RENDER LISTS + //---------------------------------------------------------------------------- + mpCPUProfiler->BeginEntry("Cull_MainView"); + mainViewRenderList = FrustumCullMainView(stats.scene.numMainViewCulledObjects); + mpCPUProfiler->EndEntry(); + + + //---------------------------------------------------------------------------- + // CULL SHADOW VIEW RENDER LISTS + //---------------------------------------------------------------------------- + //mpCPUProfiler->BeginEntry("Cull_ShadowViews"); + FrustumCullPointAndSpotShadowViews(mainViewShadowCasterRenderList, shadowingLightIndexCollection, stats); + //mpCPUProfiler->EndEntry(); + + + //---------------------------------------------------------------------------- + // OCCLUSION CULL DIRECTIONAL SHADOW VIEW RENDER LISTS (not implemented yet) + //---------------------------------------------------------------------------- + if (mSceneRenderSettings.optimization.bShadowViewCull) + { + mpCPUProfiler->BeginEntry("Cull_Directional_Occl"); + OcclusionCullDirectionalLightView(); + mpCPUProfiler->EndEntry(); + } + + //mpCPUProfiler->BeginEntry("Gather_FlattenedLightList"); + std::vector pShadowingLights = shadowingLightIndexCollection.GetFlattenedListOfLights(mLightsStatic, mLightsDynamic); + //mpCPUProfiler->EndEntry(); + + //---------------------------------------------------------------------------- + // SORT RENDER LISTS + //---------------------------------------------------------------------------- + if (mSceneRenderSettings.optimization.bSortRenderLists) + { + mpCPUProfiler->BeginEntry("Sort"); + SortRenderLists(mainViewShadowCasterRenderList, pShadowingLights); + mpCPUProfiler->EndEntry(); + } + + + //---------------------------------------------------------------------------- + // BATCH SHADOW VIEW RENDER LISTS + //---------------------------------------------------------------------------- + BatchShadowViewRenderLists(mainViewShadowCasterRenderList); + + + //---------------------------------------------------------------------------- + // BATCH MAIN VIEW RENDER LISTS + //---------------------------------------------------------------------------- + mpCPUProfiler->BeginEntry("Batch_MainView"); + BatchMainViewRenderList(mainViewRenderList); + mpCPUProfiler->EndEntry(); + + +#if _DEBUG + static bool bReportedList = false; + if (!bReportedList) + { + Log::Info("Mesh Render List (%s): ", mSceneRenderSettings.optimization.bSortRenderLists ? "Sorted" : "Unsorted"); + int num = 0; + std::for_each(RANGE(mSceneView.culledOpaqueList), [&](const GameObject* pObj) + { + Log::Info("\tObj[%d]: ", num); + + int numMesh = 0; + std::for_each(RANGE(pObj->GetModelData().mMeshIDs), [&](const MeshID& id) + { + Log::Info("\t\tMesh[%d]: %d", numMesh, id); + }); + ++num; + }); + bReportedList = true; + } +#endif // THREADED_FRUSTUM_CULL + + + mpCPUProfiler->BeginEntry("GatherLightData"); + GatherLightData(outLightingData, pShadowingLights); + mpCPUProfiler->EndEntry(); + + //return numFrustumCulledObjs + numShadowFrustumCullObjs; +} + + +void Scene::ResetActiveCamera() +{ + mCameras[mSelectedCamera].Reset(); +} + +std::vector Scene::mBuiltinMeshes; +void Scene::InitializeBuiltinMeshes() +{ + + // cylinder parameters + const float cylHeight = 3.1415f; const float cylTopRadius = 1.0f; + const float cylBottomRadius = 1.0f; const unsigned cylSliceCount = 70; + const unsigned cylStackCount = 20; + + // grid parameters + const float gridWidth = 1.0f; const float gridDepth = 1.0f; + const unsigned gridFinenessH = 90; const unsigned gridFinenessV = 90; + + // sphere parameters + const float sphRadius = 2.0f; + const unsigned sphRingCount = 70; const unsigned sphSliceCount = 70; + + // cone parameters + const float coneHeight = 3.0f; + const float coneRadius = 1.0f; + + constexpr int numDefaultLODLevels_Sphere = 5; + constexpr int numDefaultLODLevels_Grid = 7; + constexpr int numDefaultLODLevels_Cone = 6; + constexpr int numDefaultLODLevels_Cylinder = 6; + + Scene::mBuiltinMeshes = // this should match enum declaration order + { + GeometryGenerator::Triangle(1.0f), + GeometryGenerator::Quad(1.0f), + GeometryGenerator::FullScreenQuad(), + GeometryGenerator::Cube(), + GeometryGenerator::Cylinder(cylHeight, cylTopRadius, cylBottomRadius, cylSliceCount, cylStackCount, numDefaultLODLevels_Cylinder), + GeometryGenerator::Sphere(sphRadius, sphRingCount, sphSliceCount, numDefaultLODLevels_Sphere), + GeometryGenerator::Grid(gridWidth, gridDepth, gridFinenessH, gridFinenessV, numDefaultLODLevels_Grid), + GeometryGenerator::Cone(coneHeight, coneRadius, 120, numDefaultLODLevels_Cone), + GeometryGenerator::Cone(1.0f, 1.0f, 30), + //GeometryGenerator::Sphere(sphRadius / 40, 10, 10), + }; + + LODManager::InitializeBuiltinMeshLODSettings(); +} + +void Scene::SetEnvironmentMap(EEnvironmentMapPresets preset) +{ + mActiveSkyboxPreset = preset; + mSkybox = Skybox::s_Presets[mActiveSkyboxPreset]; +} + + + +//---------------------------------------------------------------------------------------------------------------- +// PRE-RENDER FUNCTIONS +//---------------------------------------------------------------------------------------------------------------- +// can't use std::array, hence std::array +// array of 2: light data for non-shadowing and shadowing lights +constexpr size_t NON_SHADOWING_LIGHT_INDEX = 0; +constexpr size_t SHADOWING_LIGHT_INDEX = 1; +using pPointLightDataArray = std::array; +using pSpotLightDataArray = std::array; + +// stores the number of lights per light type (2 types : point and spot) +using pNumArray = std::array; +void Scene::GatherLightData(SceneLightingConstantBuffer & outLightingData, const std::vector& pLightList) +{ + SceneLightingConstantBuffer::cb& cbuffer = outLightingData._cb; + + outLightingData.ResetCounts(); + + cbuffer.directionalLight.depthBias = 0.0f; + cbuffer.directionalLight.enabled = 0; + cbuffer.directionalLight.shadowing = 0; + cbuffer.directionalLight.brightness = 0.0f; + + pNumArray lightCounts + { + &outLightingData._cb.pointLightCount, + &outLightingData._cb.spotLightCount + }; + pNumArray casterCounts + { + &outLightingData._cb.pointLightCount_shadow, + &outLightingData._cb.spotLightCount_shadow + }; + + unsigned numShdSpot = 0; + unsigned numPtSpot = 0; + + for (const Light* l : pLightList) + { + //if (!l->_bEnabled) continue; // #BreaksRelease + + pNumArray& refLightCounts = casterCounts; + const size_t lightIndex = (*refLightCounts[l->mType])++; + switch (l->mType) + { + case Light::ELightType::POINT: + { + PointLightGPU plData; + l->GetGPUData(plData); + + cbuffer.pointLightsShadowing[lightIndex] = plData; + mShadowView.points.push_back(l); + } break; + case Light::ELightType::SPOT: + { + SpotLightGPU slData; + l->GetGPUData(slData); + + cbuffer.spotLightsShadowing[lightIndex] = slData; + cbuffer.shadowViews[numShdSpot++] = l->GetLightSpaceMatrix(); + mShadowView.spots.push_back(l); + } break; + default: + Log::Error("Engine::PreRender(): UNKNOWN LIGHT TYPE"); + continue; + } + } + + // iterate for non-shadowing lights (they won't be in pLightList) + constexpr size_t NUM_LIGHT_CONTAINERS = 2; + std::array*, NUM_LIGHT_CONTAINERS > lightContainers = + { + &mLightsStatic + , &mLightsDynamic + }; + for (int i = 0; i < NUM_LIGHT_CONTAINERS; ++i) + { + const std::vector& mLights = *lightContainers[i]; + for (const Light& l : mLights) + { + if (l.mbCastingShadows) continue; + pNumArray& refLightCounts = lightCounts; + + const size_t lightIndex = (*refLightCounts[l.mType])++; + switch (l.mType) + { + case Light::ELightType::POINT: + { + PointLightGPU plData; + l.GetGPUData(plData); + cbuffer.pointLights[lightIndex] = plData; + } break; + case Light::ELightType::SPOT: + { + SpotLightGPU slData; + l.GetGPUData(slData); + cbuffer.spotLights[lightIndex] = slData; + } break; + default: + Log::Error("Engine::PreRender(): UNKNOWN LIGHT TYPE"); + continue; + } + } + } + + if (mDirectionalLight.mbEnabled) + { + mDirectionalLight.GetGPUData(cbuffer.directionalLight); + cbuffer.shadowViewDirectional = mDirectionalLight.GetLightSpaceMatrix(); + mShadowView.pDirectional = &mDirectionalLight; + } + else + { + cbuffer.directionalLight = {}; + } +} + +void Scene::SetSceneViewData() +{ + const Camera& viewCamera = GetActiveCamera(); + const XMMATRIX view = viewCamera.GetViewMatrix(); + const XMMATRIX viewInverse = viewCamera.GetViewInverseMatrix(); + const XMMATRIX proj = viewCamera.GetProjectionMatrix(); + XMVECTOR det = XMMatrixDeterminant(proj); + const XMMATRIX projInv = XMMatrixInverse(&det, proj); + det = mDirectionalLight.mbEnabled + ? XMMatrixDeterminant(mDirectionalLight.GetProjectionMatrix()) + : XMVECTOR(); + const XMMATRIX directionalLightProjection = mDirectionalLight.mbEnabled + ? mDirectionalLight.GetProjectionMatrix() + : XMMatrixIdentity(); + + // scene view matrices + mSceneView.viewProj = view * proj; + mSceneView.view = view; + mSceneView.viewInverse = viewInverse; + mSceneView.proj = proj; + mSceneView.projInverse = projInv; + mSceneView.directionalLightProjection = directionalLightProjection; + + // render/scene settings + mSceneView.sceneRenderSettings = GetSceneRenderSettings(); + mSceneView.environmentMap = GetEnvironmentMap(); + mSceneView.cameraPosition = viewCamera.GetPositionF(); + mSceneView.bIsIBLEnabled = mSceneRenderSettings.bSkylightEnabled && mSceneView.bIsPBRLightingUsed && mSceneView.environmentMap.environmentMap != -1; +} + +void Scene::GatherSceneObjects(std::vector & mainViewShadowCasterRenderList, int& outNumSceneObjects) +{ + // CLEAN UP RENDER LISTS + // + //pCPUProfiler->BeginEntry("CleanUp"); + // scene view + mSceneView.opaqueList.clear(); + mSceneView.culledOpaqueList.clear(); + mSceneView.culluedOpaqueInstancedRenderListLookup.clear(); + mSceneView.alphaList.clear(); + + // shadow views + mShadowView.Clear(); + mShadowView.RenderListsPerMeshType.clear(); + mShadowView.casters.clear(); + mShadowView.shadowMapRenderListLookUp.clear(); + mShadowView.shadowMapInstancedRenderListLookUp.clear(); + //pCPUProfiler->EndEntry(); + + // POPULATE RENDER LISTS WITH SCENE OBJECTS + // + outNumSceneObjects = 0; + for (GameObject& obj : mObjectPool.mObjects) + { + // only gather the game objects that are to be rendered in 'this' scene + if (obj.mpScene == this && obj.mRenderSettings.bRender) + { + const bool bMeshListEmpty = obj.mModel.mData.mMeshIDs.empty(); + const bool bTransparentMeshListEmpty = obj.mModel.mData.mTransparentMeshIDs.empty(); + const bool mbCastingShadows = obj.mRenderSettings.bCastShadow && !bMeshListEmpty; + + // populate render lists + if (!bMeshListEmpty) + { + mSceneView.opaqueList.push_back(&obj); + } + if (!bTransparentMeshListEmpty) + { + mSceneView.alphaList.push_back(&obj); + } + if (mbCastingShadows) + { + mainViewShadowCasterRenderList.push_back(&obj); + } + +#if _DEBUG + if (bMeshListEmpty && bTransparentMeshListEmpty) + { + Log::Warning("GameObject with no Mesh Data, turning bRender off"); + obj.mRenderSettings.bRender = false; + } +#endif + ++outNumSceneObjects; + } + } +} + + +void Scene::SortRenderLists(std::vector & mainViewShadowCasterRenderList, std::vector& pShadowingLights) +{ + // LAMBDA DEFINITIONS + //--------------------------------------------------------------------------------------------- + // Meshes are sorted according to BUILT_IN_TYPE < CUSTOM, + // and BUILT_IN_TYPEs are sorted in themselves + auto SortByMeshType = [&](const GameObject* pObj0, const GameObject* pObj1) + { + const ModelData& model0 = pObj0->GetModelData(); + const ModelData& model1 = pObj1->GetModelData(); + + const MeshID mID0 = model0.mMeshIDs.empty() ? -1 : model0.mMeshIDs.back(); + const MeshID mID1 = model1.mMeshIDs.empty() ? -1 : model1.mMeshIDs.back(); + + assert(mID0 != -1 && mID1 != -1); + + // case: one of the objects have a custom mesh + if (mID0 >= EGeometry::MESH_TYPE_COUNT || mID1 >= EGeometry::MESH_TYPE_COUNT) + { + if (mID0 < EGeometry::MESH_TYPE_COUNT) + return true; + + if (mID1 < EGeometry::MESH_TYPE_COUNT) + return false; + + return false; + } + + // case: both objects are built-in types + else + { + return mID0 < mID1; + } + }; + auto SortByMaterialID = [](const GameObject* pObj0, const GameObject* pObj1) + { + // TODO: + return true; + }; + auto SortByViewSpaceDepth = [](const GameObject* pObj0, const GameObject* pObj1) + { + // TODO: + return true; + }; + //--------------------------------------------------------------------------------------------- + + std::sort(RANGE(mSceneView.culledOpaqueList), SortByMeshType); + std::sort(RANGE(mainViewShadowCasterRenderList), SortByMeshType); + for (const Light* pLight : pShadowingLights) + { + switch (pLight->mType) + { + + case Light::ELightType::POINT: + { + for (int i = 0; i < 6; ++i) + { + ; + } + break; + } + case Light::ELightType::SPOT: + { + RenderList& lightRenderList = mShadowView.shadowMapRenderListLookUp.at(pLight); + std::sort(RANGE(lightRenderList), SortByMeshType); + break; + } + } + + } +} + +Scene::SceneShadowingLightIndexCollection Scene::CullShadowingLights(int& outNumCulledPoints, int& outNumCulledSpots) +{ + using namespace VQEngine; + + SceneShadowingLightIndexCollection sceneShadowingLightIndexCollection; + + outNumCulledPoints = 0; + outNumCulledSpots = 0; + + auto fnCullLights = [&](const std::vector& lights) -> ShadowingLightIndexCollection + { + ShadowingLightIndexCollection outLightIndices; + + for (int i = 0; i < lights.size(); ++i) + { + if (!lights[i].mbCastingShadows) continue; + + const Light& l = lights[i]; + switch (l.mType) + { + case Light::ELightType::SPOT: + { + // TODO: frustum - cone check + const bool bCullLight = false; + if (!bCullLight /* == IsVisible() */) + { + outLightIndices.spotLightIndices.push_back(i); + } + else + { + ++outNumCulledSpots; + } + } break; + + case Light::ELightType::POINT: + { + vec3 vecCamera = GetActiveCamera().GetPositionF() - l.mTransform._position; + const float dstSqrCameraToLight = XMVector3Dot(vecCamera, vecCamera).m128_f32[0]; + const float rangeSqr = l.mRange * l.mRange; + + const bool bIsCameraInPointLightSphereOfIncluence = dstSqrCameraToLight < rangeSqr; + const bool bSphereInFrustum = IsSphereInFrustum(GetActiveCamera().GetViewFrustumPlanes(), Sphere(l.mTransform._position, l.mRange)); + + if (bIsCameraInPointLightSphereOfIncluence || bSphereInFrustum) + { + outLightIndices.pointLightIndices.push_back(i); + } + else + { + ++outNumCulledPoints; + } + } break; + } // light type + + } + + return outLightIndices; + }; + + sceneShadowingLightIndexCollection.mStaticLights = fnCullLights(mLightsStatic); + sceneShadowingLightIndexCollection.mDynamicLights = fnCullLights(mLightsDynamic); + return sceneShadowingLightIndexCollection; +} + +std::vector Scene::FrustumCullMainView(int& outNumCulledObjects) +{ + using namespace VQEngine; + + const bool& bCullMainView = mSceneRenderSettings.optimization.bViewFrustumCull_MainView; + + std::vector mainViewRenderList; + + //mpCPUProfiler->BeginEntry("[Cull Main SceneView]"); + if (bCullMainView) + { + outNumCulledObjects = static_cast(CullGameObjects( + FrustumPlaneset::ExtractFromMatrix(mSceneView.viewProj) + , mSceneView.opaqueList + , mainViewRenderList)); + } + else + { + mainViewRenderList.resize(mSceneView.opaqueList.size()); + std::copy(RANGE(mSceneView.opaqueList), mainViewRenderList.begin()); + outNumCulledObjects = 0; + } + //mpCPUProfiler->EndEntry(); + + return mainViewRenderList; +} + + +void Scene::FrustumCullPointAndSpotShadowViews( + const std::vector & mainViewShadowCasterRenderList + , const SceneShadowingLightIndexCollection& shadowingLightIndices + , FrameStats& stats +) +{ + using namespace VQEngine; + + + auto fnCullPointLightView = [&](const Light* l, const std::array& frustumPlaneSetPerFace) + { +#if SHADOW_PASS_USE_INSTANCED_DRAW_DATA + std::array< MeshDrawData, 6>& meshDrawDataPerFace = mShadowView.shadowCubeMapMeshDrawListLookup[l]; + for (int i = 0; i < 6; ++i) + meshDrawDataPerFace[i].meshTransformListLookup.clear(); +#else + std::array< MeshDrawList, 6>& meshListForPoints = mShadowView.shadowCubeMapMeshDrawListLookup[l]; + for (int i = 0; i < 6; ++i) + meshListForPoints[i].clear(); +#endif + + // cull for far distance + std::vector filteredMainViewShadowCasterList(mainViewShadowCasterRenderList.size(), nullptr); + int numObjs = 0; + for (const GameObject* pObj : mainViewShadowCasterRenderList) + { + const XMMATRIX matWorld = pObj->GetTransform().WorldTransformationMatrix(); + BoundingBox BB = pObj->GetAABB(); // local space AABB (this is wrong, AABB should be calculated on update()). + BB.low = XMVector3Transform(BB.low, matWorld); + BB.hi = XMVector3Transform(BB.hi , matWorld); // world space BB + if (IsBoundingBoxInsideSphere_Approx(BB, Sphere(l->GetTransform()._position, l->mRange))) + filteredMainViewShadowCasterList[numObjs++] = pObj; + } + if (numObjs == 0) + { + return; + } + + // cull for visibility per face + for (int face = 0; face < 6; ++face) + { + const Texture::CubemapUtility::ECubeMapLookDirections CubemapFaceDirectionEnum = static_cast(face); + for (const GameObject* pObj : filteredMainViewShadowCasterList) + { + if (!pObj) // stop at first null game object because we resize @filteredMainViewShadowCasterList when creating it. + break; + +#if SHADOW_PASS_USE_INSTANCED_DRAW_DATA + stats.scene.numPointsCulledObjects += static_cast(CullMeshes + ( + frustumPlaneSetPerFace[face], + pObj, + meshDrawDataPerFace[face] + )); +#else + meshDrawData.meshIDs.clear(); + stats.scene.numPointsCulledObjects += static_cast(CullMeshes + ( + frustumPlaneSetPerFace[face], + pObj, + meshDrawData + )); + meshListForPoints[face].push_back(meshDrawData); +#endif + } + } + }; + auto fnCullSpotLightView = [&](const Light* l, const FrustumPlaneset& frustumPlaneSet) + { + RenderList& renderList = mShadowView.shadowMapRenderListLookUp[l]; + + renderList.clear(); + stats.scene.numSpotsCulledObjects += static_cast( + CullGameObjects( + frustumPlaneSet + , mainViewShadowCasterRenderList + , renderList + )); + }; + + + RenderList objList; + + // Culling Disabled: just copy the mainViewShadowCasterRenderList + // to the render lists of lights without any culling. + // + if (!mSceneRenderSettings.optimization.bViewFrustumCull_LocalLights) + { + // spots + for (int i = 0; i < shadowingLightIndices.mStaticLights.spotLightIndices.size(); ++i) + { + const Light* l = &mLightsStatic[shadowingLightIndices.mStaticLights.spotLightIndices[i]]; + + RenderList& renderList = mShadowView.shadowMapRenderListLookUp[l]; + renderList.resize(mainViewShadowCasterRenderList.size()); + std::copy(RANGE(mainViewShadowCasterRenderList), renderList.begin()); + } + for (int i = 0; i < shadowingLightIndices.mDynamicLights.spotLightIndices.size(); ++i) + { + const Light* l = &mLightsStatic[shadowingLightIndices.mDynamicLights.spotLightIndices[i]]; + + RenderList& renderList = mShadowView.shadowMapRenderListLookUp[l]; + renderList.resize(mainViewShadowCasterRenderList.size()); + std::copy(RANGE(mainViewShadowCasterRenderList), renderList.begin()); + } + + + // points + auto fnCopyPointLightRenderLists = [&](const std::vector& lightContainer, const std::vector& lightIndices) + { + for (int i = 0; i < lightIndices.size(); ++i) + { + const Light* l = &lightContainer[lightIndices[i]]; + +#if SHADOW_PASS_USE_INSTANCED_DRAW_DATA + std::array< MeshDrawData, 6>& meshDrawDataPerFace = mShadowView.shadowCubeMapMeshDrawListLookup[l]; +#else + std::array< MeshDrawList, 6>& meshListForPoints = mShadowView.shadowCubeMapMeshDrawListLookup[l]; +#endif + + for (int face = 0; face < 6; ++face) + { + for (const GameObject* pObj : mainViewShadowCasterRenderList) + { +#if SHADOW_PASS_USE_INSTANCED_DRAW_DATA + const XMMATRIX matWorld = pObj->GetTransform().WorldTransformationMatrix(); + for (MeshID meshID : pObj->GetModelData().mMeshIDs) + meshDrawDataPerFace[face].AddMeshTransformation(meshID, matWorld); +#else + meshListForPoints[face].push_back(pObj); +#endif + } + } + } + }; + + fnCopyPointLightRenderLists(mLightsStatic , shadowingLightIndices.mStaticLights.pointLightIndices); + fnCopyPointLightRenderLists(mLightsDynamic, shadowingLightIndices.mDynamicLights.pointLightIndices); + return; + } + + + + // Culling Enabled : cull mainViewShadowCasterRenderList against + // light frustums. + // + // record the light stats + stats.scene.numSpots = static_cast(shadowingLightIndices.GetLightCount(Light::ELightType::SPOT) ); + stats.scene.numPoints = static_cast(shadowingLightIndices.GetLightCount(Light::ELightType::POINT)); + + + // Cull Static Lights + mpCPUProfiler->BeginEntry("Cull_ShadowView_Point_s"); + { + const std::vector& lightIndexContainer = shadowingLightIndices.mStaticLights.pointLightIndices; + for (int i = 0; i < lightIndexContainer.size(); ++i) // point lights + { + int lightIndex = lightIndexContainer[i]; + const Light* l = &mLightsStatic[lightIndex]; + fnCullPointLightView(l, mStaticLightCache.mStaticPointLightFrustumPlanes.at(l)); + } + } + mpCPUProfiler->EndEntry(); + + mpCPUProfiler->BeginEntry("Cull_ShadowView_Spot_s"); + { + const std::vector& lightIndexContainer = shadowingLightIndices.mStaticLights.spotLightIndices; + for (int i = 0; i < lightIndexContainer.size(); ++i) // spot lights + { + int lightIndex = lightIndexContainer[i]; + const Light* l = &mLightsStatic[lightIndex]; + fnCullSpotLightView(&mLightsStatic[lightIndex], mStaticLightCache.mStaticSpotLightFrustumPlanes.at(l)); + } + } + mpCPUProfiler->EndEntry(); + + // Cull Dynamic Lights + mpCPUProfiler->BeginEntry("Cull_ShadowView_Point_d"); + for (int lightIndex : shadowingLightIndices.mDynamicLights.pointLightIndices) + { + std::array frustumPlanesPerFace = + { + mLightsDynamic[lightIndex].GetViewFrustumPlanes(static_cast(0)) + , mLightsDynamic[lightIndex].GetViewFrustumPlanes(static_cast(1)) + , mLightsDynamic[lightIndex].GetViewFrustumPlanes(static_cast(2)) + , mLightsDynamic[lightIndex].GetViewFrustumPlanes(static_cast(3)) + , mLightsDynamic[lightIndex].GetViewFrustumPlanes(static_cast(4)) + , mLightsDynamic[lightIndex].GetViewFrustumPlanes(static_cast(5)) + }; + fnCullPointLightView(&mLightsDynamic[lightIndex], frustumPlanesPerFace); + } + mpCPUProfiler->EndEntry(); + + mpCPUProfiler->BeginEntry("Cull_ShadowView_Spot_d"); + for (int lightIndex : shadowingLightIndices.mDynamicLights.spotLightIndices) + { + const Light* l = &mLightsDynamic[lightIndex]; + fnCullSpotLightView(l, l->GetViewFrustumPlanes()); + } + mpCPUProfiler->EndEntry(); +} + +void Scene::OcclusionCullDirectionalLightView() +{ + // TODO: consider this for directionals: http://stefan-s.net/?p=92 or umbra paper +} + +void Scene::BatchMainViewRenderList(const std::vector mainViewRenderList) +{ + for (int i = 0; i < mainViewRenderList.size(); ++i) + { + const GameObject* pObj = mainViewRenderList[i]; + const ModelData& model = pObj->GetModelData(); + const MeshID meshID = model.mMeshIDs.empty() ? -1 : model.mMeshIDs.front(); + + // instanced is only for built-in meshes (for now) + if (meshID >= EGeometry::MESH_TYPE_COUNT || SceneResourceView::GetMeshRenderMode(this, pObj, meshID) == MeshRenderSettings::WIREFRAME) + { + mSceneView.culledOpaqueList.push_back(std::move(mainViewRenderList[i])); + continue; + } + + const bool bMeshHasMaterial = model.mMaterialLookupPerMesh.find(meshID) != model.mMaterialLookupPerMesh.end(); + if (bMeshHasMaterial) + { + const MaterialID materialID = model.mMaterialLookupPerMesh.at(meshID); + const Material* pMat = mMaterials.GetMaterial_const(materialID); + if (pMat->HasTexture()) + { + mSceneView.culledOpaqueList.push_back(std::move(mainViewRenderList[i])); + continue; + } + } + + RenderListLookup& instancedRenderLists = mSceneView.culluedOpaqueInstancedRenderListLookup; + if (instancedRenderLists.find(meshID) == instancedRenderLists.end()) + { + instancedRenderLists[meshID] = std::vector(); + } + + std::vector& renderList = instancedRenderLists.at(meshID); + renderList.push_back(std::move(mainViewRenderList[i])); + } +} + +void Scene::BatchShadowViewRenderLists(const std::vector & mainViewShadowCasterRenderList) +{ + std::unordered_map>& instancedCasterLists = mShadowView.RenderListsPerMeshType; + + mpCPUProfiler->BeginEntry("Batch_DirectionalView"); + for (int i = 0; i < mainViewShadowCasterRenderList.size(); ++i) + { + const GameObject* pCaster = mainViewShadowCasterRenderList[i]; + const ModelData& model = pCaster->GetModelData(); + const MeshID meshID = model.mMeshIDs.empty() ? -1 : model.mMeshIDs.front(); + if (meshID >= EGeometry::MESH_TYPE_COUNT) + { + mShadowView.casters.push_back(std::move(mainViewShadowCasterRenderList[i])); + continue; + } + + if (instancedCasterLists.find(meshID) == instancedCasterLists.end()) + { + instancedCasterLists[meshID] = std::vector(); + } + std::vector& renderList = instancedCasterLists.at(meshID); + renderList.push_back(std::move(mainViewShadowCasterRenderList[i])); + } + mpCPUProfiler->EndEntry(); + +} + +void Scene::SetLightCache() +{ + mStaticLightCache.Clear(); + + // cache/set static light data + // + // static lights are assumed to not change position and rotations, + // hence, we can cache their frustum planes which are extracted + // from the light-space matrix. This cache would save us matrix + // multiplication and frustum extraction instructions during + // PreRender() - frustum cull lights phase. + // + for (Light& l : mLightsStatic) + { + l.SetMatrices(); + switch (l.mType) + { + case Light::ELightType::SPOT: + mStaticLightCache.mStaticSpotLightFrustumPlanes[&l] = l.GetViewFrustumPlanes(); + break; + case Light::ELightType::POINT: + { + std::array< FrustumPlaneset, 6> planesetPerFace; + for (int i = 0; i < 6; ++i) + planesetPerFace[i] = l.GetViewFrustumPlanes(static_cast(i)); + mStaticLightCache.mStaticPointLightFrustumPlanes[&l] = planesetPerFace; + } break; + } // l.type + } + + // cache/set dynamic light data + for (Light& l : mLightsDynamic) + l.SetMatrices(); + + + // special case for directional lights for now... + // this should eventually be processed with the + // containers above, potentially in the static one. + if (mDirectionalLight.mbEnabled) + { + mDirectionalLight.SetMatrices(); + } +} + +void Scene::ClearLights() +{ + mLightsDynamic.clear(); + mLightsStatic.clear(); + mStaticLightCache.Clear(); +} + +//static void CalculateSceneBoundingBox(Scene* pScene, ) +void Scene::CalculateSceneBoundingBox() +{ + // get the objects for the scene + std::vector pObjects; + for (GameObject& obj : mObjectPool.mObjects) + { + if (obj.mpScene == this && obj.mRenderSettings.bRender) + { + pObjects.push_back(&obj); + } + } + + constexpr float max_f = std::numeric_limits::max(); + vec3 mins(max_f); + vec3 maxs(-(max_f - 1.0f)); + PerfTimer timer; + timer.Start(); + std::for_each(RANGE(pObjects), [&](GameObject* pObj) + { + XMMATRIX worldMatrix = pObj->GetTransform().WorldTransformationMatrix(); + + vec3 mins_obj(max_f); + vec3 maxs_obj(-(max_f - 1.0f)); + + const ModelData& modelData = pObj->GetModelData(); + pObj->mMeshBoundingBoxes.clear(); + std::for_each(RANGE(modelData.mMeshIDs), [&](const MeshID& meshID) + { + const BufferID VertexBufferID = mMeshIDs[meshID].GetIABuffers().first; + const Buffer& VertexBuffer = mpRenderer->GetVertexBuffer(VertexBufferID); + const size_t numVerts = VertexBuffer.mDesc.mElementCount; + const size_t stride = VertexBuffer.mDesc.mStride; + + constexpr size_t defaultSz = sizeof(DefaultVertexBufferData); + constexpr float DegenerateMeshPositionChannelValueMax = 15000.0f; // make sure no vertex.xyz is > 15,000.0f + + // #SHADER REFACTOR: + // + // currently all the shader input is using default vertex buffer data. + // we just make sure that we can interpret the position data properly here + // by ensuring the vertex buffer stride for a given mesh matches + // the default vertex buffer. + // + // TODO: + // Type information is not preserved once the vertex/index buffer is created. + // need to figure out a way to interpret the position data in a given buffer + // + if (stride == defaultSz) + { + const DefaultVertexBufferData* pData = reinterpret_cast(VertexBuffer.mpCPUData); + if (pData == nullptr) + { + Log::Info("Nope: %d", int(stride)); + return; + } + + vec3 mins_mesh(max_f); + vec3 maxs_mesh(-(max_f - 1.0f)); + for (int i = 0; i < numVerts; ++i) + { + const float x_mesh_local = pData[i].position.x(); + const float y_mesh_local = pData[i].position.y(); + const float z_mesh_local = pData[i].position.z(); + + mins_mesh = vec3 + ( + std::min(x_mesh_local, mins_mesh.x()), + std::min(y_mesh_local, mins_mesh.y()), + std::min(z_mesh_local, mins_mesh.z()) + ); + maxs_mesh = vec3 + ( + std::max(x_mesh_local, maxs_mesh.x()), + std::max(y_mesh_local, maxs_mesh.y()), + std::max(z_mesh_local, maxs_mesh.z()) + ); + + + const vec3 worldPos = vec3(XMVector4Transform(vec4(pData[i].position, 1.0f), worldMatrix)); + const float x_mesh = std::min(worldPos.x(), DegenerateMeshPositionChannelValueMax); + const float y_mesh = std::min(worldPos.y(), DegenerateMeshPositionChannelValueMax); + const float z_mesh = std::min(worldPos.z(), DegenerateMeshPositionChannelValueMax); + + + // scene bounding box - world space + mins = vec3 + ( + std::min(x_mesh, mins.x()), + std::min(y_mesh, mins.y()), + std::min(z_mesh, mins.z()) + ); + maxs = vec3 + ( + std::max(x_mesh, maxs.x()), + std::max(y_mesh, maxs.y()), + std::max(z_mesh, maxs.z()) + ); + + // object bounding box - model space + mins_obj = vec3 + ( + std::min(x_mesh_local, mins_obj.x()), + std::min(y_mesh_local, mins_obj.y()), + std::min(z_mesh_local, mins_obj.z()) + ); + maxs_obj = vec3 + ( + std::max(x_mesh_local, maxs_obj.x()), + std::max(y_mesh_local, maxs_obj.y()), + std::max(z_mesh_local, maxs_obj.z()) + ); + } + + pObj->mMeshBoundingBoxes.push_back(BoundingBox({ mins_mesh, maxs_mesh })); + } + else + { + Log::Warning("Unsupported vertex stride for mesh."); + } + }); + + pObj->mBoundingBox.hi = maxs_obj; + pObj->mBoundingBox.low = mins_obj; + }); + + timer.Stop(); + Log::Info("SceneBoundingBox:lo=(%.2f, %.2f, %.2f)\thi=(%.2f, %.2f, %.2f) in %.2fs" + , mins.x() , mins.y() , mins.z() + , maxs.x() , maxs.y() , maxs.z() + , timer.DeltaTime() + ); + this->mSceneBoundingBox.hi = maxs; + this->mSceneBoundingBox.low = mins; +} + + + +//---------------------------------------------------------------------------------------------------------------- +// RESOURCE MANAGEMENT FUNCTIONS +//---------------------------------------------------------------------------------------------------------------- +GameObject* Scene::CreateNewGameObject(){ mpObjects.push_back(mObjectPool.Create(this)); return mpObjects.back(); } + +void Scene::AddLight(const Light& l) +{ + void (Scene::*pfnAddLight)(const Light&) = /* l.mbStatic */ true + // TODO: add boolean to Transform for specifying if its static or not + ? &Scene::AddStaticLight + : &Scene::AddDynamicLight; + (this->*pfnAddLight)(l); +} + +Material* Scene::CreateNewMaterial(EMaterialType type){ return static_cast(mMaterials.CreateAndGetMaterial(type)); } +Material* Scene::CreateRandomMaterialOfType(EMaterialType type) { return static_cast(mMaterials.CreateAndGetRandomMaterial(type)); } + + +//---------------------------------------------------------------------------------------------------------------- +// RENDER FUNCTIONS +//---------------------------------------------------------------------------------------------------------------- +int Scene::RenderOpaque(const FSceneView& sceneView) const +{ + //----------------------------------------------------------------------------------------------- + + struct ObjectMatrices_WorldSpace + { + XMMATRIX wvp; + XMMATRIX w; + XMMATRIX n; + }; + auto ShouldSendMaterial = [](EShaders shader) + { + return (shader == EShaders::FORWARD_PHONG + || shader == EShaders::UNLIT + || shader == EShaders::NORMAL + || shader == EShaders::FORWARD_BRDF); + }; + auto RenderObject = [&](const GameObject* pObj) + { + const Transform& tf = pObj->GetTransform(); + const ModelData& model = pObj->GetModelData(); + + const EShaders shader = static_cast(mpRenderer->GetActiveShader()); + const XMMATRIX world = tf.WorldTransformationMatrix(); + const XMMATRIX wvp = world * sceneView.viewProj; + + switch (shader) + { + case EShaders::TBN: + mpRenderer->SetConstant4x4f("world", world); + mpRenderer->SetConstant4x4f("viewProj", sceneView.viewProj); + mpRenderer->SetConstant4x4f("normalMatrix", tf.NormalMatrix(world)); + break; + case EShaders::NORMAL: + mpRenderer->SetConstant4x4f("normalMatrix", tf.NormalMatrix(world)); + case EShaders::UNLIT: + case EShaders::TEXTURE_COORDINATES: + mpRenderer->SetConstant4x4f("worldViewProj", wvp); + break; + default: // lighting shaders + { + const ObjectMatrices_WorldSpace mats = + { + wvp, + world, + tf.NormalMatrix(world) + }; + mpRenderer->SetConstantStruct("ObjMatrices", &mats); + break; + } + } + + // SET GEOMETRY & MATERIAL, THEN DRAW + mpRenderer->SetRasterizerState(EDefaultRasterizerState::CULL_BACK); + for (MeshID id : model.mMeshIDs) + { + const auto IABuffer = mMeshIDs[id].GetIABuffers(mLODManager.GetLODValue(pObj, id)); + + // SET MATERIAL CONSTANTS + if (ShouldSendMaterial(shader)) + { + const bool bMeshHasMaterial = model.mMaterialLookupPerMesh.find(id) != model.mMaterialLookupPerMesh.end(); + if (bMeshHasMaterial) + { + const MaterialID materialID = model.mMaterialLookupPerMesh.at(id); + const Material* pMat = mMaterials.GetMaterial_const(materialID); + // #TODO: uncomment below when transparency is implemented. + //if (pMat->IsTransparent()) // avoidable branching - perhaps keeping opaque and transparent meshes on separate vectors is better. + // return; + pMat->SetMaterialConstants(mpRenderer, shader, sceneView.bIsDeferredRendering); + } + else + { + mMaterials.GetDefaultMaterial(GGX_BRDF)->SetMaterialConstants(mpRenderer, shader, sceneView.bIsDeferredRendering); + } + } + + mpRenderer->SetVertexBuffer(IABuffer.first); + mpRenderer->SetIndexBuffer(IABuffer.second); + mpRenderer->Apply(); + mpRenderer->DrawIndexed(); + }; + }; + //----------------------------------------------------------------------------------------------- + + // RENDER NON-INSTANCED SCENE OBJECTS + // + int numObj = 0; + for (const auto* obj : mSceneView.culledOpaqueList) + { + RenderObject(obj); + ++numObj; + } + + + + return numObj; +} + +int Scene::RenderAlpha(const FSceneView & sceneView) const +{ + const ShaderID selectedShader = ENGINE->GetSelectedShader(); + const bool bSendMaterialData = ( + selectedShader == EShaders::FORWARD_PHONG + || selectedShader == EShaders::UNLIT + || selectedShader == EShaders::NORMAL + || selectedShader == EShaders::FORWARD_BRDF + ); + + int numObj = 0; + for (const auto* obj : mSceneView.alphaList) + { + obj->RenderTransparent(mpRenderer, sceneView, bSendMaterialData, mMaterials); + ++numObj; + } + return numObj; +} + +int Scene::RenderDebug(const XMMATRIX& viewProj) const +{ + const bool bRenderPointLightCues = true; + const bool bRenderSpotLightCues = true; + const bool bRenderObjectBoundingBoxes = false; + const bool bRenderMeshBoundingBoxes = false; + const bool bRenderSceneBoundingBox = true; + + const auto IABuffersCube = mMeshIDs[EGeometry::CUBE].GetIABuffers(); + const auto IABuffersSphere = mMeshIDs[EGeometry::SPHERE].GetIABuffers(); + const auto IABuffersCone = mMeshIDs[EGeometry::LIGHT_CUE_CONE].GetIABuffers(); + + XMMATRIX wvp; + + // set debug render states + mpRenderer->SetShader(EShaders::UNLIT); + mpRenderer->SetConstant3f("diffuse", LinearColor::yellow); + mpRenderer->SetConstant1f("isDiffuseMap", 0.0f); + mpRenderer->BindDepthTarget(ENGINE->GetWorldDepthTarget()); + mpRenderer->SetDepthStencilState(EDefaultDepthStencilState::DEPTH_TEST_ONLY); + mpRenderer->SetBlendState(EDefaultBlendState::DISABLED); + mpRenderer->SetRasterizerState(EDefaultRasterizerState::WIREFRAME); + mpRenderer->SetVertexBuffer(IABuffersCube.first); + mpRenderer->SetIndexBuffer(IABuffersCube.second); + + + // SCENE BOUNDING BOX + // + if (bRenderSceneBoundingBox) + { + wvp = mSceneBoundingBox.GetWorldTransformationMatrix() * viewProj; + mpRenderer->SetConstant4x4f("worldViewProj", wvp); + mpRenderer->Apply(); + mpRenderer->DrawIndexed(); + } + + // GAME OBJECT OBB & MESH BOUNDING BOXES + // + int numRenderedObjects = 0; + if (bRenderObjectBoundingBoxes) + { + std::vector pObjects( + mSceneView.opaqueList.size() + mSceneView.alphaList.size() + , nullptr + ); + std::copy(RANGE(mSceneView.opaqueList), pObjects.begin()); + std::copy(RANGE(mSceneView.alphaList), pObjects.begin() + mSceneView.opaqueList.size()); + for (const GameObject* pObj : pObjects) + { + const XMMATRIX matWorld = pObj->GetTransform().WorldTransformationMatrix(); + wvp = pObj->mBoundingBox.GetWorldTransformationMatrix() * matWorld * viewProj; +#if 1 + mpRenderer->SetConstant3f("diffuse", LinearColor::cyan); + mpRenderer->SetConstant4x4f("worldViewProj", wvp); + mpRenderer->Apply(); + mpRenderer->DrawIndexed(); +#endif + + // mesh bounding boxes (currently broken...) + if (bRenderMeshBoundingBoxes) + { + mpRenderer->SetConstant3f("diffuse", LinearColor::orange); +#if 0 + for (const MeshID meshID : pObj->mModel.mData.mMeshIDs) + { + wvp = pObj->mMeshBoundingBoxes[meshID].GetWorldTransformationMatrix() * matWorld * viewProj; + mpRenderer->SetConstant4x4f("worldViewProj", wvp); + mpRenderer->Apply(); + mpRenderer->DrawIndexed(); + } +#endif + } + } + numRenderedObjects = (int)pObjects.size(); + } + + // LIGHT VOLUMES + // + mpRenderer->SetConstant3f("diffuse", LinearColor::yellow); + + // light's transform hold Translation and Rotation data, + // Scale is used for rendering. Hence, we use another transform + // here to use mRange as the lights render scale signifying its + // radius of influence. + Transform tf; + constexpr size_t NUM_LIGHT_CONTAINERS = 2; + std::array*, NUM_LIGHT_CONTAINERS > lightContainers = + { + &mLightsStatic + , &mLightsDynamic + }; + for (int i = 0; i < NUM_LIGHT_CONTAINERS; ++i) + { + const std::vector& mLights = *lightContainers[i]; + // point lights + if (bRenderPointLightCues) + { + mpRenderer->SetVertexBuffer(IABuffersSphere.first); + mpRenderer->SetIndexBuffer(IABuffersSphere.second); + for (const Light& l : mLights) + { + if (l.mType == Light::ELightType::POINT) + { + mpRenderer->SetConstant3f("diffuse", l.mColor); + + tf.SetPosition(l.mTransform._position); + tf.SetScale(l.mRange * 0.5f); // Mesh's model space R = 2.0f, hence scale it by 0.5f... + wvp = tf.WorldTransformationMatrix() * viewProj; + mpRenderer->SetConstant4x4f("worldViewProj", wvp); + mpRenderer->Apply(); + mpRenderer->DrawIndexed(); + } + } + } + + // spot lights + if (bRenderSpotLightCues) + { + mpRenderer->SetVertexBuffer(IABuffersCone.first); + mpRenderer->SetIndexBuffer(IABuffersCone.second); + for (const Light& l : mLights) + { + if (l.mType == Light::ELightType::SPOT) + { + mpRenderer->SetConstant3f("diffuse", l.mColor); + + tf = l.mTransform; + + // reset scale as it holds the scale value for light's render mesh + tf.SetScale(1, 1, 1); + + // align with spot light's local space + tf.RotateAroundLocalXAxisDegrees(-90.0f); + + + XMMATRIX alignConeToSpotLightTransformation = XMMatrixIdentity(); + alignConeToSpotLightTransformation.r[3].m128_f32[0] = 0.0f; + alignConeToSpotLightTransformation.r[3].m128_f32[1] = -l.mRange; + alignConeToSpotLightTransformation.r[3].m128_f32[2] = 0.0f; + //tf.SetScale(1, 20, 1); + + const float coneBaseRadius = std::tanf(l.mSpotOuterConeAngleDegrees * DEG2RAD) * l.mRange; + XMMATRIX scaleConeToRange = XMMatrixIdentity(); + scaleConeToRange.r[0].m128_f32[0] = coneBaseRadius; + scaleConeToRange.r[1].m128_f32[1] = l.mRange; + scaleConeToRange.r[2].m128_f32[2] = coneBaseRadius; + + //wvp = alignConeToSpotLightTransformation * tf.WorldTransformationMatrix() * viewProj; + wvp = scaleConeToRange * alignConeToSpotLightTransformation * tf.WorldTransformationMatrix() * viewProj; + mpRenderer->SetConstant4x4f("worldViewProj", wvp); + mpRenderer->Apply(); + mpRenderer->DrawIndexed(); + } + } + } + } + + + // TODO: CAMERA FRUSTUM + // + if (mCameras.size() > 1 && mSelectedCamera != 0 && false) + { + // render camera[0]'s frustum + const XMMATRIX viewProj = mCameras[mSelectedCamera].GetViewMatrix() * mCameras[mSelectedCamera].GetProjectionMatrix(); + + auto a = FrustumPlaneset::ExtractFromMatrix(viewProj); // world space frustum plane equations + + // IA: model space camera frustum + // world matrix from camera[0] view ray + // viewProj from camera[selected] + mpRenderer->SetConstant3f("diffuse", LinearColor::orange); + + + Transform tf; + //const vec3 diag = this->hi - this->low; + //const vec3 pos = (this->hi + this->low) * 0.5f; + //tf.SetScale(diag * 0.5f); + //tf.SetPosition(pos); + XMMATRIX wvp = tf.WorldTransformationMatrix() * viewProj; + //mpRenderer->SetConstant4x4f("worldViewProj", wvp); + mpRenderer->Apply(); + mpRenderer->DrawIndexed(); + } + + mpRenderer->UnbindDepthTarget(); + mpRenderer->SetRasterizerState(EDefaultRasterizerState::CULL_NONE); + mpRenderer->Apply(); + + + return numRenderedObjects; // objects rendered +} + + +void Scene::RenderLights() const +{ + if (!this->mSceneView.bIsIBLEnabled) + return; + + mpRenderer->BeginEvent("Render Lights Pass"); + mpRenderer->SetShader(EShaders::UNLIT); + mpRenderer->SetDepthStencilState(EDefaultDepthStencilState::DEPTH_TEST_ONLY); + constexpr size_t NUM_LIGHT_CONTAINERS = 2; + std::array*, NUM_LIGHT_CONTAINERS > lightContainers = + { + &mLightsStatic + , &mLightsDynamic + }; + + for (int i = 0; i < NUM_LIGHT_CONTAINERS; ++i) + { + const std::vector& mLights = *lightContainers[i]; + for (const Light& light : mLights) + { + //if (!light._bEnabled) continue; // #BreaksRelease + + if (light.mType == Light::ELightType::DIRECTIONAL) + continue; // do not render directional lights + + const auto IABuffers = mBuiltinMeshes[light.mMeshID].GetIABuffers(); + const XMMATRIX world = light.mTransform.WorldTransformationMatrix(); + const XMMATRIX worldViewProj = world * this->mSceneView.viewProj; + const vec3 color = light.mColor.Value() * light.mBrightness; + + mpRenderer->SetVertexBuffer(IABuffers.first); + mpRenderer->SetIndexBuffer(IABuffers.second); + mpRenderer->SetConstant4x4f("worldViewProj", worldViewProj); + mpRenderer->SetConstant3f("diffuse", color); + mpRenderer->SetConstant1f("isDiffuseMap", 0.0f); + mpRenderer->Apply(); + mpRenderer->DrawIndexed(); + } + } + mpRenderer->EndEvent(); +} + + +void Scene::RenderSkybox(const XMMATRIX& viewProj) const +{ + const XMMATRIX& wvp = viewProj; + const auto IABuffers = Scene::GetGeometryVertexAndIndexBuffers(EGeometry::CUBE); + + mpRenderer->BeginEvent("Skybox Pass"); + mpRenderer->SetViewport(mpRenderer->FrameRenderTargetDimensionsAsFloat2()); + mpRenderer->SetShader(mSkybox.GetShader()); + mpRenderer->SetDepthStencilState(EDefaultDepthStencilState::DEPTH_TEST_ONLY); + mpRenderer->SetRasterizerState(EDefaultRasterizerState::CULL_NONE); + mpRenderer->SetConstant4x4f("worldViewProj", wvp); + mpRenderer->SetTexture("texSkybox", mSkybox.GetSkyboxTexture()); + //mpRenderer->SetSamplerState("samWrap", EDefaultSamplerState::WRAP_SAMPLER); + mpRenderer->SetSamplerState("samWrap", EDefaultSamplerState::LINEAR_FILTER_SAMPLER_WRAP_UVW); + mpRenderer->SetVertexBuffer(IABuffers.first); + mpRenderer->SetIndexBuffer(IABuffers.second); + mpRenderer->Apply(); + mpRenderer->DrawIndexed(); + mpRenderer->EndEvent(); +} + + +#endif \ No newline at end of file diff --git a/Source/Application/Scene.h b/Source/Application/Scene.h new file mode 100644 index 00000000..dcbab9a7 --- /dev/null +++ b/Source/Application/Scene.h @@ -0,0 +1,536 @@ +// VQEngine | DirectX11 Renderer +// Copyright(C) 2018 - Volkan Ilbeyli +// +// This program is free software : you can redistribute it and / or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program.If not, see . +// +// Contact: volkanilbeyli@gmail.com +#pragma once + +#include "Camera.h" +#include "Mesh.h" +#include "Model.h" +#include "Light.h" +#include "Transform.h" +#include "GameObject.h" + +class Input; + +// TODO: + + +#if 1 + +struct GameObjectRepresentation +{ + Transform tf; + std::string ModelName; +}; + +struct FSceneRepresentation +{ + std::string SceneName; + std::string EnvironmentMapPreset; + + std::vector Cameras; + std::vector Objects; + //std::vector Lights; + + char loadSuccess = 0; +}; + +struct FPostProcessParameters +{ + EColorSpace ContentColorSpace = EColorSpace::REC_709; + EDisplayCurve OutputDisplayCurve = EDisplayCurve::sRGB; + float DisplayReferenceBrightnessLevel = 200.0f; + int ToggleGammaCorrection = 1; +}; +struct FSceneView +{ + DirectX::XMMATRIX view; + DirectX::XMMATRIX viewProj; + DirectX::XMMATRIX viewInverse; + DirectX::XMMATRIX proj; + DirectX::XMMATRIX projInverse; + DirectX::XMMATRIX directionalLightProjection; + DirectX::XMVECTOR cameraPosition; + //bool bIsPBRLightingUsed; + //bool bIsDeferredRendering; + //bool bIsIBLEnabled; + //Settings::SceneRender sceneRenderSettings; + //EnvironmentMap environmentMap; + + FPostProcessParameters postProcess; + + + +#if 0 + // list of objects that has the renderSettings.bRender=true + RenderList opaqueList; + RenderList alphaList; + + // list of objects that fall within the main camera's view frustum + RenderList culledOpaqueList; + RenderListLookup culluedOpaqueInstancedRenderListLookup; +#endif +}; + +//---------------------------------------------------------------------------------------------------------------- +// https://en.wikipedia.org/wiki/Template_method_pattern +// https://stackoverflow.com/questions/9724371/force-calling-base-class-virtual-function +// https://isocpp.org/wiki/faq/strange-inheritance#two-strategies-for-virtuals +// template method seems like a good idea here: +// The base class takes care of the common tasks among all scenes and calls the +// customized functions of the derived classes through pure virtual functions +// In other words, the particular scene implementations will have to override those functions +// so that each scene can have custom logic as desired. Similar to how you override those functions in Unity3D/C#. +//---------------------------------------------------------------------------------------------------------------- +class Scene +{ + // Scene class contains the scene data and the logic to manipulate it. + // Scene is essentially a small part of the Engine. Writing an entire interface + // for Scene to query scene data would be a waste of time without added benefit. + // Hence VQEngine is declared a friend and has easy acess to all data to + // effectively orchestrate communication between its multiple threads. + ///friend class VQEngine; + +//---------------------------------------------------------------------------------------------------------------- +// SCENE INTERFACE +//---------------------------------------------------------------------------------------------------------------- +protected: + // Update() is called each frame before Engine::Render(). Scene-specific update logic goes here. + // + virtual void UpdateScene(float dt, FSceneView& view) = 0; + + // Scene-specific loading logic goes here + // + virtual void LoadScene(FSceneRepresentation& scene) = 0; + + // Scene-specific unloading logic goes here + // + virtual void UnloadScene() = 0; + + // Each scene has to implement scene-specific RenderUI() function. + // RenderUI() is called after post processing is finished and it is + // the last rendering workload before presenting the frame. + // + virtual void RenderSceneUI() const = 0; + +//---------------------------------------------------------------------------------------------------------------- +// ENGINE INTERFACE +//---------------------------------------------------------------------------------------------------------------- +public: + Scene(int NumFrameBuffers, const Input& input, const std::unique_ptr& pWin) + : mInput(input) + , mpWindow(pWin) + , mFrameSceneViews(NumFrameBuffers) + , mIndex_SelectedCamera(0) + , mIndex_ActiveEnvironmentMapPreset(0) + {} + + void Update(float dt, int FRAME_DATA_INDEX); + void PostUpdate(int FRAME_DATA_INDEX, int FRAME_DATA_NEXT_INDEX); + void StartLoading(FSceneRepresentation& scene); + void OnLoadComplete(); + void Unload(); // serial-only for now. maybe MT later. + void RenderUI(); + + inline const FSceneView& GetSceneView(int FRAME_DATA_INDEX) const { return mFrameSceneViews[FRAME_DATA_INDEX]; } + inline FPostProcessParameters& GetPostProcessParameters(int FRAME_DATA_INDEX) { return mFrameSceneViews[FRAME_DATA_INDEX].postProcess; } + inline const FPostProcessParameters& GetPostProcessParameters(int FRAME_DATA_INDEX) const { return mFrameSceneViews[FRAME_DATA_INDEX].postProcess; } + inline const Camera& GetActiveCamera() const { return mCameras[mIndex_SelectedCamera]; } + inline Camera& GetActiveCamera() { return mCameras[mIndex_SelectedCamera]; } +//---------------------------------------------------------------------------------------------------------------- +// SCENE DATA +//---------------------------------------------------------------------------------------------------------------- +protected: + std::vector mFrameSceneViews; + + // + // SCENE RESOURCE CONTAINERS + // + std::vector mMeshIDs; + std::vector mObjects; + std::vector mGameObjectTransforms; + std::vector mCameras; + + Light mDirectionalLight; + std::vector mLightsStatic; // stationary lights + std::vector mLightsDynamic; // moving lights + //Skybox mSkybox; + + + // + // DATA + // + BoundingBox mSceneBoundingBox; + std::vector mMeshBoundingBoxes; + std::vector mGameObjectBoundingBoxes; + + // + // SCENE STATE + // + int mIndex_SelectedCamera; + +public: + int mIndex_ActiveEnvironmentMapPreset; + //EEnvironmentMapPresets mActiveSkyboxPreset; + //Settings::SceneRender mSceneRenderSettings; + + +protected: + const Input& mInput; + const std::unique_ptr& mpWindow; + + FSceneRepresentation mSceneRepresentation; +//---------------------------------------------------------------------------------------------------------------- +// INTERNAL DATA +//---------------------------------------------------------------------------------------------------------------- +private: + //CPUProfiler* mpCPUProfiler; + //ModelLoader mModelLoader; + //GameObjectPool mObjectPool; + //MaterialPool mMaterials; + //ModelLoadQueue mModelLoadQueue; + + //BoundingBox mSceneBoundingBox; + //FSceneView mSceneView; + //ShadowView mShadowView; + +}; + +#else +#include "Settings.h" // todo: is this needed? +#include "Skybox.h" +#include "GameObjectPool.h" +#include "SceneView.h" +#include "SceneLODManager.h" + +#include +#include +#include + + +struct FSceneRepresentation; +struct FSceneView; +struct ShadowView; +struct DrawLists; + +class SceneManager; +class Renderer; +class TextRenderer; +class MaterialPool; +class CPUProfiler; + +#define DO_NOT_LOAD_SCENES 0 + +struct ModelLoadQueue +{ + std::mutex mutex; + std::unordered_map objectModelMap; + std::unordered_map> asyncModelResults; +}; + +//---------------------------------------------------------------------------------------------------------------- +// https://en.wikipedia.org/wiki/Template_method_pattern +// https://stackoverflow.com/questions/9724371/force-calling-base-class-virtual-function +// https://isocpp.org/wiki/faq/strange-inheritance#two-strategies-for-virtuals +// template method seems like a good idea here: +// base class takes care of the common tasks among all scenes and calls the +// customized functions of the derived classes through pure virtual functions +//---------------------------------------------------------------------------------------------------------------- +class Scene +{ +//---------------------------------------------------------------------------------------------------------------- +// INTERFACE FOR SCENE INSTANCES +//---------------------------------------------------------------------------------------------------------------- +protected: + + // Update() is called each frame before Engine::Render(). Scene-specific update logic goes here. + // + virtual void Update(float dt) = 0; + + // Scene-specific loading logic goes here + // + virtual void Load(FSceneRepresentation& scene) = 0; + + // Scene-specific unloading logic goes here + // + virtual void Unload() = 0; + + // Each scene has to implement scene-specific RenderUI() function. + // RenderUI() is called after post processing is finished and it is + // the last rendering workload before presenting the frame. + // + virtual void RenderUI() const = 0; + + //------------------------------------------------------------------------ + + // + // SCENE RESOURCE MANAGEMENT + // +#if 0 + // Use this function to programmatically create new objects in the scene. + // + GameObject* CreateNewGameObject(); + + // Updates the scene's bounding box boundaries. This has to be called after + // a new game object added to a scene (or after getting done adding multiple + // game objects as this needs to be called only once). + // + void CalculateSceneBoundingBox(); + + // Adds a light to the scene resources. Scene manager differentiates between + // static and dynamic (moving and non-moving) lights for optimization reasons. + // + void AddLight(const Light& l); + + // Use this function to programmatically create new lights in the scene. + // TODO: finalize design after light refactor + // + //Light* CreateNewLight(); + + // Loads an assimp model - blocks the thread until the model loads + // + Model LoadModel(const std::string& modelPath); + + // Queues a task for loading an assimp model for the GameObject* pObject + // - ModelData will be assigned when the models finish loading which is sometime + // after Load() and before Render(), it won't be immediately available. + // + void LoadModel_Async(GameObject* pObject, const std::string& modelPath); +#endif + +//---------------------------------------------------------------------------------------------------------------- +// ENGINE INTERFACE +//---------------------------------------------------------------------------------------------------------------- +public: + struct BaseSceneParams + { + VQRenderer* pRenderer = nullptr; + //TextRenderer* pTextRenderer = nullptr; + //CPUProfiler* pCPUProfiler = nullptr; + }; + Scene(const BaseSceneParams& params); + ~Scene() = default; + + + // Moves objects from FSceneRepresentation into objects vector and sets the scene pointer in objects + // + void LoadScene(FSceneRepresentation& scene, const Settings::Window& windowSettings); + + // Clears object/light containers and camera settings + // + void UnloadScene(); + + // Updates selected camera and calls overridden Update from derived scene class + // + void UpdateScene(float dt); + +#if 0 + // Prepares the scene and shadow views for culling, sorting, instanced draw lists, lights, etc. + // + void PreRender(FrameStats& stats, SceneLightingConstantBuffer & outLightingData); + + + // Renders the meshes in the scene which have materials with alpha=1.0f + // + int RenderOpaque(const FSceneView& sceneView) const; + + // Renders the transparent meshes in the scene, on a separate draw pass + // + int RenderAlpha(const FSceneView& sceneView) const; + + // Renders debugging information such as bounding boxes, wireframe meshes, etc. + // + int RenderDebug(const XMMATRIX& viewProj) const; + + void RenderLights() const; + void RenderSkybox(const XMMATRIX& viewProj) const; + + + // Use these functions to programmatically create material instances which you can add to game objects in the scene. + // + Material* CreateNewMaterial(EMaterialType type); // + Material* CreateRandomMaterialOfType(EMaterialType type); // + + // ??? + // + MeshID AddMesh_Async(Mesh m); +#endif + + // note: this function introduces plenty of header includes in many areas. + // at this point, its probably worth considering elsewhere. + ///static inline std::pair GetGeometryVertexAndIndexBuffers(EGeometry GeomEnum, int lod = 0) { return mBuiltinMeshes[GeomEnum].GetIABuffers(lod); } + + // TODO: Move all this to SceneResourceView + // Getters + // + inline const EnvironmentMap& GetEnvironmentMap() const { return mSkybox.GetEnvironmentMap(); } + inline const Camera& GetActiveCamera() const { return mCameras[mSelectedCamera]; } + inline const Settings::SceneRender& GetSceneRenderSettings() const { return mSceneRenderSettings; } + inline const std::vector& GetDynamicLights() { return mLightsDynamic; } + inline EEnvironmentMapPresets GetActiveEnvironmentMapPreset() const { return mActiveSkyboxPreset; } + inline const std::vector& GetBuiltInMeshes() const { return mBuiltinMeshes; } + + inline bool HasSkybox() const { return mSkybox.GetSkyboxTexture() != -1; } + + // Setters + // + void SetEnvironmentMap(EEnvironmentMapPresets preset); + void ResetActiveCamera(); + + +protected: + //---------------------------------------------------------------------------------------------------------------- + // SCENE DATA + //---------------------------------------------------------------------------------------------------------------- + friend class SceneResourceView; // using attorney method, alternatively can use friend function + friend class ModelLoader; + + // + // SCENE RESOURCE CONTAINERS + // + //static std::vector mBuiltinMeshes; + //static void InitializeBuiltinMeshes(); + std::vector mTransforms; + std::vector mMeshIDs; + std::vector mCameras; + std::vector mpObjects; + Light mDirectionalLight; + std::vector mLightsStatic; // non-moving lights + std::vector mLightsDynamic; // moving lights + //Skybox mSkybox; + + + // + // SCENE STATE + // + EEnvironmentMapPresets mActiveSkyboxPreset; + int mSelectedCamera; + Settings::SceneRender mSceneRenderSettings; + + + // + // SYSTEMS + // + VQRenderer* mpRenderer; + //TextRenderer* mpTextRenderer; + ThreadPool* mpThreadPool; // initialized by the Engine + LODManager mLODManager; + +private: + //---------------------------------------------------------------------------------------------------------------- + // INTERNAL DATA + //---------------------------------------------------------------------------------------------------------------- + // + // LIGHTS + // + struct ShadowingLightIndexCollection + { + inline void Clear() { spotLightIndices.clear(); pointLightIndices.clear(); } + std::vector spotLightIndices; + std::vector pointLightIndices; + }; + struct SceneShadowingLightIndexCollection + { + inline void Clear() { mStaticLights.Clear(); mDynamicLights.Clear(); } + inline size_t GetLightCount(Light::ELightType type) const + { + switch (type) + { + case Light::POINT: return mStaticLights.pointLightIndices.size() + mDynamicLights.pointLightIndices.size(); break; + case Light::SPOT : return mStaticLights.spotLightIndices.size() + mDynamicLights.spotLightIndices.size(); break; + default: return 0; + } + } + inline std::vector GetFlattenedListOfLights(const std::vector& staticLights, const std::vector& dynamicLights) const + { + std::vector pLights; + for (const int& i : mStaticLights.spotLightIndices) pLights.push_back(&staticLights[i]); + for (const int& i : mStaticLights.pointLightIndices) pLights.push_back(&staticLights[i]); + for (const int& i : mDynamicLights.spotLightIndices) pLights.push_back(&dynamicLights[i]); + for (const int& i : mDynamicLights.pointLightIndices) pLights.push_back(&dynamicLights[i]); + return pLights; + } + ShadowingLightIndexCollection mStaticLights; + ShadowingLightIndexCollection mDynamicLights; + }; + + // Static lights will not change position or orientation. Here, we cache + // some light data based on this assumption, such as frustum planes. + // + struct StaticLightCache + { + std::unordered_map> mStaticPointLightFrustumPlanes; + std::unordered_map mStaticSpotLightFrustumPlanes; + void Clear() { mStaticPointLightFrustumPlanes.clear(); mStaticSpotLightFrustumPlanes.clear(); } + }; + + StaticLightCache mStaticLightCache; + + friend class Engine; + + GameObjectPool mObjectPool; + MaterialPool mMaterials; + ModelLoader mModelLoader; + ModelLoadQueue mModelLoadQueue; + + std::mutex mSceneMeshMutex; + + + BoundingBox mSceneBoundingBox; + + + FSceneView mSceneView; + ShadowView mShadowView; + + CPUProfiler* mpCPUProfiler; + + +private: + + void StartLoadingModels(); + void EndLoadingModels(); + + void AddStaticLight(const Light& l); + void AddDynamicLight(const Light& l); + + //------------------------------- + // PreRender() ROUTINES + //------------------------------- + void SetSceneViewData(); + + void GatherSceneObjects(std::vector & mainViewShadowCasterRenderList, int& outNumSceneObjects); + void GatherLightData(SceneLightingConstantBuffer& outLightingData, const std::vector& pLightList); + + void SortRenderLists(std::vector & mainViewShadowCasterRenderList, std::vector& pShadowingLights); + + SceneShadowingLightIndexCollection CullShadowingLights(int& outNumCulledPoints, int& outNumCulledSpots); // culls lights against main view + std::vector FrustumCullMainView(int& outNumCulledObjects); + void FrustumCullPointAndSpotShadowViews(const std::vector & mainViewShadowCasterRenderList, const SceneShadowingLightIndexCollection& shadowingLightIndices, FrameStats& stats); + void OcclusionCullDirectionalLightView(); + + void BatchMainViewRenderList(const std::vector mainViewRenderList); + void BatchShadowViewRenderLists(const std::vector & mainViewShadowCasterRenderList); + //------------------------------- + + void SetLightCache(); + void ClearLights(); +}; + + + + +#endif \ No newline at end of file diff --git a/Source/Application/Settings.h b/Source/Application/Settings.h index abacb1f0..8af5a9d5 100644 --- a/Source/Application/Settings.h +++ b/Source/Application/Settings.h @@ -18,6 +18,8 @@ #pragma once +#include + enum EDisplayMode { WINDOWED = 0, @@ -60,4 +62,6 @@ struct FEngineSettings bool bAutomatedTestRun = false; int NumAutomatedTestFrames = -1; + + std::string StartupScene; }; \ No newline at end of file diff --git a/Source/Application/Types.h b/Source/Application/Types.h index f7b4a616..7e2bf04e 100644 --- a/Source/Application/Types.h +++ b/Source/Application/Types.h @@ -46,4 +46,8 @@ using CBV_ID = ID_TYPE; using RTV_ID = ID_TYPE; using DSV_ID = ID_TYPE; -using EnvironmentMapID = ID_TYPE; \ No newline at end of file +using EnvironmentMapID = ID_TYPE; +using MeshID = ID_TYPE; +using MaterialID = ID_TYPE; +using ModelID = ID_TYPE; +using TransformID = ID_TYPE; \ No newline at end of file diff --git a/Source/Application/VQEngine.h b/Source/Application/VQEngine.h index 9a68902b..0ba85594 100644 --- a/Source/Application/VQEngine.h +++ b/Source/Application/VQEngine.h @@ -27,6 +27,8 @@ #include "Transform.h" #include "Camera.h" #include "Input.h" +#include "AssetLoader.h" +#include "Scene.h" #include "Libs/VQUtils/Source/Multithreading.h" #include "Libs/VQUtils/Source/Timer.h" @@ -38,45 +40,15 @@ // Outputs Render/Update thread sync values on each Tick() #define DEBUG_LOG_THREAD_SYNC_VERBOSE 0 - // // DATA STRUCTS // -struct FPostProcessParameters -{ - EColorSpace ContentColorSpace = EColorSpace::REC_709; - EDisplayCurve OutputDisplayCurve = EDisplayCurve::sRGB; - float DisplayReferenceBrightnessLevel = 200.0f; - int ToggleGammaCorrection = 1; -}; -struct FFrameData -{ - std::array SwapChainClearColor; - - // scene - Camera SceneCamera; - Transform TFCube; - bool bCubeAnimating; - - // post process - FPostProcessParameters PPParams; -}; struct FLoadingScreenData { std::array SwapChainClearColor; - SRV_ID SRVLoadingScreen = INVALID_ID; // TODO: animation resources }; -class IWindowUpdateContext -{ -public: - HWND hwnd; - std::vector mFrameData; - std::vector mLoadingScreenData; -}; -class MainWindowSceneData : public IWindowUpdateContext{}; -class DebugWindowSceneData : public IWindowUpdateContext{}; struct FEnvironmentMapDescriptor @@ -107,13 +79,6 @@ struct FEnvironmentMap int MaxFrameAverageLightLevel = 0; }; -struct FSceneRepresentation -{ - std::string SceneName; - std::string EnvironmentMapPreset; - // TBA -}; - struct FRenderingResources{}; struct FRenderingResources_MainWindow : public FRenderingResources { @@ -207,7 +172,7 @@ class VQEngine : public IWindowOwner void RenderThread_PreRender(); // RENDER() - // - Records command lists in parallel per SceneView + // - Records command lists in parallel per FSceneView // - Submits commands to the GPU // - Presents SwapChain void RenderThread_Render(); @@ -241,7 +206,7 @@ class VQEngine : public IWindowOwner // POST_UPDATE() - // - Computes visibility per SceneView + // - Computes visibility per FSceneView void UpdateThread_PostUpdate(); @@ -255,14 +220,15 @@ class VQEngine : public IWindowOwner private: //------------------------------------------------------------------------------------------------- - using BuiltinMeshArray_t = std::array; + using BuiltinMeshArray_t = std::array; using BuiltinMeshNameArray_t = std::array; - using EnvironmentMapLookup_t = std::unordered_map; + using MeshLookup_t = std::unordered_map; + using ModelLookup_t = std::unordered_map; + using EnvironmentMapDescLookup_t = std::unordered_map; //------------------------------------------------------------------------------------------------- using EventPtr_t = std::shared_ptr; using EventQueue_t = BufferedContainer, EventPtr_t>; //------------------------------------------------------------------------------------------------- - using UpdateContextLookup_t = std::unordered_map; using RenderingResourcesLookup_t = std::unordered_map>; using WindowLookup_t = std::unordered_map>; using WindowNameLookup_t = std::unordered_map; @@ -298,24 +264,30 @@ class VQEngine : public IWindowOwner EventQueue_t mEventQueue_WinToVQE_Update; EventQueue_t mEventQueue_VQEToWin_Main; - // render VQRenderer mRenderer; + AssetLoader mAssetLoader; - // data + // data: geometry BuiltinMeshArray_t mBuiltinMeshes; - BuiltinMeshNameArray_t mBuiltinMeshNames; + MeshLookup_t mMeshes; + ModelLookup_t mModels; // contains MeshIDs and MaterialIDs + + // data: environment maps & HDR profiles std::vector mDisplayHDRProfiles; - EnvironmentMapLookup_t mLookup_EnvironmentMapDescriptors; + EnvironmentMapDescLookup_t mLookup_EnvironmentMapDescriptors; + + // data: strings + BuiltinMeshNameArray_t mBuiltinMeshNames; std::vector mEnvironmentMapPresetNames; - int mActiveEnvironmentMapPresetIndex; + std::vector mSceneNames; // state + EAppState mAppState; std::atomic mbRenderThreadInitialized; std::atomic mNumRenderLoopsExecuted; std::atomic mNumUpdateLoopsExecuted; std::atomic mbLoadingLevel; - EAppState mAppState; std::atomic mbMainWindowHDRTransitionInProgress; // see DispatchHDRSwapchainTransitionEvents() // system & settings @@ -323,11 +295,12 @@ class VQEngine : public IWindowOwner VQSystemInfo::FSystemInfo mSysInfo; // scene - MainWindowSceneData mScene_MainWnd; - DebugWindowSceneData mScene_DebugWnd; - UpdateContextLookup_t mWindowUpdateContextLookup; + FLoadingScreenData mLoadingScreenData; std::queue mQueue_SceneLoad; + int mIndex_SelectedScene; + std::unique_ptr mpScene; + #if 0 RenderingResourcesLookup_t mRenderingResources; #else @@ -335,6 +308,7 @@ class VQEngine : public IWindowOwner FRenderingResources_DebugWindow mResources_DebugWnd; #endif + // timer / profiler Timer mTimer; Timer mTimerRender; @@ -347,11 +321,12 @@ class VQEngine : public IWindowOwner private: + void InitializeInput(); void InitializeEngineSettings(const FStartupParameters& Params); void InitializeWindows(const FStartupParameters& Params); void InitializeHDRProfiles(); void InitializeEnvironmentMaps(); - void InitializeScenes(const FStartupParameters& Params); + void InitializeScenes(); void InitializeThreads(); void ExitThreads(); @@ -386,7 +361,7 @@ class VQEngine : public IWindowOwner // void TransitionForSceneRendering(FWindowRenderContext& ctx); void RenderShadowMaps(FWindowRenderContext& ctx); - void RenderSceneColor(FWindowRenderContext& ctx, const FFrameData& FrameData); + void RenderSceneColor(FWindowRenderContext& ctx, const FSceneView& SceneView); void ResolveMSAA(FWindowRenderContext& ctx); void TransitionForPostProcessing(FWindowRenderContext& ctx); void RenderPostProcess(FWindowRenderContext& ctx, const FPostProcessParameters& PPParams); @@ -404,7 +379,6 @@ class VQEngine : public IWindowOwner const std::unique_ptr& GetWindow(HWND hwnd) const; const FWindowSettings& GetWindowSettings(HWND hwnd) const; FWindowSettings& GetWindowSettings(HWND hwnd); - FFrameData& GetCurrentFrameData(HWND hwnd); const FEnvironmentMapDescriptor& GetEnvironmentMapDesc(const std::string& EnvMapName) const; @@ -426,10 +400,11 @@ class VQEngine : public IWindowOwner private: // Reads EngineSettings.ini from next to the executable and returns a // FStartupParameters struct as it readily has override booleans for engine settings - static FStartupParameters ParseEngineSettingsFile(); - static std::vector ParseEnvironmentMapsFile(); - static std::vector ParseHDRProfilesFile(); - static std::vector ParseScenesFile(); + static FStartupParameters ParseEngineSettingsFile(); + static std::vector> ParseSceneIndexMappingFile(); + static std::vector ParseEnvironmentMapsFile(); + static std::vector ParseHDRProfilesFile(); + static std::vector ParseScenesFile(); public: // Supported HDR Formats { DXGI_FORMAT_R10G10B10A2_UNORM, DXGI_FORMAT_R16G16B16A16_FLOAT } diff --git a/Source/Application/VQEngine_EventHandlers.cpp b/Source/Application/VQEngine_EventHandlers.cpp index fe616df3..41a7912d 100644 --- a/Source/Application/VQEngine_EventHandlers.cpp +++ b/Source/Application/VQEngine_EventHandlers.cpp @@ -184,21 +184,16 @@ void VQEngine::UpdateThread_HandleWindowResizeEvent(const std::shared_ptr p = std::static_pointer_cast(pEvent); - // TODO: potentially use a lookup when camera count gets larger. - // also need to take into account the array of framedata that containts the camera. - // there's only one camera for one window for now. if (p->hwnd == mpWinMain->GetHWND()) { - if (mWindowUpdateContextLookup.find(p->hwnd) != mWindowUpdateContextLookup.end()) - { - Camera& cam = GetCurrentFrameData(p->hwnd).SceneCamera; - - ProjectionMatrixParameters UpdatedProjectionMatrixParams = cam.mProjParams; - UpdatedProjectionMatrixParams.ViewporWidth = static_cast(p->width ); - UpdatedProjectionMatrixParams.ViewporHeight = static_cast(p->height); + // TODO: all cameras? + Camera& cam = mpScene->GetActiveCamera(); + + FProjectionMatrixParameters UpdatedProjectionMatrixParams = cam.mProjParams; + UpdatedProjectionMatrixParams.ViewporWidth = static_cast(p->width ); + UpdatedProjectionMatrixParams.ViewporHeight = static_cast(p->height); - cam.SetProjectionMatrix(UpdatedProjectionMatrixParams); - } + cam.SetProjectionMatrix(UpdatedProjectionMatrixParams); } } @@ -287,7 +282,7 @@ void VQEngine::RenderThread_HandleWindowResizeEvent(const std::shared_ptrGatherHDRMetaDataParameters(hwnd); if (pWnd->GetIsOnHDRCapableDisplay()) Swapchain.SetHDRMetaData(HDRMetaData); - else + else if (GetWindowSettings(hwnd).bEnableHDR) Swapchain.ClearHDRMetaData(); } Swapchain.EnsureSwapChainColorSpace(Swapchain.GetFormat() == DXGI_FORMAT_R16G16B16A16_FLOAT ? _16 : _8, false); @@ -439,7 +434,7 @@ void VQEngine::RenderThread_HandleSetVSyncEvent(const IEvent* pEvent) const FSetHDRMetaDataParams HDRMetaData = this->GatherHDRMetaDataParameters(hwnd); if (pWnd->GetIsOnHDRCapableDisplay()) Swapchain.SetHDRMetaData(HDRMetaData); - else + else if (GetWindowSettings(hwnd).bEnableHDR) Swapchain.ClearHDRMetaData(); Swapchain.EnsureSwapChainColorSpace(Swapchain.GetFormat() == DXGI_FORMAT_R16G16B16A16_FLOAT ? _16 : _8, false); } @@ -466,7 +461,7 @@ void VQEngine::RenderThread_HandleSetSwapchainFormatEvent(const IEvent* pEvent) { if (pWnd->GetIsOnHDRCapableDisplay()) Swapchain.SetHDRMetaData(HDRMetaData); - else + else if(GetWindowSettings(hwnd).bEnableHDR) Swapchain.ClearHDRMetaData(); Swapchain.EnsureSwapChainColorSpace(pSwapchainEvent->format == DXGI_FORMAT_R16G16B16A16_FLOAT? _16 : _8, false); } @@ -477,7 +472,7 @@ void VQEngine::RenderThread_HandleSetSwapchainFormatEvent(const IEvent* pEvent) const int BACK_BUFFER_INDEX = Swapchain.GetCurrentBackBufferIndex(); const EDisplayCurve OutputDisplayCurve = Swapchain.IsHDRFormat() ? EDisplayCurve::Linear : EDisplayCurve::sRGB; for (int i = 0; i < NUM_BACK_BUFFERS; ++i) - mScene_MainWnd.mFrameData[i].PPParams.OutputDisplayCurve = OutputDisplayCurve; + mpScene->GetPostProcessParameters(i).OutputDisplayCurve = OutputDisplayCurve; Log::Info("Set Swapchain Format: %s | OutputDisplayCurve: %s" , VQRenderer::DXGIFormatAsString(pSwapchainEvent->format).data() diff --git a/Source/Application/VQEngine_Main.cpp b/Source/Application/VQEngine_Main.cpp index 53f6ed06..14edad67 100644 --- a/Source/Application/VQEngine_Main.cpp +++ b/Source/Application/VQEngine_Main.cpp @@ -18,7 +18,10 @@ #include "VQEngine.h" +#include "../Scenes/Scenes.h" + #include "Libs/VQUtils/Source/utils.h" +#include "Libs/VQUtils/Libs/tinyxml2/tinyxml2.h" #include #include @@ -28,7 +31,7 @@ constexpr char* BUILD_CONFIG = "-Debug"; #else constexpr char* BUILD_CONFIG = ""; #endif -constexpr char* VQENGINE_VERSION = "v0.4.0"; +constexpr char* VQENGINE_VERSION = "v0.5.0"; static std::pair ParseLineINI(const std::string& iniLine, bool* pbSectionTag) @@ -100,10 +103,12 @@ bool VQEngine::Initialize(const FStartupParameters& Params) InitializeEngineSettings(Params); InitializeEnvironmentMaps(); InitializeHDRProfiles(); - InitializeScenes(Params); - float f2 = t.Tick(); + float f1 = t.Tick(); InitializeWindows(Params); float f3 = t.Tick(); + InitializeInput(); + InitializeScenes(); + float f2 = t.Tick(); InitializeThreads(); CalculateEffectiveFrameRate(mpWinMain->GetHWND()); float f4 = t.Tick(); @@ -123,7 +128,8 @@ bool VQEngine::Initialize(const FStartupParameters& Params) #if 0 Log::Info("[PERF] VQEngine::Initialize() : %.3fs", t2.StopGetDeltaTimeAndReset()); Log::Info("[PERF] DispatchSysInfo : %.3fs", f0); - Log::Info("[PERF] Settings : %.3fs", f2); + Log::Info("[PERF] Settings : %.3fs", f1); + Log::Info("[PERF] Scenes : %.3fs", f2); Log::Info("[PERF] Windows : %.3fs", f3); Log::Info("[PERF] Threads : %.3fs", f4); #endif @@ -140,6 +146,17 @@ void VQEngine::Exit() +void VQEngine::InitializeInput() +{ +#if ENABLE_RAW_INPUT + Input::InitRawInputDevices(mpWinMain->GetHWND()); +#endif + + // initialize input states + RegisterWindowForInput(mpWinMain); + RegisterWindowForInput(mpWinDebug); +} + void VQEngine::InitializeEngineSettings(const FStartupParameters& Params) { const FEngineSettings& p = Params.EngineSettings; @@ -168,6 +185,7 @@ void VQEngine::InitializeEngineSettings(const FStartupParameters& Params) s.bAutomatedTestRun = false; s.NumAutomatedTestFrames = 100; // default num frames to run if -Test is specified in cmd line params + s.StartupScene = "Default"; // Override #0 : from file FStartupParameters paramFile = VQEngine::ParseEngineSettingsFile(); @@ -197,13 +215,14 @@ void VQEngine::InitializeEngineSettings(const FStartupParameters& Params) s.NumAutomatedTestFrames = pf.NumAutomatedTestFrames; } + if (paramFile.bOverrideENGSetting_StartupScene) s.StartupScene = pf.StartupScene; // Override #1 : if there's command line params - if (Params.bOverrideGFXSetting_bVSync ) s.gfx.bVsync = p.gfx.bVsync; - if (Params.bOverrideGFXSetting_bAA ) s.gfx.bAntiAliasing = p.gfx.bAntiAliasing; - if (Params.bOverrideGFXSetting_bUseTripleBuffering) s.gfx.bUseTripleBuffering = p.gfx.bUseTripleBuffering; - if (Params.bOverrideGFXSetting_RenderScale) s.gfx.RenderScale = p.gfx.RenderScale; - if (Params.bOverrideGFXSetting_bMaxFrameRate) s.gfx.MaxFrameRate = p.gfx.MaxFrameRate; + if (Params.bOverrideGFXSetting_bVSync ) s.gfx.bVsync = p.gfx.bVsync; + if (Params.bOverrideGFXSetting_bAA ) s.gfx.bAntiAliasing = p.gfx.bAntiAliasing; + if (Params.bOverrideGFXSetting_bUseTripleBuffering) s.gfx.bUseTripleBuffering = p.gfx.bUseTripleBuffering; + if (Params.bOverrideGFXSetting_RenderScale) s.gfx.RenderScale = p.gfx.RenderScale; + if (Params.bOverrideGFXSetting_bMaxFrameRate) s.gfx.MaxFrameRate = p.gfx.MaxFrameRate; if (Params.bOverrideENGSetting_MainWindowWidth) s.WndMain.Width = p.WndMain.Width; if (Params.bOverrideENGSetting_MainWindowHeight) s.WndMain.Height = p.WndMain.Height; @@ -211,20 +230,20 @@ void VQEngine::InitializeEngineSettings(const FStartupParameters& Params) if (Params.bOverrideENGSetting_PreferredDisplay) s.WndMain.PreferredDisplay = p.WndMain.PreferredDisplay; if (Params.bOverrideGFXSetting_bHDR) s.WndMain.bEnableHDR = p.WndMain.bEnableHDR; - if (Params.bOverrideENGSetting_bDebugWindowEnable) s.bShowDebugWindow = p.bShowDebugWindow; - if (Params.bOverrideENGSetting_DebugWindowWidth) s.WndDebug.Width = p.WndDebug.Width; - if (Params.bOverrideENGSetting_DebugWindowHeight) s.WndDebug.Height = p.WndDebug.Height; - if (Params.bOverrideENGSetting_DebugWindowDisplayMode) s.WndDebug.DisplayMode = p.WndDebug.DisplayMode; - if (Params.bOverrideENGSetting_DebugWindowPreferredDisplay) s.WndDebug.PreferredDisplay = p.WndDebug.PreferredDisplay; + if (Params.bOverrideENGSetting_bDebugWindowEnable) s.bShowDebugWindow = p.bShowDebugWindow; + if (Params.bOverrideENGSetting_DebugWindowWidth) s.WndDebug.Width = p.WndDebug.Width; + if (Params.bOverrideENGSetting_DebugWindowHeight) s.WndDebug.Height = p.WndDebug.Height; + if (Params.bOverrideENGSetting_DebugWindowDisplayMode) s.WndDebug.DisplayMode = p.WndDebug.DisplayMode; + if (Params.bOverrideENGSetting_DebugWindowPreferredDisplay) s.WndDebug.PreferredDisplay= p.WndDebug.PreferredDisplay; - if (Params.bOverrideENGSetting_bAutomatedTest) s.bAutomatedTestRun = p.bAutomatedTestRun; + if (Params.bOverrideENGSetting_bAutomatedTest) s.bAutomatedTestRun = p.bAutomatedTestRun; if (Params.bOverrideENGSetting_bTestFrames) { s.bAutomatedTestRun = true; - s.NumAutomatedTestFrames = Params.EngineSettings.NumAutomatedTestFrames; + s.NumAutomatedTestFrames = p.NumAutomatedTestFrames; } - // TODO: parse scene to load + if (Params.bOverrideENGSetting_StartupScene) s.StartupScene = p.StartupScene; } void VQEngine::InitializeWindows(const FStartupParameters& Params) @@ -276,18 +295,54 @@ void VQEngine::InitializeEnvironmentMaps() } } -void VQEngine::InitializeScenes(const FStartupParameters& Params) +void VQEngine::InitializeScenes() { + const int NUM_SWAPCHAIN_BACKBUFFERS = mSettings.gfx.bUseTripleBuffering ? 3 : 2; + const Input& input = mInputStates.at(mpWinMain->GetHWND()); + + auto fnCreateSceneInstance = [&](const std::string& SceneType, std::unique_ptr& pScene) -> void + { + if (SceneType == "Default") pScene = std::make_unique(NUM_SWAPCHAIN_BACKBUFFERS, input, mpWinMain); + else if (SceneType == "Sponza") pScene = std::make_unique(NUM_SWAPCHAIN_BACKBUFFERS, input, mpWinMain); + }; + + + // Read Scene Index Mappings from file and initialize @mSceneNames + { + std::vector> SceneIndexMappings = VQEngine::ParseSceneIndexMappingFile(); + for (auto& nameIndex : SceneIndexMappings) + mSceneNames.push_back(std::move(nameIndex.first)); + } + // read scene files from disk: Data/Scenes/ std::vector< FSceneRepresentation> SceneReps = VQEngine::ParseScenesFile(); - auto it = std::find_if(SceneReps.begin(), SceneReps.end(), [&Params](const FSceneRepresentation& s) { return s.SceneName == Params.LevelNameToLoad; }); - const bool bSceneFound = it != SceneReps.end(); + // find out which scene to load + auto it = std::find_if(SceneReps.begin(), SceneReps.end(), [&](const FSceneRepresentation& s) { return s.SceneName == mSettings.StartupScene; }); + bool bSceneFound = it != SceneReps.end(); if (!bSceneFound) { - Log::Error("Couldn't find scene '%s' among parsed scene files. DefaultScene will be loaded", Params.LevelNameToLoad.c_str()); + Log::Error("Couldn't find scene '%s' among parsed scene files.", mSettings.StartupScene.c_str()); + Log::Warning("DefaultScene will be loaded"); + it = std::find_if(SceneReps.begin(), SceneReps.end(), [&](const FSceneRepresentation& s) { return s.SceneName == "Default"; }); + mSettings.StartupScene = "Default"; } - - mQueue_SceneLoad.push(bSceneFound ? *it : SceneReps.back()); + + // Create the scene instance + fnCreateSceneInstance(mSettings.StartupScene, mpScene); + + // queue the selected scene (@mSettings.StartupScene) for loading + assert(it != SceneReps.end()); + mQueue_SceneLoad.push(*it); + + // set the selected scene index for easily + auto it2 = std::find_if(mSceneNames.begin(), mSceneNames.end(), [&](const std::string& scn) { return scn == mSettings.StartupScene; }); + bSceneFound = it2 != mSceneNames.end(); + if (!bSceneFound) + { + Log::Error("Couldn't find scene '%s' among scene file names", mSettings.StartupScene.c_str()); + it2 = mSceneNames.begin(); + } + mIndex_SelectedScene = static_cast(it2 - mSceneNames.begin()); } void VQEngine::InitializeThreads() @@ -375,10 +430,13 @@ FWindowSettings& VQEngine::GetWindowSettings(HWND hwnd) void VQEngine::RegisterWindowForInput(const std::unique_ptr& pWnd) { - if (pWnd) + if (!pWnd) { - mInputStates.emplace(pWnd->GetHWND(), std::move(Input())); + Log::Warning("RegisterWindowForInput() called with nullptr"); + return; } + + mInputStates.emplace(pWnd->GetHWND(), std::move(Input())); } void VQEngine::UnregisterWindowForInput(const std::unique_ptr& pWnd) @@ -398,7 +456,6 @@ void VQEngine::UnregisterWindowForInput(const std::unique_ptr& pWnd) } - FStartupParameters VQEngine::ParseEngineSettingsFile() { constexpr char* ENGINE_SETTINGS_FILE_NAME = "Data/EngineSettings.ini"; @@ -522,6 +579,12 @@ FStartupParameters VQEngine::ParseEngineSettingsFile() params.bOverrideENGSetting_DebugWindowPreferredDisplay = true; params.EngineSettings.WndDebug.PreferredDisplay = StrUtil::ParseInt(SettingValue); } + + if (SettingName == "Scene") + { + params.bOverrideENGSetting_StartupScene = true; + params.EngineSettings.StartupScene = SettingValue; + } } } @@ -531,9 +594,55 @@ FStartupParameters VQEngine::ParseEngineSettingsFile() Log::Warning("Will use default settings for Engine & Graphics.", ENGINE_SETTINGS_FILE_NAME, DirectoryUtil::GetCurrentPath().c_str()); } + file.close(); + return params; } +std::vector> VQEngine::ParseSceneIndexMappingFile() +{ + constexpr char* SCENE_MAPPING_FILE_NAME = "Data/Scenes.ini"; + + std::vector> SceneIndexMappings; + + std::ifstream file(SCENE_MAPPING_FILE_NAME); + if (file.is_open()) + { + std::string line; + std::string currSection; + bool bReadingSection = false; + while (std::getline(file, line)) + { + if (line[0] == ';') continue; // skip comment lines + if (line == "") continue; // skip empty lines + + const std::pair SettingNameValuePair = ParseLineINI(line, &bReadingSection); + const std::string& SettingName = SettingNameValuePair.first; + const std::string& SettingValue = SettingNameValuePair.second; + + // Header sections; + if (bReadingSection) + { + currSection = SettingName; + continue; + } + + const int SceneIndex = StrUtil::ParseInt(SettingValue); + const std::string& SceneName = SettingName; + SceneIndexMappings.push_back(std::make_pair(SceneName, SceneIndex)); + } + } + else + { + Log::Warning("Cannot find settings file %s in current directory: %s", SCENE_MAPPING_FILE_NAME, DirectoryUtil::GetCurrentPath().c_str()); + Log::Warning("Default scene mapping will be used."); + } + + std::sort(SceneIndexMappings.begin(), SceneIndexMappings.end(), [](const auto& l, const auto& r) { return l.second < r.second; }); + + return SceneIndexMappings; +} + std::vector VQEngine::ParseEnvironmentMapsFile() { constexpr char* SETTINGS_FILE_NAME = "Data/EnvironmentMaps.ini"; @@ -657,49 +766,220 @@ std::vector VQEngine::ParseHDRProfilesFile() return HDRProfiles; } -#include "Libs/VQUtils/Libs/tinyxml2/tinyxml2.h" std::vector< FSceneRepresentation> VQEngine::ParseScenesFile() { + using namespace DirectX; using namespace tinyxml2; - constexpr char* XML_TAG_SCENE = "scene"; - constexpr char* XML_TAG_ENVIRONMENT_MAP = "environment_map"; - constexpr char* XML_TAG_ENVIRONMENT_MAP_PRESET = "preset"; + //----------------------------------------------------------------- + constexpr char* XML_TAG__SCENE = "Scene"; + constexpr char* XML_TAG__ENVIRONMENT_MAP = "EnvironmentMap"; + constexpr char* XML_TAG__ENVIRONMENT_MAP_PRESET = "Preset"; + constexpr char* XML_TAG__CAMERA = "Camera"; + constexpr char* XML_TAG__GAMEOBJECT = "GameObject"; //----------------------------------------------------------------- constexpr char* SCENE_FILES_DIRECTORY = "Data/Levels/"; //----------------------------------------------------------------- - const std::vector< std::string> SceneFiles = DirectoryUtil::ListFilesInDirectory(SCENE_FILES_DIRECTORY, ".xml"); std::vector< FSceneRepresentation> SceneRepresentations; + const std::vector< std::string> SceneFiles = DirectoryUtil::ListFilesInDirectory(SCENE_FILES_DIRECTORY, ".xml"); //----------------------------------------------------------------- + // parse vectors -------------------------------------------------- + // e.g." 0.0 9 -1.0f" -> [0.0f, 9.0f, -1.0f] + auto fnParseF3 = [](const std::string& xyz) -> XMFLOAT3 + { + XMFLOAT3 f3; + std::vector tokens = StrUtil::split(xyz, ' '); + assert(tokens.size() == 3); + f3.x = StrUtil::ParseFloat(tokens[0]); + f3.y = StrUtil::ParseFloat(tokens[1]); + f3.z = StrUtil::ParseFloat(tokens[2]); + return f3; + }; + auto fnParseF4 = [](const std::string& xyzw) -> XMFLOAT4 + { + XMFLOAT4 f4; + std::vector tokens = StrUtil::split(xyzw, ' '); + assert(tokens.size() == 4); + f4.x = StrUtil::ParseFloat(tokens[0]); + f4.y = StrUtil::ParseFloat(tokens[1]); + f4.z = StrUtil::ParseFloat(tokens[2]); + f4.w = StrUtil::ParseFloat(tokens[3]); + return f4; + }; + // parse xml elements --------------------------------------------- + auto fnParseXMLStringVal = [](XMLElement* pEle, std::string& dest) + { + XMLNode* pNode = pEle->FirstChild(); + if (pNode) + { + dest = pNode->Value(); + } + }; + auto fnParseXMLFloatVal = [](XMLElement* pEle, float& dest) + { + XMLNode* pNode = pEle->FirstChild(); + if (pNode) + { + dest = StrUtil::ParseFloat(pNode->Value()); + } + }; + auto fnParseXMLFloat3Val = [&](XMLElement* pEle, XMFLOAT3& f3) + { + XMLNode* pNode = pEle->FirstChild(); + if (pNode) + { + f3 = fnParseF3(pNode->Value()); + } + }; + auto fnParseXMLFloat4Val = [&](XMLElement* pEle, XMFLOAT4& f4) + { + XMLNode* pNode = pEle->FirstChild(); + if (pNode) + { + f4 = fnParseF4(pNode->Value()); + } + }; + // parse engine stuff ------------------------------------------- + auto fnParseTransform = [&](XMLElement* pTransform) -> Transform + { + Transform tf; + + XMLElement* pPos = pTransform->FirstChildElement("Position"); + XMLElement* pRot = pTransform->FirstChildElement("Quaternion"); + XMLElement* pScl = pTransform->FirstChildElement("Scale"); + if (pPos) fnParseXMLFloat3Val(pPos, tf._position); + if (pScl) fnParseXMLFloat3Val(pScl, tf._scale); + if (pRot) + { + XMFLOAT4 qf4; fnParseXMLFloat4Val(pRot, qf4); + tf._rotation = Quaternion(qf4.w, XMFLOAT3(qf4.x, qf4.y, qf4.z)); + } + return tf; + }; + + //----------------------------------------------------------------- + + // Start reading scene XML files for (const std::string SceneFile : SceneFiles) { - // scene rep FSceneRepresentation SceneRep = {}; - SceneRep.SceneName = DirectoryUtil::GetFileNameWithoutExtension(SceneFile); // parse XML tinyxml2::XMLDocument doc; doc.LoadFile(SceneFile.c_str()); - XMLElement* pScene = doc.FirstChildElement(XML_TAG_SCENE); + // scene name + SceneRep.SceneName = DirectoryUtil::GetFileNameWithoutExtension(SceneFile); + + + XMLElement* pScene = doc.FirstChildElement(XML_TAG__SCENE); if (pScene) { - XMLElement* pEnvMap = pScene->FirstChildElement(XML_TAG_ENVIRONMENT_MAP); - if (pEnvMap) + XMLElement* pCurrentSceneElement = pScene->FirstChildElement(); + if (!pCurrentSceneElement) + { + SceneRepresentations.push_back(SceneRep); + continue; + } + + do { - XMLElement* pPreset = pEnvMap->FirstChildElement(XML_TAG_ENVIRONMENT_MAP_PRESET); - if (pPreset) + // Environment Map + const std::string CurrEle = pCurrentSceneElement->Value(); + if (XML_TAG__ENVIRONMENT_MAP == CurrEle) { - XMLNode* pPresetVal = pPreset->FirstChild(); - if (pPresetVal) + XMLElement* pPreset = pCurrentSceneElement->FirstChildElement(XML_TAG__ENVIRONMENT_MAP_PRESET); + if (pPreset) { - SceneRep.EnvironmentMapPreset = pPresetVal->Value(); + fnParseXMLStringVal(pPreset, SceneRep.EnvironmentMapPreset); } } - } - } - // TODO: error reporting? + // Cameras + else if (XML_TAG__CAMERA == CurrEle) + { + FCameraParameters cam; + XMLElement*& pCam = pCurrentSceneElement; + + // transform + XMLElement* pPos = pCam->FirstChildElement("Position"); + XMLElement* pPitch = pCam->FirstChildElement("Pitch"); + XMLElement* pYaw = pCam->FirstChildElement("Yaw"); + + // projection + XMLElement* pProj = pCam->FirstChildElement("Projection"); + XMLElement* pFoV = pCam->FirstChildElement("FoV"); + XMLElement* pNear = pCam->FirstChildElement("Near"); + XMLElement* pFar = pCam->FirstChildElement("Far"); + + // attributes + XMLElement* pFP = pCam->FirstChildElement("FirstPerson"); + XMLElement* pTSpeed = pFP ? pFP->FirstChildElement("TranslationSpeed") : nullptr; + XMLElement* pASpeed = pFP ? pFP->FirstChildElement("AngularSpeed") : nullptr; + XMLElement* pDrag = pFP ? pFP->FirstChildElement("Drag") : nullptr; + + // transform ---------------------------------------- + if (pPos) + { + XMFLOAT3 xyz; + fnParseXMLFloat3Val(pPos, xyz); + cam.x = xyz.x; + cam.y = xyz.y; + cam.z = xyz.z; + } + if (pPitch) fnParseXMLFloatVal(pPitch, cam.Pitch); + if (pYaw) fnParseXMLFloatVal(pYaw, cam.Yaw); + + // projection---------------------------------------- + if(pProj) + { + std::string projVal; + fnParseXMLStringVal(pProj, projVal); + cam.bPerspectiveProjection = projVal == "Perspective"; + } + if(pFoV ) fnParseXMLFloatVal(pFoV, cam.FovV_Degrees); + if(pNear) fnParseXMLFloatVal(pNear, cam.NearPlane); + if(pFar ) fnParseXMLFloatVal(pFar, cam.FarPlane); + + + // attributes---------------------------------------- + if (pFP) + { + if(pTSpeed) fnParseXMLFloatVal(pTSpeed, cam.TranslationSpeed); + if(pASpeed) fnParseXMLFloatVal(pASpeed, cam.AngularSpeed); + if(pDrag ) fnParseXMLFloatVal(pDrag , cam.Drag); + } + + SceneRep.Cameras.push_back(cam); + } + + + // Game Objects + else if (XML_TAG__GAMEOBJECT == CurrEle) + { + GameObjectRepresentation obj; + + XMLElement*& pObj = pCurrentSceneElement; + XMLElement* pTransform = pObj->FirstChildElement("Transform"); + XMLElement* pModel = pObj->FirstChildElement("Model"); + + if (pTransform) + { + obj.tf = fnParseTransform(pTransform); + } + + // TODO: this is currently WIP + if (pModel) + { + //obj.ModelName + } + + SceneRep.Objects.push_back(obj); + } + + pCurrentSceneElement = pCurrentSceneElement->NextSiblingElement(); + } while (pCurrentSceneElement); + } SceneRepresentations.push_back(SceneRep); } diff --git a/Source/Application/VQEngine_Render.cpp b/Source/Application/VQEngine_Render.cpp index fccd8d5d..84d5a463 100644 --- a/Source/Application/VQEngine_Render.cpp +++ b/Source/Application/VQEngine_Render.cpp @@ -360,6 +360,8 @@ void VQEngine::RenderThread_RenderMainWindow() void VQEngine::RenderThread_RenderDebugWindow() { + // temporarily disabled +#if 0 if (mScene_DebugWnd.mFrameData.empty()) return; @@ -457,6 +459,7 @@ void VQEngine::RenderThread_RenderDebugWindow() hr = ctx.SwapChain.Present(); ctx.SwapChain.MoveToNextFrame(); //return hr; +#endif } HRESULT VQEngine::RenderThread_RenderMainWindow_LoadingScreen(FWindowRenderContext& ctx) @@ -465,8 +468,6 @@ HRESULT VQEngine::RenderThread_RenderMainWindow_LoadingScreen(FWindowRenderConte const int NUM_BACK_BUFFERS = ctx.SwapChain.GetNumBackBuffers(); const int BACK_BUFFER_INDEX = ctx.SwapChain.GetCurrentBackBufferIndex(); const int FRAME_DATA_INDEX = mNumRenderLoopsExecuted % NUM_BACK_BUFFERS; - assert(mScene_MainWnd.mLoadingScreenData.size() > 0); - const FLoadingScreenData& FrameData = mScene_MainWnd.mLoadingScreenData[FRAME_DATA_INDEX]; assert(ctx.mCommandAllocatorsGFX.size() >= NUM_BACK_BUFFERS); const bool bUseHDRRenderPath = this->ShouldRenderHDR(mpWinMain->GetHWND()); // ---------------------------------------------------------------------------- @@ -502,10 +503,10 @@ HRESULT VQEngine::RenderThread_RenderMainWindow_LoadingScreen(FWindowRenderConte CD3DX12_CPU_DESCRIPTOR_HANDLE rtvHandle = ctx.SwapChain.GetCurrentBackBufferRTVHandle(); const float clearColor[] = { - FrameData.SwapChainClearColor[0], - FrameData.SwapChainClearColor[1], - FrameData.SwapChainClearColor[2], - FrameData.SwapChainClearColor[3] + mLoadingScreenData.SwapChainClearColor[0], + mLoadingScreenData.SwapChainClearColor[1], + mLoadingScreenData.SwapChainClearColor[2], + mLoadingScreenData.SwapChainClearColor[3] }; pCmd->ClearRenderTargetView(rtvHandle, clearColor, 0, nullptr); @@ -527,7 +528,7 @@ HRESULT VQEngine::RenderThread_RenderMainWindow_LoadingScreen(FWindowRenderConte pCmd->SetGraphicsRootSignature(mRenderer.GetRootSignature(1)); pCmd->SetDescriptorHeaps(_countof(ppHeaps), ppHeaps); - pCmd->SetGraphicsRootDescriptorTable(0, mRenderer.GetShaderResourceView(FrameData.SRVLoadingScreen).GetGPUDescHandle()); + pCmd->SetGraphicsRootDescriptorTable(0, mRenderer.GetShaderResourceView(mLoadingScreenData.SRVLoadingScreen).GetGPUDescHandle()); pCmd->RSSetViewports(1, &viewport); pCmd->RSSetScissorRects(1, &scissorsRect); @@ -563,7 +564,6 @@ HRESULT VQEngine::RenderThread_RenderMainWindow_Scene(FWindowRenderContext& ctx) const int NUM_BACK_BUFFERS = ctx.SwapChain.GetNumBackBuffers(); const int BACK_BUFFER_INDEX = ctx.SwapChain.GetCurrentBackBufferIndex(); const int FRAME_DATA_INDEX = mNumRenderLoopsExecuted % NUM_BACK_BUFFERS; - const FFrameData& FrameData = mScene_MainWnd.mFrameData[FRAME_DATA_INDEX]; assert(ctx.mCommandAllocatorsGFX.size() >= NUM_BACK_BUFFERS); const bool bUseHDRRenderPath = this->ShouldRenderHDR(mpWinMain->GetHWND()); // ---------------------------------------------------------------------------- @@ -597,13 +597,13 @@ HRESULT VQEngine::RenderThread_RenderMainWindow_Scene(FWindowRenderContext& ctx) RenderShadowMaps(ctx); - RenderSceneColor(ctx, FrameData); + RenderSceneColor(ctx, mpScene->GetSceneView(FRAME_DATA_INDEX)); ResolveMSAA(ctx); TransitionForPostProcessing(ctx); - RenderPostProcess(ctx, FrameData.PPParams); + RenderPostProcess(ctx, mpScene->GetPostProcessParameters(FRAME_DATA_INDEX)); RenderUI(ctx); @@ -676,7 +676,7 @@ void VQEngine::RenderShadowMaps(FWindowRenderContext& ctx) } -void VQEngine::RenderSceneColor(FWindowRenderContext& ctx, const FFrameData& FrameData) +void VQEngine::RenderSceneColor(FWindowRenderContext& ctx, const FSceneView& SceneView) { const bool& bMSAA = mSettings.gfx.bAntiAliasing; ID3D12GraphicsCommandList*& pCmd = ctx.pCmdList_GFX; @@ -692,6 +692,8 @@ void VQEngine::RenderSceneColor(FWindowRenderContext& ctx, const FFrameData& Fra pCmd->ClearRenderTargetView(rtvHandle, clearColor, 0, nullptr); pCmd->ClearDepthStencilView(dsvHandle, DSVClearFlags, 1.0f, 0, 0, nullptr); + pCmd->OMSetRenderTargets(1, &rtvHandle, FALSE, &dsvHandle); + // Set Viewport & Scissors const float RenderResolutionX = static_cast(ctx.MainRTResolutionX); @@ -701,14 +703,14 @@ void VQEngine::RenderSceneColor(FWindowRenderContext& ctx, const FFrameData& Fra pCmd->RSSetViewports(1, &viewport); pCmd->RSSetScissorRects(1, &scissorsRect); - + pCmd->SetPipelineState(mRenderer.GetPSO(bMSAA ? EBuiltinPSOs::HELLO_WORLD_CUBE_PSO_MSAA_4 : EBuiltinPSOs::HELLO_WORLD_CUBE_PSO)); // Draw Object ----------------------------------------------- +#if 0 using namespace DirectX; const XMMATRIX mMVP = FrameData.TFCube.WorldTransformationMatrix() - * FrameData.SceneCamera.GetViewMatrix() - * FrameData.SceneCamera.GetProjectionMatrix(); + * SceneView.viewProj; ID3D12DescriptorHeap* ppHeaps[] = { mRenderer.GetDescHeap(EResourceHeapType::CBV_SRV_UAV_HEAP) }; @@ -718,11 +720,6 @@ void VQEngine::RenderSceneColor(FWindowRenderContext& ctx, const FFrameData& Fra ctx.mDynamicHeap_ConstantBuffer.AllocConstantBuffer(sizeof(FrameConstantBuffer), (void**)(&pConstBuffer), &cbAddr); pConstBuffer->matModelViewProj = mMVP; - - pCmd->OMSetRenderTargets(1, &rtvHandle, FALSE, &dsvHandle); - - pCmd->SetPipelineState(mRenderer.GetPSO(bMSAA ? EBuiltinPSOs::HELLO_WORLD_CUBE_PSO_MSAA_4 : EBuiltinPSOs::HELLO_WORLD_CUBE_PSO)); - // hardcoded root signature for now until shader reflection and rootsignature management is implemented pCmd->SetGraphicsRootSignature(mRenderer.GetRootSignature(2)); @@ -730,9 +727,6 @@ void VQEngine::RenderSceneColor(FWindowRenderContext& ctx, const FFrameData& Fra pCmd->SetGraphicsRootDescriptorTable(0, mRenderer.GetSRV(0).GetGPUDescHandle()); pCmd->SetGraphicsRootConstantBufferView(1, cbAddr); -#if 0 - DrawMesh(pCmd, mBuiltinMeshes[EBuiltInMeshes::CUBE]); -#else const Mesh& mesh = mBuiltinMeshes[EBuiltInMeshes::CUBE]; const auto VBIBIDs = mesh.GetIABufferIDs(); const uint32 NumIndices = mesh.GetNumIndices(); @@ -754,11 +748,14 @@ void VQEngine::RenderSceneColor(FWindowRenderContext& ctx, const FFrameData& Fra const bool bDrawEnvironmentMap = bHasEnvironmentMapHDRTexture && true; if (bDrawEnvironmentMap) { - Camera skyCam = FrameData.SceneCamera; + ID3D12DescriptorHeap* ppHeaps[] = { mRenderer.GetDescHeap(EResourceHeapType::CBV_SRV_UAV_HEAP) }; + + Camera skyCam = mpScene->GetActiveCamera(); skyCam.SetPosition(0, 0, 0); skyCam.UpdateViewMatrix(); - cbAddr = {}; + D3D12_GPU_VIRTUAL_ADDRESS cbAddr = {}; + FrameConstantBuffer* pConstBuffer = {}; ctx.mDynamicHeap_ConstantBuffer.AllocConstantBuffer(sizeof(FrameConstantBuffer), (void**)(&pConstBuffer), &cbAddr); pConstBuffer->matModelViewProj = skyCam.GetViewMatrix() * skyCam.GetProjectionMatrix(); @@ -771,11 +768,7 @@ void VQEngine::RenderSceneColor(FWindowRenderContext& ctx, const FFrameData& Fra pCmd->SetGraphicsRootDescriptorTable(0, mRenderer.GetSRV(mResources_MainWnd.EnvironmentMap.SRV_HDREnvironment).GetGPUDescHandle()); pCmd->SetGraphicsRootConstantBufferView(1, cbAddr); - pCmd->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST); - pCmd->IASetVertexBuffers(0, 1, &vb); - pCmd->IASetIndexBuffer(&ib); - - pCmd->DrawIndexedInstanced(NumIndices, NumInstances, 0, 0, 0); + DrawMesh(pCmd, mBuiltinMeshes[EBuiltInMeshes::CUBE]); } } diff --git a/Source/Application/VQEngine_Update.cpp b/Source/Application/VQEngine_Update.cpp index b730d5c1..7db9155e 100644 --- a/Source/Application/VQEngine_Update.cpp +++ b/Source/Application/VQEngine_Update.cpp @@ -20,6 +20,7 @@ #include "VQEngine.h" #include "Math.h" +#include "Scene.h" #include "Libs/VQUtils/Source/utils.h" @@ -66,18 +67,8 @@ void VQEngine::UpdateThread_Main() void VQEngine::UpdateThread_Inititalize() { - mActiveEnvironmentMapPresetIndex = -1; mNumUpdateLoopsExecuted.store(0); -#if ENABLE_RAW_INPUT - // initialize raw input - Input::InitRawInputDevices(mpWinMain->GetHWND()); -#endif - - // initialize input states - RegisterWindowForInput(mpWinMain); - RegisterWindowForInput(mpWinDebug); - // busy lock until render thread is initialized while (!mbRenderThreadInitialized); @@ -131,6 +122,7 @@ void VQEngine::UpdateThread_UpdateAppState(const float dt) const bool bLoadDone = NumActiveTasks == 0; if (bLoadDone) { + mpScene->OnLoadComplete(); Log::Info("Update Thread loaded, starting simulation..."); mAppState = EAppState::SIMULATING; mbLoadingLevel.store(false); @@ -158,12 +150,9 @@ void VQEngine::UpdateThread_PostUpdate() return; } - // compute visibility - - // extract scene view + mpScene->PostUpdate(FRAME_DATA_INDEX, FRAME_DATA_NEXT_INDEX); - // copy over state for next frame - mScene_MainWnd.mFrameData[FRAME_DATA_NEXT_INDEX] = mScene_MainWnd.mFrameData[FRAME_DATA_INDEX]; + // TODO: compute visibility // input post update for (auto it = mInputStates.begin(); it != mInputStates.end(); ++it) @@ -192,26 +181,11 @@ void VQEngine::UpdateThread_SignalRenderThread() // ------------------------------------------------------------------- -// temporary hardcoded initialization until scene is data driven -static FCameraData GenerateCameraInitializationParameters(const std::unique_ptr& pWin) -{ - assert(pWin); - FCameraData camData = {}; - camData.x = 0.0f; camData.y = 3.0f; camData.z = -5.0f; - camData.pitch = 15.0f; - camData.yaw = 0.0f; - camData.bPerspectiveProjection = true; - camData.fovV_Degrees = 60.0f; - camData.nearPlane = 0.01f; - camData.farPlane = 1000.0f; - camData.width = static_cast(pWin->GetWidth()); - camData.height = static_cast(pWin->GetHeight()); - return camData; -} -static void Toggle(bool& b) { b = !b; } - void VQEngine::HandleEngineInput() { + const int NUM_BACK_BUFFERS = mRenderer.GetSwapChainBackBufferCount(mpWinMain->GetHWND()); + const int FRAME_DATA_INDEX = mNumUpdateLoopsExecuted % NUM_BACK_BUFFERS; + for (decltype(mInputStates)::iterator it = mInputStates.begin(); it != mInputStates.end(); ++it) { HWND hwnd = it->first; @@ -244,29 +218,23 @@ void VQEngine::HandleEngineInput() // // Graphics Settings Controls // - if (input.IsKeyTriggered("V")) + if (pWin == mpWinMain) { - if (pWin == mpWinMain) + if (input.IsKeyTriggered("V")) { auto& SwapChain = mRenderer.GetWindowSwapChain(hwnd); mEventQueue_WinToVQE_Renderer.AddItem(std::make_shared(hwnd, !SwapChain.IsVSyncOn())); } - } - if (input.IsKeyTriggered("M")) - { - if (pWin == mpWinMain) + if (input.IsKeyTriggered("M")) { mSettings.gfx.bAntiAliasing = !mSettings.gfx.bAntiAliasing; - Log::Info("Toggle MSAA: %d", mSettings.gfx.bAntiAliasing); + Log::Info("Toggle MSAA: %d", mSettings.gfx.bAntiAliasing); } - } - if (input.IsKeyTriggered("G")) - { - if (pWin == mpWinMain) + if (input.IsKeyTriggered("G")) { - FFrameData& data = GetCurrentFrameData(mpWinMain->GetHWND()); - data.PPParams.ToggleGammaCorrection = data.PPParams.ToggleGammaCorrection == 1 ? 0 : 1; - Log::Info("Tonemapper: ApplyGamma=%d (SDR-only)", data.PPParams.ToggleGammaCorrection); + FPostProcessParameters& PPParams = mpScene->GetPostProcessParameters(FRAME_DATA_INDEX); + PPParams.ToggleGammaCorrection = PPParams.ToggleGammaCorrection == 1 ? 0 : 1; + Log::Info("Tonemapper: ApplyGamma=%d (SDR-only)", PPParams.ToggleGammaCorrection); } } } @@ -366,14 +334,6 @@ const std::string& VQEngine::GetWindowName(HWND hwnd) const return mWinNameLookup.at(hwnd); } -FFrameData& VQEngine::GetCurrentFrameData(HWND hwnd) -{ - const int NUM_BACK_BUFFERS = mRenderer.GetSwapChainBackBufferCount(hwnd); - const int FRAME_DATA_INDEX = mNumUpdateLoopsExecuted % NUM_BACK_BUFFERS; - return mWindowUpdateContextLookup.at(hwnd)->mFrameData[FRAME_DATA_INDEX]; - -} - const FEnvironmentMapDescriptor& VQEngine::GetEnvironmentMapDesc(const std::string& EnvMapName) const { static const FEnvironmentMapDescriptor DEFAULT_ENV_MAP_DESC = { "ENV_MAP_NOT_FOUND", "", 0.0f }; @@ -393,86 +353,56 @@ void VQEngine::UpdateThread_UpdateScene_MainWnd(const float dt) { std::unique_ptr& pWin = mpWinMain; HWND hwnd = pWin->GetHWND(); - FFrameData& FrameData = GetCurrentFrameData(hwnd); const Input& input = mInputStates.at(hwnd); - - // handle input - if (input.IsKeyTriggered('R')) FrameData.SceneCamera.InitializeCamera(GenerateCameraInitializationParameters(mpWinMain)); - - constexpr float CAMERA_MOVEMENT_SPEED_MULTIPLER = 0.75f; - constexpr float CAMERA_MOVEMENT_SPEED_SHIFT_MULTIPLER = 2.0f; - XMVECTOR LocalSpaceTranslation = XMVectorSet(0, 0, 0, 0); - if (input.IsKeyDown('A')) LocalSpaceTranslation += XMLoadFloat3(&LeftVector); - if (input.IsKeyDown('D')) LocalSpaceTranslation += XMLoadFloat3(&RightVector); - if (input.IsKeyDown('W')) LocalSpaceTranslation += XMLoadFloat3(&ForwardVector); - if (input.IsKeyDown('S')) LocalSpaceTranslation += XMLoadFloat3(&BackVector); - if (input.IsKeyDown('E')) LocalSpaceTranslation += XMLoadFloat3(&UpVector); - if (input.IsKeyDown('Q')) LocalSpaceTranslation += XMLoadFloat3(&DownVector); - if (input.IsKeyDown(VK_SHIFT)) LocalSpaceTranslation *= CAMERA_MOVEMENT_SPEED_SHIFT_MULTIPLER; - LocalSpaceTranslation *= CAMERA_MOVEMENT_SPEED_MULTIPLER; - - if (input.IsKeyTriggered("Space")) Toggle(FrameData.bCubeAnimating); - - constexpr float MOUSE_BUTTON_ROTATION_SPEED_MULTIPLIER = 1.0f; - if (input.IsMouseDown(Input::EMouseButtons::MOUSE_BUTTON_LEFT)) FrameData.TFCube.RotateAroundAxisRadians(ZAxis, dt * PI * MOUSE_BUTTON_ROTATION_SPEED_MULTIPLIER); - if (input.IsMouseDown(Input::EMouseButtons::MOUSE_BUTTON_RIGHT)) FrameData.TFCube.RotateAroundAxisRadians(YAxis, dt * PI * MOUSE_BUTTON_ROTATION_SPEED_MULTIPLIER); - if (input.IsMouseDown(Input::EMouseButtons::MOUSE_BUTTON_MIDDLE)) FrameData.TFCube.RotateAroundAxisRadians(XAxis, dt * PI * MOUSE_BUTTON_ROTATION_SPEED_MULTIPLIER); - - constexpr float DOUBLE_CLICK_MULTIPLIER = 4.0f; - if (input.IsMouseDoubleClick(Input::EMouseButtons::MOUSE_BUTTON_LEFT)) FrameData.TFCube.RotateAroundAxisRadians(ZAxis, dt * PI * DOUBLE_CLICK_MULTIPLIER); - if (input.IsMouseDoubleClick(Input::EMouseButtons::MOUSE_BUTTON_RIGHT)) FrameData.TFCube.RotateAroundAxisRadians(YAxis, dt * PI * DOUBLE_CLICK_MULTIPLIER); - if (input.IsMouseDoubleClick(Input::EMouseButtons::MOUSE_BUTTON_MIDDLE)) FrameData.TFCube.RotateAroundAxisRadians(XAxis, dt * PI * DOUBLE_CLICK_MULTIPLIER); - - constexpr float SCROLL_SCALE_DELTA = 1.1f; - const float CubeScale = FrameData.TFCube._scale.x; - if (input.IsMouseScrollUp() ) FrameData.TFCube.SetUniformScale(CubeScale * SCROLL_SCALE_DELTA); - if (input.IsMouseScrollDown()) FrameData.TFCube.SetUniformScale(std::max(0.5f, CubeScale / SCROLL_SCALE_DELTA)); - + const int NUM_BACK_BUFFERS = mRenderer.GetSwapChainBackBufferCount(hwnd); + const int FRAME_DATA_INDEX = mNumUpdateLoopsExecuted % NUM_BACK_BUFFERS; + + mpScene->Update(dt, FRAME_DATA_INDEX); + + auto fnBusyWaitUntilRenderThreadCatchesUp = [&]() { - while ((mNumRenderLoopsExecuted+1) != mNumUpdateLoopsExecuted); + while ((mNumRenderLoopsExecuted + 1) != mNumUpdateLoopsExecuted); }; const FEnvironmentMap& env = mResources_MainWnd.EnvironmentMap; const int NumEnvMaps = static_cast(mEnvironmentMapPresetNames.size()); + +#if 0 // TODO: there's a crash during changing environment map for some reason :( if (input.IsKeyTriggered("PageUp")) { fnBusyWaitUntilRenderThreadCatchesUp(); - mActiveEnvironmentMapPresetIndex = (mActiveEnvironmentMapPresetIndex + 1) % NumEnvMaps; + + int& ACTIVE_ENV_MAP_INDEX = mpScene->mIndex_ActiveEnvironmentMapPreset; + ACTIVE_ENV_MAP_INDEX = (ACTIVE_ENV_MAP_INDEX + 1) % NumEnvMaps; + mAppState = EAppState::LOADING; mbLoadingLevel = true; mWorkers_Load.AddTask([&]() { - LoadEnvironmentMap(mEnvironmentMapPresetNames[mActiveEnvironmentMapPresetIndex]); + LoadEnvironmentMap(mEnvironmentMapPresetNames[ACTIVE_ENV_MAP_INDEX]); }); - + } if (input.IsKeyTriggered("PageDown")) { fnBusyWaitUntilRenderThreadCatchesUp(); - mActiveEnvironmentMapPresetIndex = mActiveEnvironmentMapPresetIndex == 0 + + int& ACTIVE_ENV_MAP_INDEX = mpScene->mIndex_ActiveEnvironmentMapPreset; + ACTIVE_ENV_MAP_INDEX = ACTIVE_ENV_MAP_INDEX == 0 ? NumEnvMaps - 1 - : mActiveEnvironmentMapPresetIndex - 1; + : ACTIVE_ENV_MAP_INDEX - 1; + mAppState = EAppState::LOADING; mbLoadingLevel = true; mWorkers_Load.AddTask([&]() { - LoadEnvironmentMap(mEnvironmentMapPresetNames[mActiveEnvironmentMapPresetIndex]); + LoadEnvironmentMap(mEnvironmentMapPresetNames[ACTIVE_ENV_MAP_INDEX]); }); } - - - // update camera - FCameraInput camInput(LocalSpaceTranslation); - camInput.DeltaMouseXY = input.GetMouseDelta(); - FrameData.SceneCamera.Update(dt, camInput); - - // update scene data - if(FrameData.bCubeAnimating) - FrameData.TFCube.RotateAroundAxisRadians(YAxis, dt * 0.2f * PI); - +#endif } void VQEngine::UpdateThread_UpdateScene_DebugWnd(const float dt) @@ -481,7 +411,6 @@ void VQEngine::UpdateThread_UpdateScene_DebugWnd(const float dt) std::unique_ptr& pWin = mpWinDebug; HWND hwnd = pWin->GetHWND(); - FFrameData& FrameData = GetCurrentFrameData(hwnd); const Input& input = mInputStates.at(hwnd); @@ -493,59 +422,19 @@ void VQEngine::Load_SceneData_Dispatch() if (mQueue_SceneLoad.empty()) return; - const FSceneRepresentation SceneRep = mQueue_SceneLoad.front(); + FSceneRepresentation SceneRep = mQueue_SceneLoad.front(); mQueue_SceneLoad.pop(); - mWorkers_Load.AddTask([&]() // Load scene data - { - const int NumBackBuffer_WndMain = mRenderer.GetSwapChainBackBufferCount(mpWinMain); - const int NumBackBuffer_WndDbg = mRenderer.GetSwapChainBackBufferCount(mpWinDebug); + // let the custom scene logic edit the scene representation + mpScene->StartLoading(SceneRep); - // TODO: initialize window scene data here for now, should update this to proper location later on (Scene probably?) - FFrameData data[2]; + // start loading; + Log::Info("[Scene] Loading: %s", SceneRep.SceneName.c_str()); - // - // MAIN WINDOW DATA - // - data[0].SwapChainClearColor = { 0.07f, 0.07f, 0.07f, 1.0f }; - - // Cube Data - constexpr XMFLOAT3 CUBE_POSITION = XMFLOAT3(0, 0, 4); - constexpr float CUBE_SCALE = 3.0f; - constexpr XMFLOAT3 CUBE_ROTATION_VECTOR = XMFLOAT3(1, 1, 1); - constexpr float CUBE_ROTATION_DEGREES = 60.0f; - const XMVECTOR CUBE_ROTATION_AXIS = XMVector3Normalize(XMLoadFloat3(&CUBE_ROTATION_VECTOR)); - data[0].TFCube = Transform( - CUBE_POSITION - , Quaternion::FromAxisAngle(CUBE_ROTATION_AXIS, CUBE_ROTATION_DEGREES * DEG2RAD) - , XMFLOAT3(CUBE_SCALE, CUBE_SCALE, CUBE_SCALE) - ); - data[0].bCubeAnimating = true; - // Camera Data - FCameraData camData = GenerateCameraInitializationParameters(mpWinMain); - data[0].SceneCamera.InitializeCamera(camData); - // Post Process Data - data[0].PPParams.ContentColorSpace = EColorSpace::REC_709; - data[0].PPParams.OutputDisplayCurve = ShouldRenderHDR(mpWinMain->GetHWND()) ? EDisplayCurve::Linear : EDisplayCurve::sRGB; - data[0].PPParams.DisplayReferenceBrightnessLevel = 200.0f; - - mScene_MainWnd.mFrameData.resize(NumBackBuffer_WndMain, data[0]); - - // - // DEBUG WINDOW DATA - // - data[1].SwapChainClearColor = { 0.20f, 0.21f, 0.21f, 1.0f }; - mScene_DebugWnd.mFrameData.resize(NumBackBuffer_WndDbg, data[1]); - - mWindowUpdateContextLookup[mpWinMain->GetHWND()] = &mScene_MainWnd; - if (mpWinDebug) mWindowUpdateContextLookup[mpWinDebug->GetHWND()] = &mScene_DebugWnd; - }); - mWorkers_Load.AddTask([&, SceneRep]() // Load Environment map textures - { - Log::Info("[Scene] Loading: %s", SceneRep.SceneName.c_str()); - LoadEnvironmentMap(SceneRep.EnvironmentMapPreset); - Log::Info("[Scene] %s loaded.", SceneRep.SceneName.c_str()); - }); + if (!SceneRep.EnvironmentMapPreset.empty()) + { + mWorkers_Load.AddTask([=]() { LoadEnvironmentMap(SceneRep.EnvironmentMapPreset); }); + } } void VQEngine::LoadEnvironmentMap(const std::string& EnvMapName) @@ -574,7 +463,8 @@ void VQEngine::LoadEnvironmentMap(const std::string& EnvMapName) env.SRV_HDREnvironment = mRenderer.CreateAndInitializeSRV(env.Tex_HDREnvironment); env.MaxContentLightLevel = static_cast(desc.MaxContentLightLevel); - this->mActiveEnvironmentMapPresetIndex = static_cast(ActiveEnvMapIndex); + //assert(mpScene->mIndex_ActiveEnvironmentMapPreset == static_cast(ActiveEnvMapIndex)); // Only false durin initialization + mpScene->mIndex_ActiveEnvironmentMapPreset = static_cast(ActiveEnvMapIndex); // Update HDRMetaData when the nvironment map is loaded HWND hwnd = mpWinMain->GetHWND(); @@ -590,7 +480,7 @@ void VQEngine::LoadEnvironmentMap(const std::string& EnvMapName) void VQEngine::LoadLoadingScreenData() { - FLoadingScreenData data; + FLoadingScreenData& data = mLoadingScreenData; data.SwapChainClearColor = { 0.0f, 0.2f, 0.4f, 1.0f }; @@ -600,18 +490,5 @@ void VQEngine::LoadLoadingScreenData() TextureID texID = mRenderer.CreateTextureFromFile(LoadingScreenTextureFilePath.c_str()); SRV_ID srvID = mRenderer.CreateAndInitializeSRV(texID); data.SRVLoadingScreen = srvID; - - const int NumBackBuffer_WndMain = mRenderer.GetSwapChainBackBufferCount(mpWinMain); - mScene_MainWnd.mLoadingScreenData.resize(NumBackBuffer_WndMain, data); - - if (mpWinDebug) - { - FLoadingScreenData data; - data.SwapChainClearColor = { 0.5f, 0.4f, 0.01f, 1.0f }; - const int NumBackBuffer_WndDbg = mRenderer.GetSwapChainBackBufferCount(mpWinDebug); - mScene_DebugWnd.mLoadingScreenData.resize(NumBackBuffer_WndDbg, data); - - mWindowUpdateContextLookup[mpWinDebug->GetHWND()] = &mScene_DebugWnd; - } } diff --git a/Source/Scenes/DefaultScene.cpp b/Source/Scenes/DefaultScene.cpp new file mode 100644 index 00000000..e9b87a78 --- /dev/null +++ b/Source/Scenes/DefaultScene.cpp @@ -0,0 +1,79 @@ +#define NOMINMAX + +#include "Scenes.h" + +#include "../Application/Input.h" + +using namespace DirectX; + +static void Toggle(bool& b) { b = !b; } + + +void DefaultScene::UpdateScene(float dt, FSceneView& SceneView) +{ + // TODO: + //FFrameData& FrameData = GetCurrentFrameData(hwnd); + + // handle input + if (mInput.IsKeyTriggered('R')) + //FrameData.SceneCamera.InitializeCamera(GenerateCameraInitializationParameters(mpWinMain)); + ; // TODO: reset camera to initial stat + + constexpr float CAMERA_MOVEMENT_SPEED_MULTIPLER = 0.75f; + constexpr float CAMERA_MOVEMENT_SPEED_SHIFT_MULTIPLER = 2.0f; + XMVECTOR LocalSpaceTranslation = XMVectorSet(0, 0, 0, 0); + if (mInput.IsKeyDown('A')) LocalSpaceTranslation += XMLoadFloat3(&LeftVector); + if (mInput.IsKeyDown('D')) LocalSpaceTranslation += XMLoadFloat3(&RightVector); + if (mInput.IsKeyDown('W')) LocalSpaceTranslation += XMLoadFloat3(&ForwardVector); + if (mInput.IsKeyDown('S')) LocalSpaceTranslation += XMLoadFloat3(&BackVector); + if (mInput.IsKeyDown('E')) LocalSpaceTranslation += XMLoadFloat3(&UpVector); + if (mInput.IsKeyDown('Q')) LocalSpaceTranslation += XMLoadFloat3(&DownVector); + if (mInput.IsKeyDown(VK_SHIFT)) LocalSpaceTranslation *= CAMERA_MOVEMENT_SPEED_SHIFT_MULTIPLER; + LocalSpaceTranslation *= CAMERA_MOVEMENT_SPEED_MULTIPLER; + +#if 0 + if (mInput.IsKeyTriggered("Space")) Toggle(FrameData.bCubeAnimating); + + constexpr float MOUSE_BUTTON_ROTATION_SPEED_MULTIPLIER = 1.0f; + if (mInput.IsMouseDown(Input::EMouseButtons::MOUSE_BUTTON_LEFT)) FrameData.TFCube.RotateAroundAxisRadians(ZAxis, dt * PI * MOUSE_BUTTON_ROTATION_SPEED_MULTIPLIER); + if (mInput.IsMouseDown(Input::EMouseButtons::MOUSE_BUTTON_RIGHT)) FrameData.TFCube.RotateAroundAxisRadians(YAxis, dt * PI * MOUSE_BUTTON_ROTATION_SPEED_MULTIPLIER); + if (mInput.IsMouseDown(Input::EMouseButtons::MOUSE_BUTTON_MIDDLE)) FrameData.TFCube.RotateAroundAxisRadians(XAxis, dt * PI * MOUSE_BUTTON_ROTATION_SPEED_MULTIPLIER); + + constexpr float DOUBLE_CLICK_MULTIPLIER = 4.0f; + if (mInput.IsMouseDoubleClick(Input::EMouseButtons::MOUSE_BUTTON_LEFT)) FrameData.TFCube.RotateAroundAxisRadians(ZAxis, dt * PI * DOUBLE_CLICK_MULTIPLIER); + if (mInput.IsMouseDoubleClick(Input::EMouseButtons::MOUSE_BUTTON_RIGHT)) FrameData.TFCube.RotateAroundAxisRadians(YAxis, dt * PI * DOUBLE_CLICK_MULTIPLIER); + if (mInput.IsMouseDoubleClick(Input::EMouseButtons::MOUSE_BUTTON_MIDDLE)) FrameData.TFCube.RotateAroundAxisRadians(XAxis, dt * PI * DOUBLE_CLICK_MULTIPLIER); + + constexpr float SCROLL_SCALE_DELTA = 1.1f; + const float CubeScale = FrameData.TFCube._scale.x; + if (mInput.IsMouseScrollUp()) FrameData.TFCube.SetUniformScale(CubeScale * SCROLL_SCALE_DELTA); + if (mInput.IsMouseScrollDown()) FrameData.TFCube.SetUniformScale(std::max(0.5f, CubeScale / SCROLL_SCALE_DELTA)); +#endif + + + + // update camera + FCameraInput camInput(LocalSpaceTranslation); + camInput.DeltaMouseXY = mInput.GetMouseDelta(); + mCameras[mIndex_SelectedCamera].Update(dt, camInput); + +#if 0 + // update scene data + if (FrameData.bCubeAnimating) + FrameData.TFCube.RotateAroundAxisRadians(YAxis, dt * 0.2f * PI); +#endif +} + +void DefaultScene::LoadScene(FSceneRepresentation& scene) +{ + +} + +void DefaultScene::UnloadScene() +{ +} + +void DefaultScene::RenderSceneUI() const +{ +} + diff --git a/Source/Scenes/Scenes.h b/Source/Scenes/Scenes.h new file mode 100644 index 00000000..d7f898b1 --- /dev/null +++ b/Source/Scenes/Scenes.h @@ -0,0 +1,39 @@ +// TBA + +#include "../Application/Scene.h" + +#pragma once + +#define DECLARE_SCENE_INTERFACE()\ +protected:\ + void UpdateScene(float dt, FSceneView& SceneView) override;\ + void LoadScene(FSceneRepresentation& scene) override;\ + void UnloadScene() override;\ + void RenderSceneUI() const override;\ + +#define DECLARE_CTOR(TypeName)\ +public:\ + TypeName(int NumFrameBuffers\ + , const Input& input\ + , const std::unique_ptr& pWin\ + )\ + : Scene(NumFrameBuffers, input, pWin)\ + {}\ + + +class DefaultScene : public Scene +{ + DECLARE_SCENE_INTERFACE() + DECLARE_CTOR(DefaultScene) + +private: + GameObject* pObject = nullptr; + bool bObjectAnimation = false; +}; + +class SponzaScene : public Scene +{ + DECLARE_SCENE_INTERFACE() + + DECLARE_CTOR(SponzaScene) +}; \ No newline at end of file diff --git a/Source/Scenes/Sponza.cpp b/Source/Scenes/Sponza.cpp new file mode 100644 index 00000000..ed81f40d --- /dev/null +++ b/Source/Scenes/Sponza.cpp @@ -0,0 +1,18 @@ +#include "Scenes.h" + +void SponzaScene::UpdateScene(float dt, FSceneView& SceneView) +{ + +} + +void SponzaScene::LoadScene(FSceneRepresentation& scene) +{ +} + +void SponzaScene::UnloadScene() +{ +} + +void SponzaScene::RenderSceneUI() const +{ +} \ No newline at end of file From 4bdd39a5f37b3bcf85e7c9586815a436c72bc6b5 Mon Sep 17 00:00:00 2001 From: Volkan Date: Fri, 14 Aug 2020 14:34:50 -0700 Subject: [PATCH 03/67] Fix update thread synchronization: WaitForRenderThread() at the beginning of the loop instead of at the end --- Source/Application/VQEngine_Update.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Source/Application/VQEngine_Update.cpp b/Source/Application/VQEngine_Update.cpp index 7db9155e..60fcc0e5 100644 --- a/Source/Application/VQEngine_Update.cpp +++ b/Source/Application/VQEngine_Update.cpp @@ -42,6 +42,8 @@ void VQEngine::UpdateThread_Main() float dt = 0.0f; while (!mbStopAllThreads && !bQuit) { + UpdateThread_WaitForRenderThread(); + UpdateThread_HandleEvents(); UpdateThread_PreUpdate(dt); @@ -57,8 +59,6 @@ void VQEngine::UpdateThread_Main() ++mNumUpdateLoopsExecuted; UpdateThread_SignalRenderThread(); - - UpdateThread_WaitForRenderThread(); } UpdateThread_Exit(); From b1396283611c59b1600317800b01f964c35e962c Mon Sep 17 00:00:00 2001 From: Volkan Date: Sat, 15 Aug 2020 15:43:52 -0700 Subject: [PATCH 04/67] Fix warnings --- Source/Application/Scene.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Source/Application/Scene.cpp b/Source/Application/Scene.cpp index 267fe004..8fe50b94 100644 --- a/Source/Application/Scene.cpp +++ b/Source/Application/Scene.cpp @@ -58,8 +58,8 @@ void Scene::StartLoading(FSceneRepresentation& scene) // initialize cameras for (FCameraParameters& param : scene.Cameras) { - param.Width = mpWindow->GetWidth(); - param.Height = mpWindow->GetHeight(); + param.Width = static_cast( mpWindow->GetWidth() ); + param.Height = static_cast( mpWindow->GetHeight() ); Camera c; c.InitializeCamera(param); From 0dba229e32c8098a1333581b4f5a8830fd72ecca Mon Sep 17 00:00:00 2001 From: Volkan Date: Sun, 16 Aug 2020 13:48:17 -0700 Subject: [PATCH 05/67] Memory Pool, Game Object Deserialization --- CMakeLists.txt | 2 + Libs/VQUtils | 2 +- Source/Application/GameObject.h | 5 +- Source/Application/Memory.cpp | 21 +++ Source/Application/Memory.h | 203 +++++++++++++++++++++++++ Source/Application/Mesh.cpp | 11 ++ Source/Application/Mesh.h | 2 + Source/Application/Scene.cpp | 70 ++++++++- Source/Application/Scene.h | 54 +++++-- Source/Application/VQEngine.h | 8 + Source/Application/VQEngine_Main.cpp | 24 ++- Source/Application/VQEngine_Update.cpp | 35 ++++- Source/Scenes/Scenes.h | 7 +- 13 files changed, 413 insertions(+), 31 deletions(-) create mode 100644 Source/Application/Memory.cpp create mode 100644 Source/Application/Memory.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 71c4f9ed..7b1ef1e8 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -60,6 +60,7 @@ set (HeaderVQE "Source/Application/Scene.h" "Source/Application/Light.h" "Source/Application/GameObject.h" + "Source/Application/Memory.h" ) set (SourceVQE @@ -84,6 +85,7 @@ set (SourceVQE "Source/Application/Scene.cpp" "Source/Application/Light.cpp" "Source/Application/GameObject.cpp" + "Source/Application/Memory.cpp" ) # ouput exe to bin directory diff --git a/Libs/VQUtils b/Libs/VQUtils index 494af9b6..8e046ab3 160000 --- a/Libs/VQUtils +++ b/Libs/VQUtils @@ -1 +1 @@ -Subproject commit 494af9b63350a594f8c8b009baf89df15c1692b5 +Subproject commit 8e046ab3335d151c86311321dd8c58c7dab69d54 diff --git a/Source/Application/GameObject.h b/Source/Application/GameObject.h index 99328d05..9ac2ffbf 100644 --- a/Source/Application/GameObject.h +++ b/Source/Application/GameObject.h @@ -25,8 +25,9 @@ struct BoundingBox {}; class GameObject { - TransformID mTransformID; - ModelID mModelID; +public: + TransformID mTransformID = INVALID_ID; + ModelID mModelID = INVALID_ID; // Todo: move to scene and rename to @BoundingBoxes_GameObjects; BoundingBox mBoundingBox; diff --git a/Source/Application/Memory.cpp b/Source/Application/Memory.cpp new file mode 100644 index 00000000..7d3d1a20 --- /dev/null +++ b/Source/Application/Memory.cpp @@ -0,0 +1,21 @@ +// VQE +// Copyright(C) 2020 - Volkan Ilbeyli +// +// This program is free software : you can redistribute it and / or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program.If not, see . +// +// Contact: volkanilbeyli@gmail.com +#pragma once + +#include "Memory.h" + diff --git a/Source/Application/Memory.h b/Source/Application/Memory.h new file mode 100644 index 00000000..e823c978 --- /dev/null +++ b/Source/Application/Memory.h @@ -0,0 +1,203 @@ +// VQE +// Copyright(C) 2020 - Volkan Ilbeyli +// +// This program is free software : you can redistribute it and / or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program.If not, see . +// +// Contact: volkanilbeyli@gmail.com +#pragma once + +// +// Resources on memory management +// +// - http://allenchou.net/memory-management-series/ +// - https://www.gamasutra.com/blogs/MichaelKissner/20151104/258271/Writing_a_Game_Engine_from_Scratch__Part_2_Memory.php +// - https://gamasutra.com/blogs/MichaelKissner/20151120/259561/Writing_a_Game_Engine_from_Scratch__Part_3_Data__Cache.php +// - http://dmitrysoshnikov.com/compilers/writing-a-memory-allocator/ +// - http://dmitrysoshnikov.com/compilers/writing-a-pool-allocator/ +// - https://blog.molecular-matters.com/2012/09/17/memory-allocation-strategies-a-pool-allocator/ +// + +// http://dmitrysoshnikov.com/compilers/writing-a-memory-allocator/ +inline constexpr size_t AlignTo(size_t size, size_t alignment = 64) +{ + return (size + alignment - 1) & ~(alignment - 1); +} + +#define MEMORY_POOL__ENABLE_DEBUG_LOG 1 +#define MEMORY_POOL__LOG_VERBOSE 0 +#if MEMORY_POOL__ENABLE_DEBUG_LOG +#include "../../Libs/VQUtils/Source/Log.h" +#include "../../Libs/VQUtils/Source/utils.h" +#endif + + +// +// MEMORY POOL +// +template +class MemoryPool +{ +public: + MemoryPool(size_t NumBlocks, size_t Alignment); + ~MemoryPool(); + + TObject* Allocate(size_t NumBlocks = 1); + void Free(void* pBlock); + + +#if MEMORY_POOL__ENABLE_DEBUG_LOG + void PrintDebugInfo() const; +#endif +private: + struct Block { Block* pNext; }; + + // memory + Block* mpNextFreeBlock = nullptr; + void* mpAlloc = nullptr; + + // header + size_t mNumBlocks = 0; + size_t mNumUsedBlocks = 0; + size_t mAllocSize = 0; +}; + + + + +// +// MemoryPool Template Implementation +// +template +inline MemoryPool::MemoryPool(size_t NumBlocks, size_t Alignment) + : mNumBlocks(NumBlocks) +{ + // calc alloc size + const size_t AlignedObjSize = AlignTo(sizeof(TObject), Alignment); + const size_t AllocSize = AlignedObjSize * NumBlocks; + + // alloc mem + this->mpNextFreeBlock = reinterpret_cast(malloc(AllocSize)); +#if MEMORY_POOL__ENABLE_DEBUG_LOG + if (!this->mpNextFreeBlock) Log::Error("MemoryPool(NumBlocks=%d, Alignment=%d): malloc() failed", NumBlocks, Alignment); +#endif + assert(this->mpNextFreeBlock); + this->mpAlloc = this->mpNextFreeBlock; + this->mAllocSize = AllocSize; + + // setup list structure + Block* pWalk = this->mpNextFreeBlock; + Block* pNextBlock = (Block*)(((unsigned char*)this->mpNextFreeBlock) + AlignedObjSize); + for (size_t i = 1; i < NumBlocks; ++i) + { + if (i == NumBlocks - 1) + { + pWalk->pNext = nullptr; + break; + } + pWalk->pNext = pNextBlock; + pWalk = pNextBlock; + pNextBlock = (Block*)((unsigned char*)(pNextBlock) + AlignedObjSize); + } + + +#if MEMORY_POOL__ENABLE_DEBUG_LOG + Log::Info("MemoryPool: Created pool w/ ObjectSize=%s, Alignment=%s, AlignedObjectSize=%s, NumBlocks=%d, AllocSize=%s, mpAlloc=0x%x" + , StrUtil::FormatByte(sizeof(TObject)).c_str() + , StrUtil::FormatByte(Alignment).c_str() + , StrUtil::FormatByte(AlignedObjSize).c_str() + , NumBlocks + , StrUtil::FormatByte(AllocSize).c_str() + , mpAlloc + ); + PrintDebugInfo(); +#endif +} + +template +inline MemoryPool::~MemoryPool() +{ + if (mNumUsedBlocks != 0) + { + Log::Warning("~MemoryPool() : mNumUsedBlocks != 0, did you Free() all allocated objects from the Scene?"); + + // if you hit this, Scene has 'leaked' memory. + // The application will still deallocate the memory and won't really leak, + // but the pointers that weren't freed will be dangling. + ///assert(mNumUsedBlocks == 0); + } + + if (mpAlloc) + free(mpAlloc); +} + +template +inline TObject* MemoryPool::Allocate(size_t NumBlocks) +{ + // TODO: alloc NumBlocks? + //for (size_t i = 0; i < NumBlocks; ++i) + //{ + // ; + //} + + if (!mpNextFreeBlock) + { + assert(this->mNumUsedBlocks == this->mNumBlocks); + Log::Error("MemoryPool is out of memory"); + assert(mpNextFreeBlock); // if you hit this, allocate a bigger pool on startup + } + + ++this->mNumUsedBlocks; + + // only alloc 1 for now + TObject* pNewObj = (TObject*)mpNextFreeBlock; + mpNextFreeBlock = mpNextFreeBlock->pNext; + return pNewObj; +} + +template +inline void MemoryPool::Free(void* pBlock) +{ + assert(pBlock); + Block* pMem = (Block*)pBlock; + pMem->pNext = this->mpNextFreeBlock; + this->mpNextFreeBlock = pMem; + --this->mNumUsedBlocks; +} + + +#if MEMORY_POOL__ENABLE_DEBUG_LOG +template +inline void MemoryPool::PrintDebugInfo() const +{ + Log::Info("-----------------"); + Log::Info("Memory Pool"); + Log::Info("Allocation Size : %s", StrUtil::FormatByte(this->mAllocSize).c_str()); + Log::Info("Total # Blocks : %d", this->mNumBlocks); + Log::Info("Used # Blocks : %d", this->mNumUsedBlocks); + Log::Info("Next Available : 0x%x %s", this->mpNextFreeBlock, (this->mpNextFreeBlock == this->mpAlloc ? "(HEAD)" : "")); + Log::Info("-----------------"); +#if MEMORY_POOL__LOG_VERBOSE + size_t iBlock = 0; + Block* pWalk = mpNextFreeBlock; + while (pWalk) + { + Log::Info("[%d] 0x%x", iBlock, pWalk); + + ++iBlock; + pWalk = pWalk->pNext; + } + Log::Info("-----------------"); +#endif +} +#endif \ No newline at end of file diff --git a/Source/Application/Mesh.cpp b/Source/Application/Mesh.cpp index 09ff23e6..3bdbcf84 100644 --- a/Source/Application/Mesh.cpp +++ b/Source/Application/Mesh.cpp @@ -25,6 +25,17 @@ #endif +EBuiltInMeshes Mesh::GetBuiltInMeshType(const std::string& MeshTypeStr) +{ + static std::unordered_map MESH_TYPE_LOOKUP = + { + { "Cube", EBuiltInMeshes::CUBE } + , { "Triangle", EBuiltInMeshes::TRIANGLE } + // TODO + }; + return MESH_TYPE_LOOKUP.at(MeshTypeStr); +} + std::pair Mesh::GetIABufferIDs(int lod /*= 0*/) const { assert(mLODBufferPairs.size() > 0); // maybe no assert and return <-1, -1> ? diff --git a/Source/Application/Mesh.h b/Source/Application/Mesh.h index 6143ddcf..44cd9675 100644 --- a/Source/Application/Mesh.h +++ b/Source/Application/Mesh.h @@ -35,6 +35,7 @@ enum EBuiltInMeshes NUM_BUILTIN_MESHES }; + struct VertexIndexBufferIDPair @@ -64,6 +65,7 @@ struct MeshLODData struct Mesh { public: + static EBuiltInMeshes GetBuiltInMeshType(const std::string& MeshTypeStr); // // Constructors / Operators // diff --git a/Source/Application/Scene.cpp b/Source/Application/Scene.cpp index 8fe50b94..866f6d45 100644 --- a/Source/Application/Scene.cpp +++ b/Source/Application/Scene.cpp @@ -20,6 +20,7 @@ #include "Scene.h" #include "Window.h" +#include "VQEngine.h" using namespace DirectX; @@ -50,12 +51,68 @@ void Scene::PostUpdate(int FRAME_DATA_INDEX, int FRAME_DATA_NEXT_INDEX) void Scene::StartLoading(FSceneRepresentation& scene) { + constexpr bool B_LOAD_SERIAL = true; + // scene-specific load this->LoadScene(scene); + // GAME OBJECTS + auto fnDeserializeGameObject = [&](GameObjectRepresentation& ObjRep) + { + // Transform + Transform* pTransform = mTransformPool.Allocate(1); + *pTransform = std::move(ObjRep.tf); + mpTransforms.push_back(pTransform); + + TransformID tID = static_cast(mpTransforms.size() - 1); + + // Model + const bool bModelIsBuiltinMesh = !ObjRep.BuiltinMeshName.empty(); + const bool bModelIsLoadedFromFile = !ObjRep.ModelFilePath.empty(); + assert(bModelIsBuiltinMesh != bModelIsLoadedFromFile); + + ModelID mID = INVALID_ID; + if (bModelIsBuiltinMesh) + { + // create model + mID = mEngine.CreateModel(); + Model& model = mEngine.GetModel(mID); + + // create/get mesh + MeshID meshID = mEngine.GetBuiltInMeshID(ObjRep.BuiltinMeshName); + model.mData.mMeshIDs.push_back(meshID); + + // TODO: material + } + else + { + // TODO: load/create model? + //ObjRep.ModelName; // TODO + } + + + // GameObject + GameObject* pObj = mGameObjectPool.Allocate(1); + pObj->mTransformID = tID; + pObj->mModelID = mID; + mpObjects.push_back(pObj); + }; + + if constexpr (B_LOAD_SERIAL) + { + for (GameObjectRepresentation& ObjRep : scene.Objects) + { + fnDeserializeGameObject(ObjRep); + } + } + // dispatch workers + else + { + assert(false); // TODO + } - // initialize cameras + // CAMERAS for (FCameraParameters& param : scene.Cameras) { param.Width = static_cast( mpWindow->GetWidth() ); @@ -84,9 +141,14 @@ void Scene::Unload() mFrameSceneViews.clear(); mFrameSceneViews.resize(sz); - mMeshIDs.clear(); - mObjects.clear(); - mGameObjectTransforms.clear(); + //mMeshIDs.clear(); + + for (Transform* pTf : mpTransforms) mTransformPool.Free(pTf); + mpTransforms.clear(); + + for (GameObject* pObj : mpObjects) mGameObjectPool.Free(pObj); + mpObjects.clear(); + mCameras.clear(); mDirectionalLight = {}; diff --git a/Source/Application/Scene.h b/Source/Application/Scene.h index dcbab9a7..d88a830b 100644 --- a/Source/Application/Scene.h +++ b/Source/Application/Scene.h @@ -23,6 +23,7 @@ #include "Light.h" #include "Transform.h" #include "GameObject.h" +#include "Memory.h" class Input; @@ -34,7 +35,12 @@ class Input; struct GameObjectRepresentation { Transform tf; + std::string ModelName; + std::string ModelFilePath; + + std::string BuiltinMeshName; + struct Material { float data[16]; }; }; struct FSceneRepresentation @@ -86,6 +92,10 @@ struct FSceneView #endif }; + +constexpr size_t NUM_GAMEOBJECT_POOL_SIZE = 4096; +constexpr size_t GAMEOBJECT_BYTE_ALIGNMENT = 64; // assumed typical cache-line size + //---------------------------------------------------------------------------------------------------------------- // https://en.wikipedia.org/wiki/Template_method_pattern // https://stackoverflow.com/questions/9724371/force-calling-base-class-virtual-function @@ -103,7 +113,7 @@ class Scene // for Scene to query scene data would be a waste of time without added benefit. // Hence VQEngine is declared a friend and has easy acess to all data to // effectively orchestrate communication between its multiple threads. - ///friend class VQEngine; + friend class VQEngine; //---------------------------------------------------------------------------------------------------------------- // SCENE INTERFACE @@ -131,14 +141,18 @@ class Scene // ENGINE INTERFACE //---------------------------------------------------------------------------------------------------------------- public: - Scene(int NumFrameBuffers, const Input& input, const std::unique_ptr& pWin) + Scene(VQEngine& engine, int NumFrameBuffers, const Input& input, const std::unique_ptr& pWin) : mInput(input) , mpWindow(pWin) + , mEngine(engine) , mFrameSceneViews(NumFrameBuffers) , mIndex_SelectedCamera(0) , mIndex_ActiveEnvironmentMapPreset(0) + , mGameObjectPool(NUM_GAMEOBJECT_POOL_SIZE, GAMEOBJECT_BYTE_ALIGNMENT) + , mTransformPool(NUM_GAMEOBJECT_POOL_SIZE, GAMEOBJECT_BYTE_ALIGNMENT) {} +private: // Derived Scenes shouldn't access these functions void Update(float dt, int FRAME_DATA_INDEX); void PostUpdate(int FRAME_DATA_INDEX, int FRAME_DATA_NEXT_INDEX); void StartLoading(FSceneRepresentation& scene); @@ -146,11 +160,16 @@ class Scene void Unload(); // serial-only for now. maybe MT later. void RenderUI(); +public: inline const FSceneView& GetSceneView(int FRAME_DATA_INDEX) const { return mFrameSceneViews[FRAME_DATA_INDEX]; } inline FPostProcessParameters& GetPostProcessParameters(int FRAME_DATA_INDEX) { return mFrameSceneViews[FRAME_DATA_INDEX].postProcess; } inline const FPostProcessParameters& GetPostProcessParameters(int FRAME_DATA_INDEX) const { return mFrameSceneViews[FRAME_DATA_INDEX].postProcess; } inline const Camera& GetActiveCamera() const { return mCameras[mIndex_SelectedCamera]; } inline Camera& GetActiveCamera() { return mCameras[mIndex_SelectedCamera]; } + + //TransformID CreateTransform(Transform** ppTransform); + //GameObject* CreateObject(TransformID tfID, ModelID modelID); + //---------------------------------------------------------------------------------------------------------------- // SCENE DATA //---------------------------------------------------------------------------------------------------------------- @@ -160,15 +179,15 @@ class Scene // // SCENE RESOURCE CONTAINERS // - std::vector mMeshIDs; - std::vector mObjects; - std::vector mGameObjectTransforms; - std::vector mCameras; + //std::vector mMeshIDs; + std::vector mpObjects; + std::vector mpTransforms; + std::vector mCameras; - Light mDirectionalLight; - std::vector mLightsStatic; // stationary lights - std::vector mLightsDynamic; // moving lights - //Skybox mSkybox; + Light mDirectionalLight; + std::vector mLightsStatic; // stationary lights + std::vector mLightsDynamic; // moving lights + //Skybox mSkybox; // @@ -181,26 +200,29 @@ class Scene // // SCENE STATE // - int mIndex_SelectedCamera; + int mIndex_SelectedCamera; public: - int mIndex_ActiveEnvironmentMapPreset; - //EEnvironmentMapPresets mActiveSkyboxPreset; - //Settings::SceneRender mSceneRenderSettings; + int mIndex_ActiveEnvironmentMapPreset; + //EEnvironmentMapPresets mActiveSkyboxPreset; + //Settings::SceneRender mSceneRenderSettings; protected: - const Input& mInput; + const Input& mInput; const std::unique_ptr& mpWindow; + VQEngine& mEngine; FSceneRepresentation mSceneRepresentation; //---------------------------------------------------------------------------------------------------------------- // INTERNAL DATA //---------------------------------------------------------------------------------------------------------------- private: + MemoryPool mGameObjectPool; + MemoryPool mTransformPool; + //CPUProfiler* mpCPUProfiler; //ModelLoader mModelLoader; - //GameObjectPool mObjectPool; //MaterialPool mMaterials; //ModelLoadQueue mModelLoadQueue; diff --git a/Source/Application/VQEngine.h b/Source/Application/VQEngine.h index 0ba85594..843133f2 100644 --- a/Source/Application/VQEngine.h +++ b/Source/Application/VQEngine.h @@ -218,6 +218,14 @@ class VQEngine : public IWindowOwner inline const std::string& GetWindowName(const std::unique_ptr& pWin) const { return GetWindowName(pWin->GetHWND()); } inline const std::string& GetWindowName(const Window* pWin) const { return GetWindowName(pWin->GetHWND()); } + // Mesh & Model management + ModelID CreateModel(); + + MeshID GetBuiltInMeshID(const std::string& MeshName) const; + + Model& GetModel(ModelID id); + const Model& GetModel(ModelID id) const; + private: //------------------------------------------------------------------------------------------------- using BuiltinMeshArray_t = std::array; diff --git a/Source/Application/VQEngine_Main.cpp b/Source/Application/VQEngine_Main.cpp index 14edad67..1efbcd3a 100644 --- a/Source/Application/VQEngine_Main.cpp +++ b/Source/Application/VQEngine_Main.cpp @@ -302,8 +302,8 @@ void VQEngine::InitializeScenes() auto fnCreateSceneInstance = [&](const std::string& SceneType, std::unique_ptr& pScene) -> void { - if (SceneType == "Default") pScene = std::make_unique(NUM_SWAPCHAIN_BACKBUFFERS, input, mpWinMain); - else if (SceneType == "Sponza") pScene = std::make_unique(NUM_SWAPCHAIN_BACKBUFFERS, input, mpWinMain); + if (SceneType == "Default") pScene = std::make_unique(*this, NUM_SWAPCHAIN_BACKBUFFERS, input, mpWinMain); + else if (SceneType == "Sponza") pScene = std::make_unique(*this, NUM_SWAPCHAIN_BACKBUFFERS, input, mpWinMain); }; @@ -962,18 +962,34 @@ std::vector< FSceneRepresentation> VQEngine::ParseScenesFile() XMLElement*& pObj = pCurrentSceneElement; XMLElement* pTransform = pObj->FirstChildElement("Transform"); XMLElement* pModel = pObj->FirstChildElement("Model"); - + + // Transform if (pTransform) { obj.tf = fnParseTransform(pTransform); } - // TODO: this is currently WIP + // Model (WIP) if (pModel) { + XMLElement* pMesh = pModel->FirstChildElement("Mesh"); + XMLElement* pMaterial = pModel->FirstChildElement("Material"); + + if (pMesh) + { + fnParseXMLStringVal(pMesh, obj.BuiltinMeshName); + } + + if (pMaterial) + { + // TODO + } + + // TODO: model loading from disk //obj.ModelName } + SceneRep.Objects.push_back(obj); } diff --git a/Source/Application/VQEngine_Update.cpp b/Source/Application/VQEngine_Update.cpp index 60fcc0e5..3ac638d6 100644 --- a/Source/Application/VQEngine_Update.cpp +++ b/Source/Application/VQEngine_Update.cpp @@ -81,6 +81,7 @@ void VQEngine::UpdateThread_Inititalize() void VQEngine::UpdateThread_Exit() { + mpScene->Unload(); } void VQEngine::UpdateThread_PreUpdate(float& dt) @@ -334,6 +335,38 @@ const std::string& VQEngine::GetWindowName(HWND hwnd) const return mWinNameLookup.at(hwnd); } + +MeshID VQEngine::GetBuiltInMeshID(const std::string& MeshName) const +{ + const auto it = std::find(mBuiltinMeshNames.begin(), mBuiltinMeshNames.end(), MeshName); + if (it == mBuiltinMeshNames.end()) + { + Log::Error("Builtin Mesh Not Found: %s", MeshName.c_str()); + return INVALID_ID; + } + return static_cast(it - mBuiltinMeshNames.begin()); +} + +Model& VQEngine::GetModel(ModelID id) +{ + // TODO: err msg + return mModels.at(id); +} + +const Model& VQEngine::GetModel(ModelID id) const +{ + // TODO: err msg + return mModels.at(id); +} + +ModelID VQEngine::CreateModel() +{ + static ModelID LAST_USED_MODEL_ID = 0; + ModelID id = LAST_USED_MODEL_ID++; + mModels[id] = Model(); + return id; +} + const FEnvironmentMapDescriptor& VQEngine::GetEnvironmentMapDesc(const std::string& EnvMapName) const { static const FEnvironmentMapDescriptor DEFAULT_ENV_MAP_DESC = { "ENV_MAP_NOT_FOUND", "", 0.0f }; @@ -369,7 +402,6 @@ void VQEngine::UpdateThread_UpdateScene_MainWnd(const float dt) const FEnvironmentMap& env = mResources_MainWnd.EnvironmentMap; const int NumEnvMaps = static_cast(mEnvironmentMapPresetNames.size()); -#if 0 // TODO: there's a crash during changing environment map for some reason :( if (input.IsKeyTriggered("PageUp")) { fnBusyWaitUntilRenderThreadCatchesUp(); @@ -402,7 +434,6 @@ void VQEngine::UpdateThread_UpdateScene_MainWnd(const float dt) LoadEnvironmentMap(mEnvironmentMapPresetNames[ACTIVE_ENV_MAP_INDEX]); }); } -#endif } void VQEngine::UpdateThread_UpdateScene_DebugWnd(const float dt) diff --git a/Source/Scenes/Scenes.h b/Source/Scenes/Scenes.h index d7f898b1..76747991 100644 --- a/Source/Scenes/Scenes.h +++ b/Source/Scenes/Scenes.h @@ -4,6 +4,8 @@ #pragma once +class VQEngine; + #define DECLARE_SCENE_INTERFACE()\ protected:\ void UpdateScene(float dt, FSceneView& SceneView) override;\ @@ -13,11 +15,12 @@ protected:\ #define DECLARE_CTOR(TypeName)\ public:\ - TypeName(int NumFrameBuffers\ + TypeName(VQEngine& engine\ + , int NumFrameBuffers\ , const Input& input\ , const std::unique_ptr& pWin\ )\ - : Scene(NumFrameBuffers, input, pWin)\ + : Scene(engine, NumFrameBuffers, input, pWin)\ {}\ From 8a9e901914e4ec0b134df41992911e1413268c64 Mon Sep 17 00:00:00 2001 From: Volkan Date: Sun, 16 Aug 2020 18:00:40 -0700 Subject: [PATCH 06/67] Geometry rendering on screen again with the new scene logic --- Source/Application/Scene.cpp | 1719 +----------------------- Source/Application/Scene.h | 353 +---- Source/Application/VQEngine_Render.cpp | 61 +- Source/Application/VQEngine_Update.cpp | 2 - 4 files changed, 64 insertions(+), 2071 deletions(-) diff --git a/Source/Application/Scene.cpp b/Source/Application/Scene.cpp index 866f6d45..f93da58b 100644 --- a/Source/Application/Scene.cpp +++ b/Source/Application/Scene.cpp @@ -47,6 +47,23 @@ void Scene::PostUpdate(int FRAME_DATA_INDEX, int FRAME_DATA_NEXT_INDEX) SceneView.viewInverse = cam.GetViewInverseMatrix(); SceneView.viewProj = SceneView.view * SceneView.proj; SceneView.cameraPosition = XMLoadFloat3(&camPos); + + + // TODO: compute visibility + + SceneView.meshRenderCommands.clear(); + for (const GameObject* pObj : mpObjects) + { + const XMMATRIX matWorldTransform = mpTransforms.at(pObj->mTransformID)->WorldTransformationMatrix(); + + for (const MeshID id : mEngine.GetModel(pObj->mModelID).mData.mMeshIDs) + { + FMeshRenderCommand meshRenderCmd; + meshRenderCmd.meshID = id; + meshRenderCmd.WorldTransformationMatrix = matWorldTransform; + SceneView.meshRenderCommands.push_back(meshRenderCmd); + } + } } void Scene::StartLoading(FSceneRepresentation& scene) @@ -105,10 +122,9 @@ void Scene::StartLoading(FSceneRepresentation& scene) fnDeserializeGameObject(ObjRep); } } - - // dispatch workers - else + else // THREADED LOAD { + // dispatch workers assert(false); // TODO } @@ -169,1700 +185,3 @@ void Scene::RenderUI() // TODO } - -#if 0 -#include "SceneResourceView.h" -#include "Engine.h" -#include "ObjectCullingSystem.h" - -#include "Application/Input.h" -#include "Application/ThreadPool.h" -#include "Renderer/GeometryGenerator.h" -#include "Utilities/Log.h" - -#include -#include - -#define THREADED_FRUSTUM_CULL 0 // uses workers to cull the render lists (not implemented yet) - -Scene::Scene(const BaseSceneParams& params) - : mpRenderer(params.pRenderer) - , mpTextRenderer(params.pTextRenderer) - , mSelectedCamera(0) - , mpCPUProfiler(params.pCPUProfiler) - , mLODManager(this->mMeshIDs, this->mpRenderer) - , mActiveSkyboxPreset(ENVIRONMENT_MAP_PRESET_COUNT) -{ - mModelLoader.Initialize(mpRenderer); -} - - -//---------------------------------------------------------------------------------------------------------------- -// LOAD / UNLOAD FUNCTIONS -//---------------------------------------------------------------------------------------------------------------- -void Scene::LoadScene(FSceneRepresentation& scene, const Settings::Window& windowSettings) -{ - // - // Allocate GameObject & Material memory - // -#ifdef _DEBUG - mObjectPool.Initialize(4096); - mMaterials.Initialize(4096); -#else - mObjectPool.Initialize(4096 * 8); - mMaterials.Initialize(4096 * 8); -#endif - - mMeshIDs.clear(); - mpObjects.clear(); - mMeshIDs.resize(mBuiltinMeshes.size()); - std::copy(RANGE(mBuiltinMeshes), mMeshIDs.begin()); - - - // - // Lights - // - for (Light& l : scene.lights) this->AddLight(std::move(l)); - //mLights = std::move(scene.lights); - - mMaterials = std::move(scene.materials); - mDirectionalLight = std::move(scene.directionalLight); - mSceneRenderSettings = scene.settings; - - - // - // Cameras - // - for (const Settings::Camera& camSetting : scene.cameras) - { - Camera c; - c.ConfigureCamera(camSetting, windowSettings, mpRenderer); - mCameras.push_back(c); - } - - - // - // Game Objects - // - for (size_t i = 0; i < scene.objects.size(); ++i) - { - GameObject* pObj = mObjectPool.Create(this); - *pObj = scene.objects[i]; - pObj->mpScene = this; - - // if the game object has a model that is not loaded yet - // call the async load function - if (!pObj->mModel.mbLoaded && !pObj->mModel.mModelName.empty()) - { - LoadModel_Async(pObj, pObj->mModel.mModelName); - } - mpObjects.push_back(pObj); - } - - - Load(scene); // Scene-specific load - StartLoadingModels(); // async model loading - - SetLightCache(); - - EndLoadingModels(); - - // initialize LOD manager - { - std::vector pSceneObjects; - for (GameObject* pObj : mpObjects) - { - if (pObj->mpScene == this) - { - pSceneObjects.push_back(pObj); - } - } - - mLODManager.Initialize(GetActiveCamera(), pSceneObjects); - } - CalculateSceneBoundingBox(); // needs to happen after models are loaded -} - - -void Scene::UnloadScene() -{ - //--------------------------------------------------------------------------- - // if we clear materials and don't clear the models loaded with them, - // we'll crash in lookups. this can be improved by only reloading - // the materials instead of the whole mesh data. #TODO: more granular reload - mModelLoader.UnloadSceneModels(this); - mMaterials.Clear(); - //--------------------------------------------------------------------------- - mCameras.clear(); - mObjectPool.Cleanup(); - mMeshIDs.clear(); - mObjectPool.Cleanup(); - ClearLights(); - mLODManager.Reset(); - Unload(); - mpObjects.clear(); -} - -void Scene::RenderUI() -{ -} - - -MeshID Scene::AddMesh_Async(Mesh mesh) -{ - std::unique_lock l(mSceneMeshMutex); - mMeshIDs.push_back(mesh); - return MeshID(mMeshIDs.size() - 1); -} - -void Scene::StartLoadingModels() -{ - // can have multiple objects pointing to the same path - // get all the unique paths - // - std::set uniqueModelList; - - std::for_each(RANGE(mModelLoadQueue.objectModelMap), [&](auto kvp) - { // 'value' (.second) of the 'key value pair' (kvp) contains the model path - uniqueModelList.emplace(kvp.second); - }); - - if (uniqueModelList.empty()) return; - - Log::Info("Async Model Load List: "); - - // so we load the models only once - // - std::for_each(RANGE(uniqueModelList), [&](const std::string& modelPath) - { - Log::Info("\t%s", modelPath.c_str()); - mModelLoadQueue.asyncModelResults[modelPath] = mpThreadPool->AddTask([=]() - { - return mModelLoader.LoadModel_Async(modelPath, this); - }); - }); -} - -void Scene::EndLoadingModels() -{ - std::unordered_map loadedModels; - std::for_each(RANGE(mModelLoadQueue.objectModelMap), [&](auto kvp) - { - const std::string& modelPath = kvp.second; - GameObject* pObj = kvp.first; - - // this will wait on the longest item. - Model m = {}; - if (loadedModels.find(modelPath) == loadedModels.end()) - { - m = mModelLoadQueue.asyncModelResults.at(modelPath).get(); - loadedModels[modelPath] = m; - } - else - { - m = loadedModels.at(modelPath); - } - - // override material if any. - if (!pObj->mModel.mMaterialAssignmentQueue.empty()) - { - MaterialID matID = pObj->mModel.mMaterialAssignmentQueue.front(); - pObj->mModel.mMaterialAssignmentQueue.pop(); // we only use the first material for now... - m.OverrideMaterials(matID); - } - - // assign the model to object - pObj->SetModel(m); - }); -} - -void Scene::AddStaticLight(const Light& l) -{ - mLightsStatic.push_back(l); - - // Note: Static light cache is initialized after the loading is done. - // So we just push the light to the static light container here. -} - -void Scene::AddDynamicLight(const Light& l) -{ - mLightsDynamic.push_back(l); -} - -Model Scene::LoadModel(const std::string & modelPath) -{ - return mModelLoader.LoadModel(modelPath, this); -} - -void Scene::LoadModel_Async(GameObject* pObject, const std::string& modelPath) -{ - std::unique_lock lock(mModelLoadQueue.mutex); - mModelLoadQueue.objectModelMap[pObject] = modelPath; -} - - -//---------------------------------------------------------------------------------------------------------------- -// UPDATE FUNCTIONS -//---------------------------------------------------------------------------------------------------------------- -void Scene::UpdateScene(float dt) -{ - // CYCLE THROUGH CAMERAS - // - if (ENGINE->INP()->IsKeyTriggered("C")) - { - mSelectedCamera = (mSelectedCamera + 1) % mCameras.size(); - mLODManager.SetViewer(this->GetActiveCamera()); - } - - - // OPTIMIZATION SETTINGS TOGGLES - // -//#if _DEBUG -#if 1 - if (ENGINE->INP()->IsKeyTriggered("F7")) - { - bool& toggle = ENGINE->INP()->IsKeyDown("Shift") - ? mSceneRenderSettings.optimization.bViewFrustumCull_LocalLights - : mSceneRenderSettings.optimization.bViewFrustumCull_MainView; - - toggle = !toggle; - } - if (ENGINE->INP()->IsKeyTriggered("F8")) - { - mSceneRenderSettings.optimization.bViewFrustumCull_LocalLights = !mSceneRenderSettings.optimization.bViewFrustumCull_LocalLights; - } -#endif - - - - // UPDATE CAMERA & WORLD - // - mpCPUProfiler->BeginEntry("Scene::Update()"); - mCameras[mSelectedCamera].Update(dt); - Update(dt); - mpCPUProfiler->EndEntry(); - - // UPDATE LOD MANAGER - // - mpCPUProfiler->BeginEntry("LODManager::Update()"); - mLODManager.Update(); - mpCPUProfiler->EndEntry(); - - - // Note: - // this could be moved outside this function to allow for more time - // for concurrency of lod manager update operations (if it takes that long). - mpCPUProfiler->BeginEntry("LODManager::LateUpdate()"); - mLODManager.LateUpdate(); - mpCPUProfiler->EndEntry(); -} - -static void ResetSceneStatCounters(SceneStats& stats) -{ - stats.numSpots = 0; - stats.numPoints = 0; - //stats.numDirectionalCulledObjects = 0; - stats.numPointsCulledObjects = 0; - stats.numSpotsCulledObjects = 0; -} - -void Scene::PreRender(FrameStats& stats, SceneLightingConstantBuffer& outLightingData) -{ - using namespace VQEngine; - - // containers we'll work on for preparing draw lists - std::vector mainViewRenderList; // Shadow casters + non-shadow casters - std::vector mainViewShadowCasterRenderList; - SceneShadowingLightIndexCollection shadowingLightIndexCollection; - - - //---------------------------------------------------------------------------- - // SET SCENE VIEW / SETTINGS - //---------------------------------------------------------------------------- - SetSceneViewData(); - ResetSceneStatCounters(stats.scene); - - - //---------------------------------------------------------------------------- - // PREPARE RENDER LISTS - //---------------------------------------------------------------------------- - mpCPUProfiler->BeginEntry("GatherSceneObjects"); - GatherSceneObjects(mainViewShadowCasterRenderList, stats.scene.numObjects); - mpCPUProfiler->EndEntry(); - - //---------------------------------------------------------------------------- - // CULL LIGHTS - //---------------------------------------------------------------------------- - mpCPUProfiler->BeginEntry("Cull_Lights"); - shadowingLightIndexCollection = CullShadowingLights(stats.scene.numCulledShadowingPointLights, stats.scene.numCulledShadowingSpotLights); - mpCPUProfiler->EndEntry(); - - //---------------------------------------------------------------------------- - // CULL MAIN VIEW RENDER LISTS - //---------------------------------------------------------------------------- - mpCPUProfiler->BeginEntry("Cull_MainView"); - mainViewRenderList = FrustumCullMainView(stats.scene.numMainViewCulledObjects); - mpCPUProfiler->EndEntry(); - - - //---------------------------------------------------------------------------- - // CULL SHADOW VIEW RENDER LISTS - //---------------------------------------------------------------------------- - //mpCPUProfiler->BeginEntry("Cull_ShadowViews"); - FrustumCullPointAndSpotShadowViews(mainViewShadowCasterRenderList, shadowingLightIndexCollection, stats); - //mpCPUProfiler->EndEntry(); - - - //---------------------------------------------------------------------------- - // OCCLUSION CULL DIRECTIONAL SHADOW VIEW RENDER LISTS (not implemented yet) - //---------------------------------------------------------------------------- - if (mSceneRenderSettings.optimization.bShadowViewCull) - { - mpCPUProfiler->BeginEntry("Cull_Directional_Occl"); - OcclusionCullDirectionalLightView(); - mpCPUProfiler->EndEntry(); - } - - //mpCPUProfiler->BeginEntry("Gather_FlattenedLightList"); - std::vector pShadowingLights = shadowingLightIndexCollection.GetFlattenedListOfLights(mLightsStatic, mLightsDynamic); - //mpCPUProfiler->EndEntry(); - - //---------------------------------------------------------------------------- - // SORT RENDER LISTS - //---------------------------------------------------------------------------- - if (mSceneRenderSettings.optimization.bSortRenderLists) - { - mpCPUProfiler->BeginEntry("Sort"); - SortRenderLists(mainViewShadowCasterRenderList, pShadowingLights); - mpCPUProfiler->EndEntry(); - } - - - //---------------------------------------------------------------------------- - // BATCH SHADOW VIEW RENDER LISTS - //---------------------------------------------------------------------------- - BatchShadowViewRenderLists(mainViewShadowCasterRenderList); - - - //---------------------------------------------------------------------------- - // BATCH MAIN VIEW RENDER LISTS - //---------------------------------------------------------------------------- - mpCPUProfiler->BeginEntry("Batch_MainView"); - BatchMainViewRenderList(mainViewRenderList); - mpCPUProfiler->EndEntry(); - - -#if _DEBUG - static bool bReportedList = false; - if (!bReportedList) - { - Log::Info("Mesh Render List (%s): ", mSceneRenderSettings.optimization.bSortRenderLists ? "Sorted" : "Unsorted"); - int num = 0; - std::for_each(RANGE(mSceneView.culledOpaqueList), [&](const GameObject* pObj) - { - Log::Info("\tObj[%d]: ", num); - - int numMesh = 0; - std::for_each(RANGE(pObj->GetModelData().mMeshIDs), [&](const MeshID& id) - { - Log::Info("\t\tMesh[%d]: %d", numMesh, id); - }); - ++num; - }); - bReportedList = true; - } -#endif // THREADED_FRUSTUM_CULL - - - mpCPUProfiler->BeginEntry("GatherLightData"); - GatherLightData(outLightingData, pShadowingLights); - mpCPUProfiler->EndEntry(); - - //return numFrustumCulledObjs + numShadowFrustumCullObjs; -} - - -void Scene::ResetActiveCamera() -{ - mCameras[mSelectedCamera].Reset(); -} - -std::vector Scene::mBuiltinMeshes; -void Scene::InitializeBuiltinMeshes() -{ - - // cylinder parameters - const float cylHeight = 3.1415f; const float cylTopRadius = 1.0f; - const float cylBottomRadius = 1.0f; const unsigned cylSliceCount = 70; - const unsigned cylStackCount = 20; - - // grid parameters - const float gridWidth = 1.0f; const float gridDepth = 1.0f; - const unsigned gridFinenessH = 90; const unsigned gridFinenessV = 90; - - // sphere parameters - const float sphRadius = 2.0f; - const unsigned sphRingCount = 70; const unsigned sphSliceCount = 70; - - // cone parameters - const float coneHeight = 3.0f; - const float coneRadius = 1.0f; - - constexpr int numDefaultLODLevels_Sphere = 5; - constexpr int numDefaultLODLevels_Grid = 7; - constexpr int numDefaultLODLevels_Cone = 6; - constexpr int numDefaultLODLevels_Cylinder = 6; - - Scene::mBuiltinMeshes = // this should match enum declaration order - { - GeometryGenerator::Triangle(1.0f), - GeometryGenerator::Quad(1.0f), - GeometryGenerator::FullScreenQuad(), - GeometryGenerator::Cube(), - GeometryGenerator::Cylinder(cylHeight, cylTopRadius, cylBottomRadius, cylSliceCount, cylStackCount, numDefaultLODLevels_Cylinder), - GeometryGenerator::Sphere(sphRadius, sphRingCount, sphSliceCount, numDefaultLODLevels_Sphere), - GeometryGenerator::Grid(gridWidth, gridDepth, gridFinenessH, gridFinenessV, numDefaultLODLevels_Grid), - GeometryGenerator::Cone(coneHeight, coneRadius, 120, numDefaultLODLevels_Cone), - GeometryGenerator::Cone(1.0f, 1.0f, 30), - //GeometryGenerator::Sphere(sphRadius / 40, 10, 10), - }; - - LODManager::InitializeBuiltinMeshLODSettings(); -} - -void Scene::SetEnvironmentMap(EEnvironmentMapPresets preset) -{ - mActiveSkyboxPreset = preset; - mSkybox = Skybox::s_Presets[mActiveSkyboxPreset]; -} - - - -//---------------------------------------------------------------------------------------------------------------- -// PRE-RENDER FUNCTIONS -//---------------------------------------------------------------------------------------------------------------- -// can't use std::array, hence std::array -// array of 2: light data for non-shadowing and shadowing lights -constexpr size_t NON_SHADOWING_LIGHT_INDEX = 0; -constexpr size_t SHADOWING_LIGHT_INDEX = 1; -using pPointLightDataArray = std::array; -using pSpotLightDataArray = std::array; - -// stores the number of lights per light type (2 types : point and spot) -using pNumArray = std::array; -void Scene::GatherLightData(SceneLightingConstantBuffer & outLightingData, const std::vector& pLightList) -{ - SceneLightingConstantBuffer::cb& cbuffer = outLightingData._cb; - - outLightingData.ResetCounts(); - - cbuffer.directionalLight.depthBias = 0.0f; - cbuffer.directionalLight.enabled = 0; - cbuffer.directionalLight.shadowing = 0; - cbuffer.directionalLight.brightness = 0.0f; - - pNumArray lightCounts - { - &outLightingData._cb.pointLightCount, - &outLightingData._cb.spotLightCount - }; - pNumArray casterCounts - { - &outLightingData._cb.pointLightCount_shadow, - &outLightingData._cb.spotLightCount_shadow - }; - - unsigned numShdSpot = 0; - unsigned numPtSpot = 0; - - for (const Light* l : pLightList) - { - //if (!l->_bEnabled) continue; // #BreaksRelease - - pNumArray& refLightCounts = casterCounts; - const size_t lightIndex = (*refLightCounts[l->mType])++; - switch (l->mType) - { - case Light::ELightType::POINT: - { - PointLightGPU plData; - l->GetGPUData(plData); - - cbuffer.pointLightsShadowing[lightIndex] = plData; - mShadowView.points.push_back(l); - } break; - case Light::ELightType::SPOT: - { - SpotLightGPU slData; - l->GetGPUData(slData); - - cbuffer.spotLightsShadowing[lightIndex] = slData; - cbuffer.shadowViews[numShdSpot++] = l->GetLightSpaceMatrix(); - mShadowView.spots.push_back(l); - } break; - default: - Log::Error("Engine::PreRender(): UNKNOWN LIGHT TYPE"); - continue; - } - } - - // iterate for non-shadowing lights (they won't be in pLightList) - constexpr size_t NUM_LIGHT_CONTAINERS = 2; - std::array*, NUM_LIGHT_CONTAINERS > lightContainers = - { - &mLightsStatic - , &mLightsDynamic - }; - for (int i = 0; i < NUM_LIGHT_CONTAINERS; ++i) - { - const std::vector& mLights = *lightContainers[i]; - for (const Light& l : mLights) - { - if (l.mbCastingShadows) continue; - pNumArray& refLightCounts = lightCounts; - - const size_t lightIndex = (*refLightCounts[l.mType])++; - switch (l.mType) - { - case Light::ELightType::POINT: - { - PointLightGPU plData; - l.GetGPUData(plData); - cbuffer.pointLights[lightIndex] = plData; - } break; - case Light::ELightType::SPOT: - { - SpotLightGPU slData; - l.GetGPUData(slData); - cbuffer.spotLights[lightIndex] = slData; - } break; - default: - Log::Error("Engine::PreRender(): UNKNOWN LIGHT TYPE"); - continue; - } - } - } - - if (mDirectionalLight.mbEnabled) - { - mDirectionalLight.GetGPUData(cbuffer.directionalLight); - cbuffer.shadowViewDirectional = mDirectionalLight.GetLightSpaceMatrix(); - mShadowView.pDirectional = &mDirectionalLight; - } - else - { - cbuffer.directionalLight = {}; - } -} - -void Scene::SetSceneViewData() -{ - const Camera& viewCamera = GetActiveCamera(); - const XMMATRIX view = viewCamera.GetViewMatrix(); - const XMMATRIX viewInverse = viewCamera.GetViewInverseMatrix(); - const XMMATRIX proj = viewCamera.GetProjectionMatrix(); - XMVECTOR det = XMMatrixDeterminant(proj); - const XMMATRIX projInv = XMMatrixInverse(&det, proj); - det = mDirectionalLight.mbEnabled - ? XMMatrixDeterminant(mDirectionalLight.GetProjectionMatrix()) - : XMVECTOR(); - const XMMATRIX directionalLightProjection = mDirectionalLight.mbEnabled - ? mDirectionalLight.GetProjectionMatrix() - : XMMatrixIdentity(); - - // scene view matrices - mSceneView.viewProj = view * proj; - mSceneView.view = view; - mSceneView.viewInverse = viewInverse; - mSceneView.proj = proj; - mSceneView.projInverse = projInv; - mSceneView.directionalLightProjection = directionalLightProjection; - - // render/scene settings - mSceneView.sceneRenderSettings = GetSceneRenderSettings(); - mSceneView.environmentMap = GetEnvironmentMap(); - mSceneView.cameraPosition = viewCamera.GetPositionF(); - mSceneView.bIsIBLEnabled = mSceneRenderSettings.bSkylightEnabled && mSceneView.bIsPBRLightingUsed && mSceneView.environmentMap.environmentMap != -1; -} - -void Scene::GatherSceneObjects(std::vector & mainViewShadowCasterRenderList, int& outNumSceneObjects) -{ - // CLEAN UP RENDER LISTS - // - //pCPUProfiler->BeginEntry("CleanUp"); - // scene view - mSceneView.opaqueList.clear(); - mSceneView.culledOpaqueList.clear(); - mSceneView.culluedOpaqueInstancedRenderListLookup.clear(); - mSceneView.alphaList.clear(); - - // shadow views - mShadowView.Clear(); - mShadowView.RenderListsPerMeshType.clear(); - mShadowView.casters.clear(); - mShadowView.shadowMapRenderListLookUp.clear(); - mShadowView.shadowMapInstancedRenderListLookUp.clear(); - //pCPUProfiler->EndEntry(); - - // POPULATE RENDER LISTS WITH SCENE OBJECTS - // - outNumSceneObjects = 0; - for (GameObject& obj : mObjectPool.mObjects) - { - // only gather the game objects that are to be rendered in 'this' scene - if (obj.mpScene == this && obj.mRenderSettings.bRender) - { - const bool bMeshListEmpty = obj.mModel.mData.mMeshIDs.empty(); - const bool bTransparentMeshListEmpty = obj.mModel.mData.mTransparentMeshIDs.empty(); - const bool mbCastingShadows = obj.mRenderSettings.bCastShadow && !bMeshListEmpty; - - // populate render lists - if (!bMeshListEmpty) - { - mSceneView.opaqueList.push_back(&obj); - } - if (!bTransparentMeshListEmpty) - { - mSceneView.alphaList.push_back(&obj); - } - if (mbCastingShadows) - { - mainViewShadowCasterRenderList.push_back(&obj); - } - -#if _DEBUG - if (bMeshListEmpty && bTransparentMeshListEmpty) - { - Log::Warning("GameObject with no Mesh Data, turning bRender off"); - obj.mRenderSettings.bRender = false; - } -#endif - ++outNumSceneObjects; - } - } -} - - -void Scene::SortRenderLists(std::vector & mainViewShadowCasterRenderList, std::vector& pShadowingLights) -{ - // LAMBDA DEFINITIONS - //--------------------------------------------------------------------------------------------- - // Meshes are sorted according to BUILT_IN_TYPE < CUSTOM, - // and BUILT_IN_TYPEs are sorted in themselves - auto SortByMeshType = [&](const GameObject* pObj0, const GameObject* pObj1) - { - const ModelData& model0 = pObj0->GetModelData(); - const ModelData& model1 = pObj1->GetModelData(); - - const MeshID mID0 = model0.mMeshIDs.empty() ? -1 : model0.mMeshIDs.back(); - const MeshID mID1 = model1.mMeshIDs.empty() ? -1 : model1.mMeshIDs.back(); - - assert(mID0 != -1 && mID1 != -1); - - // case: one of the objects have a custom mesh - if (mID0 >= EGeometry::MESH_TYPE_COUNT || mID1 >= EGeometry::MESH_TYPE_COUNT) - { - if (mID0 < EGeometry::MESH_TYPE_COUNT) - return true; - - if (mID1 < EGeometry::MESH_TYPE_COUNT) - return false; - - return false; - } - - // case: both objects are built-in types - else - { - return mID0 < mID1; - } - }; - auto SortByMaterialID = [](const GameObject* pObj0, const GameObject* pObj1) - { - // TODO: - return true; - }; - auto SortByViewSpaceDepth = [](const GameObject* pObj0, const GameObject* pObj1) - { - // TODO: - return true; - }; - //--------------------------------------------------------------------------------------------- - - std::sort(RANGE(mSceneView.culledOpaqueList), SortByMeshType); - std::sort(RANGE(mainViewShadowCasterRenderList), SortByMeshType); - for (const Light* pLight : pShadowingLights) - { - switch (pLight->mType) - { - - case Light::ELightType::POINT: - { - for (int i = 0; i < 6; ++i) - { - ; - } - break; - } - case Light::ELightType::SPOT: - { - RenderList& lightRenderList = mShadowView.shadowMapRenderListLookUp.at(pLight); - std::sort(RANGE(lightRenderList), SortByMeshType); - break; - } - } - - } -} - -Scene::SceneShadowingLightIndexCollection Scene::CullShadowingLights(int& outNumCulledPoints, int& outNumCulledSpots) -{ - using namespace VQEngine; - - SceneShadowingLightIndexCollection sceneShadowingLightIndexCollection; - - outNumCulledPoints = 0; - outNumCulledSpots = 0; - - auto fnCullLights = [&](const std::vector& lights) -> ShadowingLightIndexCollection - { - ShadowingLightIndexCollection outLightIndices; - - for (int i = 0; i < lights.size(); ++i) - { - if (!lights[i].mbCastingShadows) continue; - - const Light& l = lights[i]; - switch (l.mType) - { - case Light::ELightType::SPOT: - { - // TODO: frustum - cone check - const bool bCullLight = false; - if (!bCullLight /* == IsVisible() */) - { - outLightIndices.spotLightIndices.push_back(i); - } - else - { - ++outNumCulledSpots; - } - } break; - - case Light::ELightType::POINT: - { - vec3 vecCamera = GetActiveCamera().GetPositionF() - l.mTransform._position; - const float dstSqrCameraToLight = XMVector3Dot(vecCamera, vecCamera).m128_f32[0]; - const float rangeSqr = l.mRange * l.mRange; - - const bool bIsCameraInPointLightSphereOfIncluence = dstSqrCameraToLight < rangeSqr; - const bool bSphereInFrustum = IsSphereInFrustum(GetActiveCamera().GetViewFrustumPlanes(), Sphere(l.mTransform._position, l.mRange)); - - if (bIsCameraInPointLightSphereOfIncluence || bSphereInFrustum) - { - outLightIndices.pointLightIndices.push_back(i); - } - else - { - ++outNumCulledPoints; - } - } break; - } // light type - - } - - return outLightIndices; - }; - - sceneShadowingLightIndexCollection.mStaticLights = fnCullLights(mLightsStatic); - sceneShadowingLightIndexCollection.mDynamicLights = fnCullLights(mLightsDynamic); - return sceneShadowingLightIndexCollection; -} - -std::vector Scene::FrustumCullMainView(int& outNumCulledObjects) -{ - using namespace VQEngine; - - const bool& bCullMainView = mSceneRenderSettings.optimization.bViewFrustumCull_MainView; - - std::vector mainViewRenderList; - - //mpCPUProfiler->BeginEntry("[Cull Main SceneView]"); - if (bCullMainView) - { - outNumCulledObjects = static_cast(CullGameObjects( - FrustumPlaneset::ExtractFromMatrix(mSceneView.viewProj) - , mSceneView.opaqueList - , mainViewRenderList)); - } - else - { - mainViewRenderList.resize(mSceneView.opaqueList.size()); - std::copy(RANGE(mSceneView.opaqueList), mainViewRenderList.begin()); - outNumCulledObjects = 0; - } - //mpCPUProfiler->EndEntry(); - - return mainViewRenderList; -} - - -void Scene::FrustumCullPointAndSpotShadowViews( - const std::vector & mainViewShadowCasterRenderList - , const SceneShadowingLightIndexCollection& shadowingLightIndices - , FrameStats& stats -) -{ - using namespace VQEngine; - - - auto fnCullPointLightView = [&](const Light* l, const std::array& frustumPlaneSetPerFace) - { -#if SHADOW_PASS_USE_INSTANCED_DRAW_DATA - std::array< MeshDrawData, 6>& meshDrawDataPerFace = mShadowView.shadowCubeMapMeshDrawListLookup[l]; - for (int i = 0; i < 6; ++i) - meshDrawDataPerFace[i].meshTransformListLookup.clear(); -#else - std::array< MeshDrawList, 6>& meshListForPoints = mShadowView.shadowCubeMapMeshDrawListLookup[l]; - for (int i = 0; i < 6; ++i) - meshListForPoints[i].clear(); -#endif - - // cull for far distance - std::vector filteredMainViewShadowCasterList(mainViewShadowCasterRenderList.size(), nullptr); - int numObjs = 0; - for (const GameObject* pObj : mainViewShadowCasterRenderList) - { - const XMMATRIX matWorld = pObj->GetTransform().WorldTransformationMatrix(); - BoundingBox BB = pObj->GetAABB(); // local space AABB (this is wrong, AABB should be calculated on update()). - BB.low = XMVector3Transform(BB.low, matWorld); - BB.hi = XMVector3Transform(BB.hi , matWorld); // world space BB - if (IsBoundingBoxInsideSphere_Approx(BB, Sphere(l->GetTransform()._position, l->mRange))) - filteredMainViewShadowCasterList[numObjs++] = pObj; - } - if (numObjs == 0) - { - return; - } - - // cull for visibility per face - for (int face = 0; face < 6; ++face) - { - const Texture::CubemapUtility::ECubeMapLookDirections CubemapFaceDirectionEnum = static_cast(face); - for (const GameObject* pObj : filteredMainViewShadowCasterList) - { - if (!pObj) // stop at first null game object because we resize @filteredMainViewShadowCasterList when creating it. - break; - -#if SHADOW_PASS_USE_INSTANCED_DRAW_DATA - stats.scene.numPointsCulledObjects += static_cast(CullMeshes - ( - frustumPlaneSetPerFace[face], - pObj, - meshDrawDataPerFace[face] - )); -#else - meshDrawData.meshIDs.clear(); - stats.scene.numPointsCulledObjects += static_cast(CullMeshes - ( - frustumPlaneSetPerFace[face], - pObj, - meshDrawData - )); - meshListForPoints[face].push_back(meshDrawData); -#endif - } - } - }; - auto fnCullSpotLightView = [&](const Light* l, const FrustumPlaneset& frustumPlaneSet) - { - RenderList& renderList = mShadowView.shadowMapRenderListLookUp[l]; - - renderList.clear(); - stats.scene.numSpotsCulledObjects += static_cast( - CullGameObjects( - frustumPlaneSet - , mainViewShadowCasterRenderList - , renderList - )); - }; - - - RenderList objList; - - // Culling Disabled: just copy the mainViewShadowCasterRenderList - // to the render lists of lights without any culling. - // - if (!mSceneRenderSettings.optimization.bViewFrustumCull_LocalLights) - { - // spots - for (int i = 0; i < shadowingLightIndices.mStaticLights.spotLightIndices.size(); ++i) - { - const Light* l = &mLightsStatic[shadowingLightIndices.mStaticLights.spotLightIndices[i]]; - - RenderList& renderList = mShadowView.shadowMapRenderListLookUp[l]; - renderList.resize(mainViewShadowCasterRenderList.size()); - std::copy(RANGE(mainViewShadowCasterRenderList), renderList.begin()); - } - for (int i = 0; i < shadowingLightIndices.mDynamicLights.spotLightIndices.size(); ++i) - { - const Light* l = &mLightsStatic[shadowingLightIndices.mDynamicLights.spotLightIndices[i]]; - - RenderList& renderList = mShadowView.shadowMapRenderListLookUp[l]; - renderList.resize(mainViewShadowCasterRenderList.size()); - std::copy(RANGE(mainViewShadowCasterRenderList), renderList.begin()); - } - - - // points - auto fnCopyPointLightRenderLists = [&](const std::vector& lightContainer, const std::vector& lightIndices) - { - for (int i = 0; i < lightIndices.size(); ++i) - { - const Light* l = &lightContainer[lightIndices[i]]; - -#if SHADOW_PASS_USE_INSTANCED_DRAW_DATA - std::array< MeshDrawData, 6>& meshDrawDataPerFace = mShadowView.shadowCubeMapMeshDrawListLookup[l]; -#else - std::array< MeshDrawList, 6>& meshListForPoints = mShadowView.shadowCubeMapMeshDrawListLookup[l]; -#endif - - for (int face = 0; face < 6; ++face) - { - for (const GameObject* pObj : mainViewShadowCasterRenderList) - { -#if SHADOW_PASS_USE_INSTANCED_DRAW_DATA - const XMMATRIX matWorld = pObj->GetTransform().WorldTransformationMatrix(); - for (MeshID meshID : pObj->GetModelData().mMeshIDs) - meshDrawDataPerFace[face].AddMeshTransformation(meshID, matWorld); -#else - meshListForPoints[face].push_back(pObj); -#endif - } - } - } - }; - - fnCopyPointLightRenderLists(mLightsStatic , shadowingLightIndices.mStaticLights.pointLightIndices); - fnCopyPointLightRenderLists(mLightsDynamic, shadowingLightIndices.mDynamicLights.pointLightIndices); - return; - } - - - - // Culling Enabled : cull mainViewShadowCasterRenderList against - // light frustums. - // - // record the light stats - stats.scene.numSpots = static_cast(shadowingLightIndices.GetLightCount(Light::ELightType::SPOT) ); - stats.scene.numPoints = static_cast(shadowingLightIndices.GetLightCount(Light::ELightType::POINT)); - - - // Cull Static Lights - mpCPUProfiler->BeginEntry("Cull_ShadowView_Point_s"); - { - const std::vector& lightIndexContainer = shadowingLightIndices.mStaticLights.pointLightIndices; - for (int i = 0; i < lightIndexContainer.size(); ++i) // point lights - { - int lightIndex = lightIndexContainer[i]; - const Light* l = &mLightsStatic[lightIndex]; - fnCullPointLightView(l, mStaticLightCache.mStaticPointLightFrustumPlanes.at(l)); - } - } - mpCPUProfiler->EndEntry(); - - mpCPUProfiler->BeginEntry("Cull_ShadowView_Spot_s"); - { - const std::vector& lightIndexContainer = shadowingLightIndices.mStaticLights.spotLightIndices; - for (int i = 0; i < lightIndexContainer.size(); ++i) // spot lights - { - int lightIndex = lightIndexContainer[i]; - const Light* l = &mLightsStatic[lightIndex]; - fnCullSpotLightView(&mLightsStatic[lightIndex], mStaticLightCache.mStaticSpotLightFrustumPlanes.at(l)); - } - } - mpCPUProfiler->EndEntry(); - - // Cull Dynamic Lights - mpCPUProfiler->BeginEntry("Cull_ShadowView_Point_d"); - for (int lightIndex : shadowingLightIndices.mDynamicLights.pointLightIndices) - { - std::array frustumPlanesPerFace = - { - mLightsDynamic[lightIndex].GetViewFrustumPlanes(static_cast(0)) - , mLightsDynamic[lightIndex].GetViewFrustumPlanes(static_cast(1)) - , mLightsDynamic[lightIndex].GetViewFrustumPlanes(static_cast(2)) - , mLightsDynamic[lightIndex].GetViewFrustumPlanes(static_cast(3)) - , mLightsDynamic[lightIndex].GetViewFrustumPlanes(static_cast(4)) - , mLightsDynamic[lightIndex].GetViewFrustumPlanes(static_cast(5)) - }; - fnCullPointLightView(&mLightsDynamic[lightIndex], frustumPlanesPerFace); - } - mpCPUProfiler->EndEntry(); - - mpCPUProfiler->BeginEntry("Cull_ShadowView_Spot_d"); - for (int lightIndex : shadowingLightIndices.mDynamicLights.spotLightIndices) - { - const Light* l = &mLightsDynamic[lightIndex]; - fnCullSpotLightView(l, l->GetViewFrustumPlanes()); - } - mpCPUProfiler->EndEntry(); -} - -void Scene::OcclusionCullDirectionalLightView() -{ - // TODO: consider this for directionals: http://stefan-s.net/?p=92 or umbra paper -} - -void Scene::BatchMainViewRenderList(const std::vector mainViewRenderList) -{ - for (int i = 0; i < mainViewRenderList.size(); ++i) - { - const GameObject* pObj = mainViewRenderList[i]; - const ModelData& model = pObj->GetModelData(); - const MeshID meshID = model.mMeshIDs.empty() ? -1 : model.mMeshIDs.front(); - - // instanced is only for built-in meshes (for now) - if (meshID >= EGeometry::MESH_TYPE_COUNT || SceneResourceView::GetMeshRenderMode(this, pObj, meshID) == MeshRenderSettings::WIREFRAME) - { - mSceneView.culledOpaqueList.push_back(std::move(mainViewRenderList[i])); - continue; - } - - const bool bMeshHasMaterial = model.mMaterialLookupPerMesh.find(meshID) != model.mMaterialLookupPerMesh.end(); - if (bMeshHasMaterial) - { - const MaterialID materialID = model.mMaterialLookupPerMesh.at(meshID); - const Material* pMat = mMaterials.GetMaterial_const(materialID); - if (pMat->HasTexture()) - { - mSceneView.culledOpaqueList.push_back(std::move(mainViewRenderList[i])); - continue; - } - } - - RenderListLookup& instancedRenderLists = mSceneView.culluedOpaqueInstancedRenderListLookup; - if (instancedRenderLists.find(meshID) == instancedRenderLists.end()) - { - instancedRenderLists[meshID] = std::vector(); - } - - std::vector& renderList = instancedRenderLists.at(meshID); - renderList.push_back(std::move(mainViewRenderList[i])); - } -} - -void Scene::BatchShadowViewRenderLists(const std::vector & mainViewShadowCasterRenderList) -{ - std::unordered_map>& instancedCasterLists = mShadowView.RenderListsPerMeshType; - - mpCPUProfiler->BeginEntry("Batch_DirectionalView"); - for (int i = 0; i < mainViewShadowCasterRenderList.size(); ++i) - { - const GameObject* pCaster = mainViewShadowCasterRenderList[i]; - const ModelData& model = pCaster->GetModelData(); - const MeshID meshID = model.mMeshIDs.empty() ? -1 : model.mMeshIDs.front(); - if (meshID >= EGeometry::MESH_TYPE_COUNT) - { - mShadowView.casters.push_back(std::move(mainViewShadowCasterRenderList[i])); - continue; - } - - if (instancedCasterLists.find(meshID) == instancedCasterLists.end()) - { - instancedCasterLists[meshID] = std::vector(); - } - std::vector& renderList = instancedCasterLists.at(meshID); - renderList.push_back(std::move(mainViewShadowCasterRenderList[i])); - } - mpCPUProfiler->EndEntry(); - -} - -void Scene::SetLightCache() -{ - mStaticLightCache.Clear(); - - // cache/set static light data - // - // static lights are assumed to not change position and rotations, - // hence, we can cache their frustum planes which are extracted - // from the light-space matrix. This cache would save us matrix - // multiplication and frustum extraction instructions during - // PreRender() - frustum cull lights phase. - // - for (Light& l : mLightsStatic) - { - l.SetMatrices(); - switch (l.mType) - { - case Light::ELightType::SPOT: - mStaticLightCache.mStaticSpotLightFrustumPlanes[&l] = l.GetViewFrustumPlanes(); - break; - case Light::ELightType::POINT: - { - std::array< FrustumPlaneset, 6> planesetPerFace; - for (int i = 0; i < 6; ++i) - planesetPerFace[i] = l.GetViewFrustumPlanes(static_cast(i)); - mStaticLightCache.mStaticPointLightFrustumPlanes[&l] = planesetPerFace; - } break; - } // l.type - } - - // cache/set dynamic light data - for (Light& l : mLightsDynamic) - l.SetMatrices(); - - - // special case for directional lights for now... - // this should eventually be processed with the - // containers above, potentially in the static one. - if (mDirectionalLight.mbEnabled) - { - mDirectionalLight.SetMatrices(); - } -} - -void Scene::ClearLights() -{ - mLightsDynamic.clear(); - mLightsStatic.clear(); - mStaticLightCache.Clear(); -} - -//static void CalculateSceneBoundingBox(Scene* pScene, ) -void Scene::CalculateSceneBoundingBox() -{ - // get the objects for the scene - std::vector pObjects; - for (GameObject& obj : mObjectPool.mObjects) - { - if (obj.mpScene == this && obj.mRenderSettings.bRender) - { - pObjects.push_back(&obj); - } - } - - constexpr float max_f = std::numeric_limits::max(); - vec3 mins(max_f); - vec3 maxs(-(max_f - 1.0f)); - PerfTimer timer; - timer.Start(); - std::for_each(RANGE(pObjects), [&](GameObject* pObj) - { - XMMATRIX worldMatrix = pObj->GetTransform().WorldTransformationMatrix(); - - vec3 mins_obj(max_f); - vec3 maxs_obj(-(max_f - 1.0f)); - - const ModelData& modelData = pObj->GetModelData(); - pObj->mMeshBoundingBoxes.clear(); - std::for_each(RANGE(modelData.mMeshIDs), [&](const MeshID& meshID) - { - const BufferID VertexBufferID = mMeshIDs[meshID].GetIABuffers().first; - const Buffer& VertexBuffer = mpRenderer->GetVertexBuffer(VertexBufferID); - const size_t numVerts = VertexBuffer.mDesc.mElementCount; - const size_t stride = VertexBuffer.mDesc.mStride; - - constexpr size_t defaultSz = sizeof(DefaultVertexBufferData); - constexpr float DegenerateMeshPositionChannelValueMax = 15000.0f; // make sure no vertex.xyz is > 15,000.0f - - // #SHADER REFACTOR: - // - // currently all the shader input is using default vertex buffer data. - // we just make sure that we can interpret the position data properly here - // by ensuring the vertex buffer stride for a given mesh matches - // the default vertex buffer. - // - // TODO: - // Type information is not preserved once the vertex/index buffer is created. - // need to figure out a way to interpret the position data in a given buffer - // - if (stride == defaultSz) - { - const DefaultVertexBufferData* pData = reinterpret_cast(VertexBuffer.mpCPUData); - if (pData == nullptr) - { - Log::Info("Nope: %d", int(stride)); - return; - } - - vec3 mins_mesh(max_f); - vec3 maxs_mesh(-(max_f - 1.0f)); - for (int i = 0; i < numVerts; ++i) - { - const float x_mesh_local = pData[i].position.x(); - const float y_mesh_local = pData[i].position.y(); - const float z_mesh_local = pData[i].position.z(); - - mins_mesh = vec3 - ( - std::min(x_mesh_local, mins_mesh.x()), - std::min(y_mesh_local, mins_mesh.y()), - std::min(z_mesh_local, mins_mesh.z()) - ); - maxs_mesh = vec3 - ( - std::max(x_mesh_local, maxs_mesh.x()), - std::max(y_mesh_local, maxs_mesh.y()), - std::max(z_mesh_local, maxs_mesh.z()) - ); - - - const vec3 worldPos = vec3(XMVector4Transform(vec4(pData[i].position, 1.0f), worldMatrix)); - const float x_mesh = std::min(worldPos.x(), DegenerateMeshPositionChannelValueMax); - const float y_mesh = std::min(worldPos.y(), DegenerateMeshPositionChannelValueMax); - const float z_mesh = std::min(worldPos.z(), DegenerateMeshPositionChannelValueMax); - - - // scene bounding box - world space - mins = vec3 - ( - std::min(x_mesh, mins.x()), - std::min(y_mesh, mins.y()), - std::min(z_mesh, mins.z()) - ); - maxs = vec3 - ( - std::max(x_mesh, maxs.x()), - std::max(y_mesh, maxs.y()), - std::max(z_mesh, maxs.z()) - ); - - // object bounding box - model space - mins_obj = vec3 - ( - std::min(x_mesh_local, mins_obj.x()), - std::min(y_mesh_local, mins_obj.y()), - std::min(z_mesh_local, mins_obj.z()) - ); - maxs_obj = vec3 - ( - std::max(x_mesh_local, maxs_obj.x()), - std::max(y_mesh_local, maxs_obj.y()), - std::max(z_mesh_local, maxs_obj.z()) - ); - } - - pObj->mMeshBoundingBoxes.push_back(BoundingBox({ mins_mesh, maxs_mesh })); - } - else - { - Log::Warning("Unsupported vertex stride for mesh."); - } - }); - - pObj->mBoundingBox.hi = maxs_obj; - pObj->mBoundingBox.low = mins_obj; - }); - - timer.Stop(); - Log::Info("SceneBoundingBox:lo=(%.2f, %.2f, %.2f)\thi=(%.2f, %.2f, %.2f) in %.2fs" - , mins.x() , mins.y() , mins.z() - , maxs.x() , maxs.y() , maxs.z() - , timer.DeltaTime() - ); - this->mSceneBoundingBox.hi = maxs; - this->mSceneBoundingBox.low = mins; -} - - - -//---------------------------------------------------------------------------------------------------------------- -// RESOURCE MANAGEMENT FUNCTIONS -//---------------------------------------------------------------------------------------------------------------- -GameObject* Scene::CreateNewGameObject(){ mpObjects.push_back(mObjectPool.Create(this)); return mpObjects.back(); } - -void Scene::AddLight(const Light& l) -{ - void (Scene::*pfnAddLight)(const Light&) = /* l.mbStatic */ true - // TODO: add boolean to Transform for specifying if its static or not - ? &Scene::AddStaticLight - : &Scene::AddDynamicLight; - (this->*pfnAddLight)(l); -} - -Material* Scene::CreateNewMaterial(EMaterialType type){ return static_cast(mMaterials.CreateAndGetMaterial(type)); } -Material* Scene::CreateRandomMaterialOfType(EMaterialType type) { return static_cast(mMaterials.CreateAndGetRandomMaterial(type)); } - - -//---------------------------------------------------------------------------------------------------------------- -// RENDER FUNCTIONS -//---------------------------------------------------------------------------------------------------------------- -int Scene::RenderOpaque(const FSceneView& sceneView) const -{ - //----------------------------------------------------------------------------------------------- - - struct ObjectMatrices_WorldSpace - { - XMMATRIX wvp; - XMMATRIX w; - XMMATRIX n; - }; - auto ShouldSendMaterial = [](EShaders shader) - { - return (shader == EShaders::FORWARD_PHONG - || shader == EShaders::UNLIT - || shader == EShaders::NORMAL - || shader == EShaders::FORWARD_BRDF); - }; - auto RenderObject = [&](const GameObject* pObj) - { - const Transform& tf = pObj->GetTransform(); - const ModelData& model = pObj->GetModelData(); - - const EShaders shader = static_cast(mpRenderer->GetActiveShader()); - const XMMATRIX world = tf.WorldTransformationMatrix(); - const XMMATRIX wvp = world * sceneView.viewProj; - - switch (shader) - { - case EShaders::TBN: - mpRenderer->SetConstant4x4f("world", world); - mpRenderer->SetConstant4x4f("viewProj", sceneView.viewProj); - mpRenderer->SetConstant4x4f("normalMatrix", tf.NormalMatrix(world)); - break; - case EShaders::NORMAL: - mpRenderer->SetConstant4x4f("normalMatrix", tf.NormalMatrix(world)); - case EShaders::UNLIT: - case EShaders::TEXTURE_COORDINATES: - mpRenderer->SetConstant4x4f("worldViewProj", wvp); - break; - default: // lighting shaders - { - const ObjectMatrices_WorldSpace mats = - { - wvp, - world, - tf.NormalMatrix(world) - }; - mpRenderer->SetConstantStruct("ObjMatrices", &mats); - break; - } - } - - // SET GEOMETRY & MATERIAL, THEN DRAW - mpRenderer->SetRasterizerState(EDefaultRasterizerState::CULL_BACK); - for (MeshID id : model.mMeshIDs) - { - const auto IABuffer = mMeshIDs[id].GetIABuffers(mLODManager.GetLODValue(pObj, id)); - - // SET MATERIAL CONSTANTS - if (ShouldSendMaterial(shader)) - { - const bool bMeshHasMaterial = model.mMaterialLookupPerMesh.find(id) != model.mMaterialLookupPerMesh.end(); - if (bMeshHasMaterial) - { - const MaterialID materialID = model.mMaterialLookupPerMesh.at(id); - const Material* pMat = mMaterials.GetMaterial_const(materialID); - // #TODO: uncomment below when transparency is implemented. - //if (pMat->IsTransparent()) // avoidable branching - perhaps keeping opaque and transparent meshes on separate vectors is better. - // return; - pMat->SetMaterialConstants(mpRenderer, shader, sceneView.bIsDeferredRendering); - } - else - { - mMaterials.GetDefaultMaterial(GGX_BRDF)->SetMaterialConstants(mpRenderer, shader, sceneView.bIsDeferredRendering); - } - } - - mpRenderer->SetVertexBuffer(IABuffer.first); - mpRenderer->SetIndexBuffer(IABuffer.second); - mpRenderer->Apply(); - mpRenderer->DrawIndexed(); - }; - }; - //----------------------------------------------------------------------------------------------- - - // RENDER NON-INSTANCED SCENE OBJECTS - // - int numObj = 0; - for (const auto* obj : mSceneView.culledOpaqueList) - { - RenderObject(obj); - ++numObj; - } - - - - return numObj; -} - -int Scene::RenderAlpha(const FSceneView & sceneView) const -{ - const ShaderID selectedShader = ENGINE->GetSelectedShader(); - const bool bSendMaterialData = ( - selectedShader == EShaders::FORWARD_PHONG - || selectedShader == EShaders::UNLIT - || selectedShader == EShaders::NORMAL - || selectedShader == EShaders::FORWARD_BRDF - ); - - int numObj = 0; - for (const auto* obj : mSceneView.alphaList) - { - obj->RenderTransparent(mpRenderer, sceneView, bSendMaterialData, mMaterials); - ++numObj; - } - return numObj; -} - -int Scene::RenderDebug(const XMMATRIX& viewProj) const -{ - const bool bRenderPointLightCues = true; - const bool bRenderSpotLightCues = true; - const bool bRenderObjectBoundingBoxes = false; - const bool bRenderMeshBoundingBoxes = false; - const bool bRenderSceneBoundingBox = true; - - const auto IABuffersCube = mMeshIDs[EGeometry::CUBE].GetIABuffers(); - const auto IABuffersSphere = mMeshIDs[EGeometry::SPHERE].GetIABuffers(); - const auto IABuffersCone = mMeshIDs[EGeometry::LIGHT_CUE_CONE].GetIABuffers(); - - XMMATRIX wvp; - - // set debug render states - mpRenderer->SetShader(EShaders::UNLIT); - mpRenderer->SetConstant3f("diffuse", LinearColor::yellow); - mpRenderer->SetConstant1f("isDiffuseMap", 0.0f); - mpRenderer->BindDepthTarget(ENGINE->GetWorldDepthTarget()); - mpRenderer->SetDepthStencilState(EDefaultDepthStencilState::DEPTH_TEST_ONLY); - mpRenderer->SetBlendState(EDefaultBlendState::DISABLED); - mpRenderer->SetRasterizerState(EDefaultRasterizerState::WIREFRAME); - mpRenderer->SetVertexBuffer(IABuffersCube.first); - mpRenderer->SetIndexBuffer(IABuffersCube.second); - - - // SCENE BOUNDING BOX - // - if (bRenderSceneBoundingBox) - { - wvp = mSceneBoundingBox.GetWorldTransformationMatrix() * viewProj; - mpRenderer->SetConstant4x4f("worldViewProj", wvp); - mpRenderer->Apply(); - mpRenderer->DrawIndexed(); - } - - // GAME OBJECT OBB & MESH BOUNDING BOXES - // - int numRenderedObjects = 0; - if (bRenderObjectBoundingBoxes) - { - std::vector pObjects( - mSceneView.opaqueList.size() + mSceneView.alphaList.size() - , nullptr - ); - std::copy(RANGE(mSceneView.opaqueList), pObjects.begin()); - std::copy(RANGE(mSceneView.alphaList), pObjects.begin() + mSceneView.opaqueList.size()); - for (const GameObject* pObj : pObjects) - { - const XMMATRIX matWorld = pObj->GetTransform().WorldTransformationMatrix(); - wvp = pObj->mBoundingBox.GetWorldTransformationMatrix() * matWorld * viewProj; -#if 1 - mpRenderer->SetConstant3f("diffuse", LinearColor::cyan); - mpRenderer->SetConstant4x4f("worldViewProj", wvp); - mpRenderer->Apply(); - mpRenderer->DrawIndexed(); -#endif - - // mesh bounding boxes (currently broken...) - if (bRenderMeshBoundingBoxes) - { - mpRenderer->SetConstant3f("diffuse", LinearColor::orange); -#if 0 - for (const MeshID meshID : pObj->mModel.mData.mMeshIDs) - { - wvp = pObj->mMeshBoundingBoxes[meshID].GetWorldTransformationMatrix() * matWorld * viewProj; - mpRenderer->SetConstant4x4f("worldViewProj", wvp); - mpRenderer->Apply(); - mpRenderer->DrawIndexed(); - } -#endif - } - } - numRenderedObjects = (int)pObjects.size(); - } - - // LIGHT VOLUMES - // - mpRenderer->SetConstant3f("diffuse", LinearColor::yellow); - - // light's transform hold Translation and Rotation data, - // Scale is used for rendering. Hence, we use another transform - // here to use mRange as the lights render scale signifying its - // radius of influence. - Transform tf; - constexpr size_t NUM_LIGHT_CONTAINERS = 2; - std::array*, NUM_LIGHT_CONTAINERS > lightContainers = - { - &mLightsStatic - , &mLightsDynamic - }; - for (int i = 0; i < NUM_LIGHT_CONTAINERS; ++i) - { - const std::vector& mLights = *lightContainers[i]; - // point lights - if (bRenderPointLightCues) - { - mpRenderer->SetVertexBuffer(IABuffersSphere.first); - mpRenderer->SetIndexBuffer(IABuffersSphere.second); - for (const Light& l : mLights) - { - if (l.mType == Light::ELightType::POINT) - { - mpRenderer->SetConstant3f("diffuse", l.mColor); - - tf.SetPosition(l.mTransform._position); - tf.SetScale(l.mRange * 0.5f); // Mesh's model space R = 2.0f, hence scale it by 0.5f... - wvp = tf.WorldTransformationMatrix() * viewProj; - mpRenderer->SetConstant4x4f("worldViewProj", wvp); - mpRenderer->Apply(); - mpRenderer->DrawIndexed(); - } - } - } - - // spot lights - if (bRenderSpotLightCues) - { - mpRenderer->SetVertexBuffer(IABuffersCone.first); - mpRenderer->SetIndexBuffer(IABuffersCone.second); - for (const Light& l : mLights) - { - if (l.mType == Light::ELightType::SPOT) - { - mpRenderer->SetConstant3f("diffuse", l.mColor); - - tf = l.mTransform; - - // reset scale as it holds the scale value for light's render mesh - tf.SetScale(1, 1, 1); - - // align with spot light's local space - tf.RotateAroundLocalXAxisDegrees(-90.0f); - - - XMMATRIX alignConeToSpotLightTransformation = XMMatrixIdentity(); - alignConeToSpotLightTransformation.r[3].m128_f32[0] = 0.0f; - alignConeToSpotLightTransformation.r[3].m128_f32[1] = -l.mRange; - alignConeToSpotLightTransformation.r[3].m128_f32[2] = 0.0f; - //tf.SetScale(1, 20, 1); - - const float coneBaseRadius = std::tanf(l.mSpotOuterConeAngleDegrees * DEG2RAD) * l.mRange; - XMMATRIX scaleConeToRange = XMMatrixIdentity(); - scaleConeToRange.r[0].m128_f32[0] = coneBaseRadius; - scaleConeToRange.r[1].m128_f32[1] = l.mRange; - scaleConeToRange.r[2].m128_f32[2] = coneBaseRadius; - - //wvp = alignConeToSpotLightTransformation * tf.WorldTransformationMatrix() * viewProj; - wvp = scaleConeToRange * alignConeToSpotLightTransformation * tf.WorldTransformationMatrix() * viewProj; - mpRenderer->SetConstant4x4f("worldViewProj", wvp); - mpRenderer->Apply(); - mpRenderer->DrawIndexed(); - } - } - } - } - - - // TODO: CAMERA FRUSTUM - // - if (mCameras.size() > 1 && mSelectedCamera != 0 && false) - { - // render camera[0]'s frustum - const XMMATRIX viewProj = mCameras[mSelectedCamera].GetViewMatrix() * mCameras[mSelectedCamera].GetProjectionMatrix(); - - auto a = FrustumPlaneset::ExtractFromMatrix(viewProj); // world space frustum plane equations - - // IA: model space camera frustum - // world matrix from camera[0] view ray - // viewProj from camera[selected] - mpRenderer->SetConstant3f("diffuse", LinearColor::orange); - - - Transform tf; - //const vec3 diag = this->hi - this->low; - //const vec3 pos = (this->hi + this->low) * 0.5f; - //tf.SetScale(diag * 0.5f); - //tf.SetPosition(pos); - XMMATRIX wvp = tf.WorldTransformationMatrix() * viewProj; - //mpRenderer->SetConstant4x4f("worldViewProj", wvp); - mpRenderer->Apply(); - mpRenderer->DrawIndexed(); - } - - mpRenderer->UnbindDepthTarget(); - mpRenderer->SetRasterizerState(EDefaultRasterizerState::CULL_NONE); - mpRenderer->Apply(); - - - return numRenderedObjects; // objects rendered -} - - -void Scene::RenderLights() const -{ - if (!this->mSceneView.bIsIBLEnabled) - return; - - mpRenderer->BeginEvent("Render Lights Pass"); - mpRenderer->SetShader(EShaders::UNLIT); - mpRenderer->SetDepthStencilState(EDefaultDepthStencilState::DEPTH_TEST_ONLY); - constexpr size_t NUM_LIGHT_CONTAINERS = 2; - std::array*, NUM_LIGHT_CONTAINERS > lightContainers = - { - &mLightsStatic - , &mLightsDynamic - }; - - for (int i = 0; i < NUM_LIGHT_CONTAINERS; ++i) - { - const std::vector& mLights = *lightContainers[i]; - for (const Light& light : mLights) - { - //if (!light._bEnabled) continue; // #BreaksRelease - - if (light.mType == Light::ELightType::DIRECTIONAL) - continue; // do not render directional lights - - const auto IABuffers = mBuiltinMeshes[light.mMeshID].GetIABuffers(); - const XMMATRIX world = light.mTransform.WorldTransformationMatrix(); - const XMMATRIX worldViewProj = world * this->mSceneView.viewProj; - const vec3 color = light.mColor.Value() * light.mBrightness; - - mpRenderer->SetVertexBuffer(IABuffers.first); - mpRenderer->SetIndexBuffer(IABuffers.second); - mpRenderer->SetConstant4x4f("worldViewProj", worldViewProj); - mpRenderer->SetConstant3f("diffuse", color); - mpRenderer->SetConstant1f("isDiffuseMap", 0.0f); - mpRenderer->Apply(); - mpRenderer->DrawIndexed(); - } - } - mpRenderer->EndEvent(); -} - - -void Scene::RenderSkybox(const XMMATRIX& viewProj) const -{ - const XMMATRIX& wvp = viewProj; - const auto IABuffers = Scene::GetGeometryVertexAndIndexBuffers(EGeometry::CUBE); - - mpRenderer->BeginEvent("Skybox Pass"); - mpRenderer->SetViewport(mpRenderer->FrameRenderTargetDimensionsAsFloat2()); - mpRenderer->SetShader(mSkybox.GetShader()); - mpRenderer->SetDepthStencilState(EDefaultDepthStencilState::DEPTH_TEST_ONLY); - mpRenderer->SetRasterizerState(EDefaultRasterizerState::CULL_NONE); - mpRenderer->SetConstant4x4f("worldViewProj", wvp); - mpRenderer->SetTexture("texSkybox", mSkybox.GetSkyboxTexture()); - //mpRenderer->SetSamplerState("samWrap", EDefaultSamplerState::WRAP_SAMPLER); - mpRenderer->SetSamplerState("samWrap", EDefaultSamplerState::LINEAR_FILTER_SAMPLER_WRAP_UVW); - mpRenderer->SetVertexBuffer(IABuffers.first); - mpRenderer->SetIndexBuffer(IABuffers.second); - mpRenderer->Apply(); - mpRenderer->DrawIndexed(); - mpRenderer->EndEvent(); -} - - -#endif \ No newline at end of file diff --git a/Source/Application/Scene.h b/Source/Application/Scene.h index d88a830b..6527c6f2 100644 --- a/Source/Application/Scene.h +++ b/Source/Application/Scene.h @@ -27,10 +27,8 @@ class Input; -// TODO: - -#if 1 +//------------------------------------------------------ struct GameObjectRepresentation { @@ -55,6 +53,8 @@ struct FSceneRepresentation char loadSuccess = 0; }; +//------------------------------------------------------ + struct FPostProcessParameters { EColorSpace ContentColorSpace = EColorSpace::REC_709; @@ -62,6 +62,15 @@ struct FPostProcessParameters float DisplayReferenceBrightnessLevel = 200.0f; int ToggleGammaCorrection = 1; }; + + +struct FMeshRenderCommand +{ + MeshID meshID = INVALID_ID; + MaterialID matID = INVALID_ID; + DirectX::XMMATRIX WorldTransformationMatrix; +}; + struct FSceneView { DirectX::XMMATRIX view; @@ -79,20 +88,9 @@ struct FSceneView FPostProcessParameters postProcess; - - -#if 0 - // list of objects that has the renderSettings.bRender=true - RenderList opaqueList; - RenderList alphaList; - - // list of objects that fall within the main camera's view frustum - RenderList culledOpaqueList; - RenderListLookup culluedOpaqueInstancedRenderListLookup; -#endif + std::vector meshRenderCommands; }; - constexpr size_t NUM_GAMEOBJECT_POOL_SIZE = 4096; constexpr size_t GAMEOBJECT_BYTE_ALIGNMENT = 64; // assumed typical cache-line size @@ -231,328 +229,3 @@ class Scene //ShadowView mShadowView; }; - -#else -#include "Settings.h" // todo: is this needed? -#include "Skybox.h" -#include "GameObjectPool.h" -#include "SceneView.h" -#include "SceneLODManager.h" - -#include -#include -#include - - -struct FSceneRepresentation; -struct FSceneView; -struct ShadowView; -struct DrawLists; - -class SceneManager; -class Renderer; -class TextRenderer; -class MaterialPool; -class CPUProfiler; - -#define DO_NOT_LOAD_SCENES 0 - -struct ModelLoadQueue -{ - std::mutex mutex; - std::unordered_map objectModelMap; - std::unordered_map> asyncModelResults; -}; - -//---------------------------------------------------------------------------------------------------------------- -// https://en.wikipedia.org/wiki/Template_method_pattern -// https://stackoverflow.com/questions/9724371/force-calling-base-class-virtual-function -// https://isocpp.org/wiki/faq/strange-inheritance#two-strategies-for-virtuals -// template method seems like a good idea here: -// base class takes care of the common tasks among all scenes and calls the -// customized functions of the derived classes through pure virtual functions -//---------------------------------------------------------------------------------------------------------------- -class Scene -{ -//---------------------------------------------------------------------------------------------------------------- -// INTERFACE FOR SCENE INSTANCES -//---------------------------------------------------------------------------------------------------------------- -protected: - - // Update() is called each frame before Engine::Render(). Scene-specific update logic goes here. - // - virtual void Update(float dt) = 0; - - // Scene-specific loading logic goes here - // - virtual void Load(FSceneRepresentation& scene) = 0; - - // Scene-specific unloading logic goes here - // - virtual void Unload() = 0; - - // Each scene has to implement scene-specific RenderUI() function. - // RenderUI() is called after post processing is finished and it is - // the last rendering workload before presenting the frame. - // - virtual void RenderUI() const = 0; - - //------------------------------------------------------------------------ - - // - // SCENE RESOURCE MANAGEMENT - // -#if 0 - // Use this function to programmatically create new objects in the scene. - // - GameObject* CreateNewGameObject(); - - // Updates the scene's bounding box boundaries. This has to be called after - // a new game object added to a scene (or after getting done adding multiple - // game objects as this needs to be called only once). - // - void CalculateSceneBoundingBox(); - - // Adds a light to the scene resources. Scene manager differentiates between - // static and dynamic (moving and non-moving) lights for optimization reasons. - // - void AddLight(const Light& l); - - // Use this function to programmatically create new lights in the scene. - // TODO: finalize design after light refactor - // - //Light* CreateNewLight(); - - // Loads an assimp model - blocks the thread until the model loads - // - Model LoadModel(const std::string& modelPath); - - // Queues a task for loading an assimp model for the GameObject* pObject - // - ModelData will be assigned when the models finish loading which is sometime - // after Load() and before Render(), it won't be immediately available. - // - void LoadModel_Async(GameObject* pObject, const std::string& modelPath); -#endif - -//---------------------------------------------------------------------------------------------------------------- -// ENGINE INTERFACE -//---------------------------------------------------------------------------------------------------------------- -public: - struct BaseSceneParams - { - VQRenderer* pRenderer = nullptr; - //TextRenderer* pTextRenderer = nullptr; - //CPUProfiler* pCPUProfiler = nullptr; - }; - Scene(const BaseSceneParams& params); - ~Scene() = default; - - - // Moves objects from FSceneRepresentation into objects vector and sets the scene pointer in objects - // - void LoadScene(FSceneRepresentation& scene, const Settings::Window& windowSettings); - - // Clears object/light containers and camera settings - // - void UnloadScene(); - - // Updates selected camera and calls overridden Update from derived scene class - // - void UpdateScene(float dt); - -#if 0 - // Prepares the scene and shadow views for culling, sorting, instanced draw lists, lights, etc. - // - void PreRender(FrameStats& stats, SceneLightingConstantBuffer & outLightingData); - - - // Renders the meshes in the scene which have materials with alpha=1.0f - // - int RenderOpaque(const FSceneView& sceneView) const; - - // Renders the transparent meshes in the scene, on a separate draw pass - // - int RenderAlpha(const FSceneView& sceneView) const; - - // Renders debugging information such as bounding boxes, wireframe meshes, etc. - // - int RenderDebug(const XMMATRIX& viewProj) const; - - void RenderLights() const; - void RenderSkybox(const XMMATRIX& viewProj) const; - - - // Use these functions to programmatically create material instances which you can add to game objects in the scene. - // - Material* CreateNewMaterial(EMaterialType type); // - Material* CreateRandomMaterialOfType(EMaterialType type); // - - // ??? - // - MeshID AddMesh_Async(Mesh m); -#endif - - // note: this function introduces plenty of header includes in many areas. - // at this point, its probably worth considering elsewhere. - ///static inline std::pair GetGeometryVertexAndIndexBuffers(EGeometry GeomEnum, int lod = 0) { return mBuiltinMeshes[GeomEnum].GetIABuffers(lod); } - - // TODO: Move all this to SceneResourceView - // Getters - // - inline const EnvironmentMap& GetEnvironmentMap() const { return mSkybox.GetEnvironmentMap(); } - inline const Camera& GetActiveCamera() const { return mCameras[mSelectedCamera]; } - inline const Settings::SceneRender& GetSceneRenderSettings() const { return mSceneRenderSettings; } - inline const std::vector& GetDynamicLights() { return mLightsDynamic; } - inline EEnvironmentMapPresets GetActiveEnvironmentMapPreset() const { return mActiveSkyboxPreset; } - inline const std::vector& GetBuiltInMeshes() const { return mBuiltinMeshes; } - - inline bool HasSkybox() const { return mSkybox.GetSkyboxTexture() != -1; } - - // Setters - // - void SetEnvironmentMap(EEnvironmentMapPresets preset); - void ResetActiveCamera(); - - -protected: - //---------------------------------------------------------------------------------------------------------------- - // SCENE DATA - //---------------------------------------------------------------------------------------------------------------- - friend class SceneResourceView; // using attorney method, alternatively can use friend function - friend class ModelLoader; - - // - // SCENE RESOURCE CONTAINERS - // - //static std::vector mBuiltinMeshes; - //static void InitializeBuiltinMeshes(); - std::vector mTransforms; - std::vector mMeshIDs; - std::vector mCameras; - std::vector mpObjects; - Light mDirectionalLight; - std::vector mLightsStatic; // non-moving lights - std::vector mLightsDynamic; // moving lights - //Skybox mSkybox; - - - // - // SCENE STATE - // - EEnvironmentMapPresets mActiveSkyboxPreset; - int mSelectedCamera; - Settings::SceneRender mSceneRenderSettings; - - - // - // SYSTEMS - // - VQRenderer* mpRenderer; - //TextRenderer* mpTextRenderer; - ThreadPool* mpThreadPool; // initialized by the Engine - LODManager mLODManager; - -private: - //---------------------------------------------------------------------------------------------------------------- - // INTERNAL DATA - //---------------------------------------------------------------------------------------------------------------- - // - // LIGHTS - // - struct ShadowingLightIndexCollection - { - inline void Clear() { spotLightIndices.clear(); pointLightIndices.clear(); } - std::vector spotLightIndices; - std::vector pointLightIndices; - }; - struct SceneShadowingLightIndexCollection - { - inline void Clear() { mStaticLights.Clear(); mDynamicLights.Clear(); } - inline size_t GetLightCount(Light::ELightType type) const - { - switch (type) - { - case Light::POINT: return mStaticLights.pointLightIndices.size() + mDynamicLights.pointLightIndices.size(); break; - case Light::SPOT : return mStaticLights.spotLightIndices.size() + mDynamicLights.spotLightIndices.size(); break; - default: return 0; - } - } - inline std::vector GetFlattenedListOfLights(const std::vector& staticLights, const std::vector& dynamicLights) const - { - std::vector pLights; - for (const int& i : mStaticLights.spotLightIndices) pLights.push_back(&staticLights[i]); - for (const int& i : mStaticLights.pointLightIndices) pLights.push_back(&staticLights[i]); - for (const int& i : mDynamicLights.spotLightIndices) pLights.push_back(&dynamicLights[i]); - for (const int& i : mDynamicLights.pointLightIndices) pLights.push_back(&dynamicLights[i]); - return pLights; - } - ShadowingLightIndexCollection mStaticLights; - ShadowingLightIndexCollection mDynamicLights; - }; - - // Static lights will not change position or orientation. Here, we cache - // some light data based on this assumption, such as frustum planes. - // - struct StaticLightCache - { - std::unordered_map> mStaticPointLightFrustumPlanes; - std::unordered_map mStaticSpotLightFrustumPlanes; - void Clear() { mStaticPointLightFrustumPlanes.clear(); mStaticSpotLightFrustumPlanes.clear(); } - }; - - StaticLightCache mStaticLightCache; - - friend class Engine; - - GameObjectPool mObjectPool; - MaterialPool mMaterials; - ModelLoader mModelLoader; - ModelLoadQueue mModelLoadQueue; - - std::mutex mSceneMeshMutex; - - - BoundingBox mSceneBoundingBox; - - - FSceneView mSceneView; - ShadowView mShadowView; - - CPUProfiler* mpCPUProfiler; - - -private: - - void StartLoadingModels(); - void EndLoadingModels(); - - void AddStaticLight(const Light& l); - void AddDynamicLight(const Light& l); - - //------------------------------- - // PreRender() ROUTINES - //------------------------------- - void SetSceneViewData(); - - void GatherSceneObjects(std::vector & mainViewShadowCasterRenderList, int& outNumSceneObjects); - void GatherLightData(SceneLightingConstantBuffer& outLightingData, const std::vector& pLightList); - - void SortRenderLists(std::vector & mainViewShadowCasterRenderList, std::vector& pShadowingLights); - - SceneShadowingLightIndexCollection CullShadowingLights(int& outNumCulledPoints, int& outNumCulledSpots); // culls lights against main view - std::vector FrustumCullMainView(int& outNumCulledObjects); - void FrustumCullPointAndSpotShadowViews(const std::vector & mainViewShadowCasterRenderList, const SceneShadowingLightIndexCollection& shadowingLightIndices, FrameStats& stats); - void OcclusionCullDirectionalLightView(); - - void BatchMainViewRenderList(const std::vector mainViewRenderList); - void BatchShadowViewRenderLists(const std::vector & mainViewShadowCasterRenderList); - //------------------------------- - - void SetLightCache(); - void ClearLights(); -}; - - - - -#endif \ No newline at end of file diff --git a/Source/Application/VQEngine_Render.cpp b/Source/Application/VQEngine_Render.cpp index 84d5a463..6e879a68 100644 --- a/Source/Application/VQEngine_Render.cpp +++ b/Source/Application/VQEngine_Render.cpp @@ -705,43 +705,46 @@ void VQEngine::RenderSceneColor(FWindowRenderContext& ctx, const FSceneView& Sce pCmd->SetPipelineState(mRenderer.GetPSO(bMSAA ? EBuiltinPSOs::HELLO_WORLD_CUBE_PSO_MSAA_4 : EBuiltinPSOs::HELLO_WORLD_CUBE_PSO)); - // Draw Object ----------------------------------------------- -#if 0 + // Draw Objects ----------------------------------------------- using namespace DirectX; - const XMMATRIX mMVP - = FrameData.TFCube.WorldTransformationMatrix() - * SceneView.viewProj; + for (const FMeshRenderCommand& meshRenderCmd : SceneView.meshRenderCommands) + { + const XMMATRIX mMVP + = meshRenderCmd.WorldTransformationMatrix + * SceneView.viewProj; - ID3D12DescriptorHeap* ppHeaps[] = { mRenderer.GetDescHeap(EResourceHeapType::CBV_SRV_UAV_HEAP) }; + ID3D12DescriptorHeap* ppHeaps[] = { mRenderer.GetDescHeap(EResourceHeapType::CBV_SRV_UAV_HEAP) }; - // set constant buffer data - FrameConstantBuffer* pConstBuffer = {}; - D3D12_GPU_VIRTUAL_ADDRESS cbAddr = {}; - ctx.mDynamicHeap_ConstantBuffer.AllocConstantBuffer(sizeof(FrameConstantBuffer), (void**)(&pConstBuffer), &cbAddr); - pConstBuffer->matModelViewProj = mMVP; + // set constant buffer data + FrameConstantBuffer* pConstBuffer = {}; + D3D12_GPU_VIRTUAL_ADDRESS cbAddr = {}; + ctx.mDynamicHeap_ConstantBuffer.AllocConstantBuffer(sizeof(FrameConstantBuffer), (void**)(&pConstBuffer), &cbAddr); + pConstBuffer->matModelViewProj = mMVP; - // hardcoded root signature for now until shader reflection and rootsignature management is implemented - pCmd->SetGraphicsRootSignature(mRenderer.GetRootSignature(2)); + // hardcoded root signature for now until shader reflection and rootsignature management is implemented + pCmd->SetGraphicsRootSignature(mRenderer.GetRootSignature(2)); - pCmd->SetDescriptorHeaps(_countof(ppHeaps), ppHeaps); - pCmd->SetGraphicsRootDescriptorTable(0, mRenderer.GetSRV(0).GetGPUDescHandle()); - pCmd->SetGraphicsRootConstantBufferView(1, cbAddr); + pCmd->SetDescriptorHeaps(_countof(ppHeaps), ppHeaps); + pCmd->SetGraphicsRootDescriptorTable(0, mRenderer.GetSRV(0).GetGPUDescHandle()); + pCmd->SetGraphicsRootConstantBufferView(1, cbAddr); - const Mesh& mesh = mBuiltinMeshes[EBuiltInMeshes::CUBE]; - const auto VBIBIDs = mesh.GetIABufferIDs(); - const uint32 NumIndices = mesh.GetNumIndices(); - const uint32 NumInstances = 1; - const BufferID& VB_ID = VBIBIDs.first; - const BufferID& IB_ID = VBIBIDs.second; - const VBV& vb = mRenderer.GetVertexBufferView(VB_ID); - const IBV& ib = mRenderer.GetIndexBufferView(IB_ID); + const Mesh& mesh = mBuiltinMeshes[meshRenderCmd.meshID]; + const auto VBIBIDs = mesh.GetIABufferIDs(); + const uint32 NumIndices = mesh.GetNumIndices(); + const uint32 NumInstances = 1; + const BufferID& VB_ID = VBIBIDs.first; + const BufferID& IB_ID = VBIBIDs.second; + const VBV& vb = mRenderer.GetVertexBufferView(VB_ID); + const IBV& ib = mRenderer.GetIndexBufferView(IB_ID); + + pCmd->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST); + pCmd->IASetVertexBuffers(0, 1, &vb); + pCmd->IASetIndexBuffer(&ib); + + pCmd->DrawIndexedInstanced(NumIndices, NumInstances, 0, 0, 0); + } - pCmd->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST); - pCmd->IASetVertexBuffers(0, 1, &vb); - pCmd->IASetIndexBuffer(&ib); - pCmd->DrawIndexedInstanced(NumIndices, NumInstances, 0, 0, 0); -#endif // Draw Environment Map --------------------------------------- const bool bHasEnvironmentMapHDRTexture = mResources_MainWnd.EnvironmentMap.SRV_HDREnvironment != INVALID_ID; diff --git a/Source/Application/VQEngine_Update.cpp b/Source/Application/VQEngine_Update.cpp index 3ac638d6..7273cc16 100644 --- a/Source/Application/VQEngine_Update.cpp +++ b/Source/Application/VQEngine_Update.cpp @@ -153,8 +153,6 @@ void VQEngine::UpdateThread_PostUpdate() mpScene->PostUpdate(FRAME_DATA_INDEX, FRAME_DATA_NEXT_INDEX); - // TODO: compute visibility - // input post update for (auto it = mInputStates.begin(); it != mInputStates.end(); ++it) { From b57fa32079ec5c37a2bbfe05234277a0b2bf4413 Mon Sep 17 00:00:00 2001 From: Volkan Date: Mon, 17 Aug 2020 02:47:51 -0700 Subject: [PATCH 07/67] Wire up custom scene logic break up VQEngine_Main and move parsing logic into new file --- CMakeLists.txt | 1 + Data/Levels/Default.xml | 7 +- Source/Application/FileParser.cpp | 625 +++++++++++++++++++++++++++ Source/Application/Scene.cpp | 3 + Source/Application/Scene.h | 13 +- Source/Application/VQEngine_Main.cpp | 598 +------------------------ Source/Scenes/DefaultScene.cpp | 57 ++- Source/Scenes/Scenes.h | 4 +- Source/Scenes/Sponza.cpp | 5 + 9 files changed, 689 insertions(+), 624 deletions(-) create mode 100644 Source/Application/FileParser.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 7b1ef1e8..d44b6cec 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -72,6 +72,7 @@ set (SourceVQE "Source/Application/VQEngine_Update.cpp" "Source/Application/VQEngine_WindowEvents.cpp" "Source/Application/VQEngine_EventHandlers.cpp" + "Source/Application/FileParser.cpp" "Source/Application/Events.cpp" "Source/Application/Mesh.cpp" "Source/Application/Model.cpp" diff --git a/Data/Levels/Default.xml b/Data/Levels/Default.xml index 624d33b1..e14c9734 100644 --- a/Data/Levels/Default.xml +++ b/Data/Levels/Default.xml @@ -61,11 +61,12 @@ 9.5 + - -1.0 5 2 - 0 3.14 0 1 - 3 4 5 + 0.0 3.0 -14 + 30 0 15 + 3.1 3.1 3.1 Cube diff --git a/Source/Application/FileParser.cpp b/Source/Application/FileParser.cpp new file mode 100644 index 00000000..0bc15b15 --- /dev/null +++ b/Source/Application/FileParser.cpp @@ -0,0 +1,625 @@ +// VQE +// Copyright(C) 2020 - Volkan Ilbeyli +// +// This program is free software : you can redistribute it and / or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program.If not, see . +// +// Contact: volkanilbeyli@gmail.com + +#include "VQEngine.h" + +#include "Libs/VQUtils/Source/utils.h" +#include "Libs/VQUtils/Libs/tinyxml2/tinyxml2.h" + +#include +#include + +#ifdef _DEBUG +constexpr char* BUILD_CONFIG = "-Debug"; +#else +constexpr char* BUILD_CONFIG = ""; +#endif +constexpr char* VQENGINE_VERSION = "v0.5.0"; + + +static std::pair ParseLineINI(const std::string& iniLine, bool* pbSectionTag) +{ + assert(!iniLine.empty()); + std::pair SettingNameValuePair; + + const bool bSectionTag = iniLine[0] == '['; + if(pbSectionTag) + *pbSectionTag = bSectionTag; + + if (bSectionTag) + { + auto vecSettingNameValue = StrUtil::split(iniLine.substr(1), ']'); + SettingNameValuePair.first = vecSettingNameValue[0]; + } + else + { + auto vecSettingNameValue = StrUtil::split(iniLine, '='); + assert(vecSettingNameValue.size() >= 2); + SettingNameValuePair.first = vecSettingNameValue[0]; + SettingNameValuePair.second = vecSettingNameValue[1]; + } + + return SettingNameValuePair; +} + +static std::unordered_map S_LOOKUP_STR_TO_DISPLAYMODE = +{ + { "Fullscreen" , EDisplayMode::EXCLUSIVE_FULLSCREEN } + , { "Borderless" , EDisplayMode::BORDERLESS_FULLSCREEN } + , { "BorderlessFullscreen" , EDisplayMode::BORDERLESS_FULLSCREEN } + , { "BorderlessWindowed" , EDisplayMode::BORDERLESS_FULLSCREEN } + , { "Windowed" , EDisplayMode::WINDOWED } +}; + + + +FStartupParameters VQEngine::ParseEngineSettingsFile() +{ + constexpr char* ENGINE_SETTINGS_FILE_NAME = "Data/EngineSettings.ini"; + FStartupParameters params = {}; + + std::ifstream file(ENGINE_SETTINGS_FILE_NAME); + if (file.is_open()) + { + std::string line; + std::string currSection; + bool bReadingSection = false; + while (std::getline(file, line)) + { + if (line[0] == ';') continue; // skip comment lines + if (line == "") continue; // skip empty lines + + const std::pair SettingNameValuePair = ParseLineINI(line, &bReadingSection); + const std::string& SettingName = SettingNameValuePair.first; + const std::string& SettingValue = SettingNameValuePair.second; + + // Header sections; + if (bReadingSection) + { + currSection = SettingName; + continue; + } + + + // + // Graphics + // + if (SettingName == "VSync") + { + params.bOverrideGFXSetting_bVSync = true; + params.EngineSettings.gfx.bVsync = StrUtil::ParseBool(SettingValue); + } + if (SettingName == "RenderScale") + { + params.bOverrideGFXSetting_RenderScale = true; + params.EngineSettings.gfx.RenderScale = StrUtil::ParseFloat(SettingValue); + } + if (SettingName == "TripleBuffer") + { + params.bOverrideGFXSetting_bUseTripleBuffering = true; + params.EngineSettings.gfx.bUseTripleBuffering = StrUtil::ParseBool(SettingValue); + } + if (SettingName == "AntiAliasing" || SettingName == "AA") + { + params.bOverrideGFXSetting_bAA = true; + params.EngineSettings.gfx.bAntiAliasing = StrUtil::ParseBool(SettingValue); + } + if (SettingName == "MaxFrameRate" || SettingName == "MaxFPS") + { + params.bOverrideGFXSetting_bMaxFrameRate = true; + if (SettingValue == "Unlimited" || SettingValue == "0") + params.EngineSettings.gfx.MaxFrameRate = 0; + else if (SettingValue == "Auto" || SettingValue == "Automatic" || SettingValue == "-1") + params.EngineSettings.gfx.MaxFrameRate = -1; + else + params.EngineSettings.gfx.MaxFrameRate = StrUtil::ParseInt(SettingValue); + } + + // + // Engine + // + if (SettingName == "Width") + { + params.bOverrideENGSetting_MainWindowWidth = true; + params.EngineSettings.WndMain.Width = StrUtil::ParseInt(SettingValue); + } + if (SettingName == "Height") + { + params.bOverrideENGSetting_MainWindowHeight = true; + params.EngineSettings.WndMain.Height = StrUtil::ParseInt(SettingValue); + } + if (SettingName == "DisplayMode") + { + if (S_LOOKUP_STR_TO_DISPLAYMODE.find(SettingValue) != S_LOOKUP_STR_TO_DISPLAYMODE.end()) + { + params.bOverrideENGSetting_bDisplayMode = true; + params.EngineSettings.WndMain.DisplayMode = S_LOOKUP_STR_TO_DISPLAYMODE.at(SettingValue); + } + } + if (SettingName == "PreferredDisplay") + { + params.bOverrideENGSetting_PreferredDisplay = true; + params.EngineSettings.WndMain.PreferredDisplay = StrUtil::ParseInt(SettingValue); + } + if (SettingName == "HDR") + { + params.bOverrideGFXSetting_bHDR = true; + params.EngineSettings.WndMain.bEnableHDR = StrUtil::ParseBool(SettingValue); + } + + + if (SettingName == "DebugWindow") + { + params.bOverrideENGSetting_bDebugWindowEnable = true; + params.EngineSettings.bShowDebugWindow = StrUtil::ParseBool(SettingValue); + } + if (SettingName == "DebugWindowWidth") + { + params.bOverrideENGSetting_DebugWindowWidth = true; + params.EngineSettings.WndDebug.Width = StrUtil::ParseInt(SettingValue); + } + if (SettingName == "DebugWindowHeight") + { + params.bOverrideENGSetting_DebugWindowHeight = true; + params.EngineSettings.WndDebug.Height = StrUtil::ParseInt(SettingValue); + } + if (SettingName == "DebugWindowDisplayMode") + { + if (S_LOOKUP_STR_TO_DISPLAYMODE.find(SettingValue) != S_LOOKUP_STR_TO_DISPLAYMODE.end()) + { + params.bOverrideENGSetting_DebugWindowDisplayMode = true; + params.EngineSettings.WndDebug.DisplayMode = S_LOOKUP_STR_TO_DISPLAYMODE.at(SettingValue); + } + } + if (SettingName == "DebugWindowPreferredDisplay") + { + params.bOverrideENGSetting_DebugWindowPreferredDisplay = true; + params.EngineSettings.WndDebug.PreferredDisplay = StrUtil::ParseInt(SettingValue); + } + + if (SettingName == "Scene") + { + params.bOverrideENGSetting_StartupScene = true; + params.EngineSettings.StartupScene = SettingValue; + } + + } + } + else + { + Log::Warning("Cannot find settings file %s in current directory: %s", ENGINE_SETTINGS_FILE_NAME, DirectoryUtil::GetCurrentPath().c_str()); + Log::Warning("Will use default settings for Engine & Graphics.", ENGINE_SETTINGS_FILE_NAME, DirectoryUtil::GetCurrentPath().c_str()); + } + + file.close(); + + return params; +} + +std::vector> VQEngine::ParseSceneIndexMappingFile() +{ + constexpr char* SCENE_MAPPING_FILE_NAME = "Data/Scenes.ini"; + + std::vector> SceneIndexMappings; + + std::ifstream file(SCENE_MAPPING_FILE_NAME); + if (file.is_open()) + { + std::string line; + std::string currSection; + bool bReadingSection = false; + while (std::getline(file, line)) + { + if (line[0] == ';') continue; // skip comment lines + if (line == "") continue; // skip empty lines + + const std::pair SettingNameValuePair = ParseLineINI(line, &bReadingSection); + const std::string& SettingName = SettingNameValuePair.first; + const std::string& SettingValue = SettingNameValuePair.second; + + // Header sections; + if (bReadingSection) + { + currSection = SettingName; + continue; + } + + const int SceneIndex = StrUtil::ParseInt(SettingValue); + const std::string& SceneName = SettingName; + SceneIndexMappings.push_back(std::make_pair(SceneName, SceneIndex)); + } + } + else + { + Log::Warning("Cannot find settings file %s in current directory: %s", SCENE_MAPPING_FILE_NAME, DirectoryUtil::GetCurrentPath().c_str()); + Log::Warning("Default scene mapping will be used."); + } + + std::sort(SceneIndexMappings.begin(), SceneIndexMappings.end(), [](const auto& l, const auto& r) { return l.second < r.second; }); + + return SceneIndexMappings; +} + +std::vector VQEngine::ParseEnvironmentMapsFile() +{ + constexpr char* SETTINGS_FILE_NAME = "Data/EnvironmentMaps.ini"; + + std::vector EnvironmentMapDescriptors; + + std::ifstream file(SETTINGS_FILE_NAME); + if (file.is_open()) + { + std::string line; + bool bReadingSection = false; + bool bRecentlyReadEmptyLine = false; + bool bCurrentlyReadingEnvMap = false; + FEnvironmentMapDescriptor desc = {}; + while (std::getline(file, line)) + { + if (line[0] == ';') continue; // skip comment lines + if (line == "") { bRecentlyReadEmptyLine = true; continue; } // skip empty lines + + const std::pair SettingNameValuePair = ParseLineINI(line, &bReadingSection); + const std::string& SettingName = SettingNameValuePair.first; + const std::string& SettingValue = SettingNameValuePair.second; + + // Header sections; + if (bReadingSection) + { + bCurrentlyReadingEnvMap = true; + if (bRecentlyReadEmptyLine) + { + EnvironmentMapDescriptors.push_back(desc); + desc = {}; + bRecentlyReadEmptyLine = false; + } + desc.Name = SettingName; + continue; + } + + if (SettingName == "Path") + { + desc.FilePath = SettingValue; + } + if (SettingName == "MaxCLL") + { + desc.MaxContentLightLevel = StrUtil::ParseFloat(SettingValue); + } + bRecentlyReadEmptyLine = false; + } + if (bCurrentlyReadingEnvMap) + { + EnvironmentMapDescriptors.push_back(desc); + desc = {}; + bCurrentlyReadingEnvMap = false; + } + } + else + { + Log::Error("Cannot find settings file %s in current directory: %s", SETTINGS_FILE_NAME, DirectoryUtil::GetCurrentPath().c_str()); + } + + return EnvironmentMapDescriptors; +} + +std::vector VQEngine::ParseHDRProfilesFile() +{ + constexpr char* SETTINGS_FILE_NAME = "Data/HDRDisplayProfiles.ini"; + + std::vector HDRProfiles; + + std::ifstream file(SETTINGS_FILE_NAME); + if (file.is_open()) + { + std::string line; + bool bReadingSection = false; // Section is an .ini term + bool bRecentlyReadEmptyLine = false; + bool bCurrentlyReadingProfile = false; + FDisplayHDRProfile profile = {}; + while (std::getline(file, line)) + { + if (line[0] == ';') continue; // skip comment lines + if (line == "") { bRecentlyReadEmptyLine = true; continue; } // skip empty lines + + const std::pair SettingNameValuePair = ParseLineINI(line, &bReadingSection); + const std::string& SettingName = SettingNameValuePair.first; + const std::string& SettingValue = SettingNameValuePair.second; + + // Header sections; + if (bReadingSection) + { + bCurrentlyReadingProfile = true; + if (bRecentlyReadEmptyLine) + { + HDRProfiles.push_back(profile); + profile = {}; + bRecentlyReadEmptyLine = false; + } + profile.DisplayName = SettingName; + continue; + } + + if (SettingName == "MaxBrightness") + { + profile.MaxBrightness = StrUtil::ParseFloat(SettingValue); + } + if (SettingName == "MinBrightness") + { + profile.MinBrightness = StrUtil::ParseFloat(SettingValue); + } + bRecentlyReadEmptyLine = false; + } + if (bCurrentlyReadingProfile) // Take into account the last item we're reading (.push_back() isn't called above for the last item) + { + HDRProfiles.push_back(profile); + profile = {}; + bCurrentlyReadingProfile = false; + } + } + else + { + Log::Error("Cannot find settings file %s in current directory: %s", SETTINGS_FILE_NAME, DirectoryUtil::GetCurrentPath().c_str()); + } + return HDRProfiles; +} + +std::vector< FSceneRepresentation> VQEngine::ParseScenesFile() +{ + using namespace DirectX; + using namespace tinyxml2; + //----------------------------------------------------------------- + constexpr char* XML_TAG__SCENE = "Scene"; + constexpr char* XML_TAG__ENVIRONMENT_MAP = "EnvironmentMap"; + constexpr char* XML_TAG__ENVIRONMENT_MAP_PRESET = "Preset"; + constexpr char* XML_TAG__CAMERA = "Camera"; + constexpr char* XML_TAG__GAMEOBJECT = "GameObject"; + //----------------------------------------------------------------- + constexpr char* SCENE_FILES_DIRECTORY = "Data/Levels/"; + //----------------------------------------------------------------- + std::vector< FSceneRepresentation> SceneRepresentations; + const std::vector< std::string> SceneFiles = DirectoryUtil::ListFilesInDirectory(SCENE_FILES_DIRECTORY, ".xml"); + //----------------------------------------------------------------- + + // parse vectors -------------------------------------------------- + // e.g." 0.0 9 -1.0f" -> [0.0f, 9.0f, -1.0f] + auto fnParseF3 = [](const std::string& xyz) -> XMFLOAT3 + { + XMFLOAT3 f3; + std::vector tokens = StrUtil::split(xyz, ' '); + assert(tokens.size() == 3); + f3.x = StrUtil::ParseFloat(tokens[0]); + f3.y = StrUtil::ParseFloat(tokens[1]); + f3.z = StrUtil::ParseFloat(tokens[2]); + return f3; + }; + auto fnParseF4 = [](const std::string& xyzw) -> XMFLOAT4 + { + XMFLOAT4 f4; + std::vector tokens = StrUtil::split(xyzw, ' '); + assert(tokens.size() == 4); + f4.x = StrUtil::ParseFloat(tokens[0]); + f4.y = StrUtil::ParseFloat(tokens[1]); + f4.z = StrUtil::ParseFloat(tokens[2]); + f4.w = StrUtil::ParseFloat(tokens[3]); + return f4; + }; + // parse xml elements --------------------------------------------- + auto fnParseXMLStringVal = [](XMLElement* pEle, std::string& dest) + { + XMLNode* pNode = pEle->FirstChild(); + if (pNode) + { + dest = pNode->Value(); + } + }; + auto fnParseXMLFloatVal = [](XMLElement* pEle, float& dest) + { + XMLNode* pNode = pEle->FirstChild(); + if (pNode) + { + dest = StrUtil::ParseFloat(pNode->Value()); + } + }; + auto fnParseXMLFloat3Val = [&](XMLElement* pEle, XMFLOAT3& f3) + { + XMLNode* pNode = pEle->FirstChild(); + if (pNode) + { + f3 = fnParseF3(pNode->Value()); + } + }; + auto fnParseXMLFloat4Val = [&](XMLElement* pEle, XMFLOAT4& f4) + { + XMLNode* pNode = pEle->FirstChild(); + if (pNode) + { + f4 = fnParseF4(pNode->Value()); + } + }; + // parse engine stuff ------------------------------------------- + auto fnParseTransform = [&](XMLElement* pTransform) -> Transform + { + Transform tf; + + XMLElement* pPos = pTransform->FirstChildElement("Position"); + XMLElement* pQuat = pTransform->FirstChildElement("Quaternion"); + XMLElement* pRot = pTransform->FirstChildElement("Rotation"); + XMLElement* pScl = pTransform->FirstChildElement("Scale"); + if (pPos) fnParseXMLFloat3Val(pPos, tf._position); + if (pScl) fnParseXMLFloat3Val(pScl, tf._scale); + if (pQuat) + { + XMFLOAT4 qf4; fnParseXMLFloat4Val(pQuat, qf4); + tf._rotation = Quaternion(qf4.w, XMFLOAT3(qf4.x, qf4.y, qf4.z)); + } + if (pRot) + { + XMFLOAT3 f3; fnParseXMLFloat3Val(pRot, f3); + tf.RotateAroundGlobalXAxisDegrees(f3.x); + tf.RotateAroundGlobalYAxisDegrees(f3.y); + tf.RotateAroundGlobalZAxisDegrees(f3.z); + } + return tf; + }; + + //----------------------------------------------------------------- + + // Start reading scene XML files + for (const std::string SceneFile : SceneFiles) + { + FSceneRepresentation SceneRep = {}; + + // parse XML + tinyxml2::XMLDocument doc; + doc.LoadFile(SceneFile.c_str()); + + // scene name + SceneRep.SceneName = DirectoryUtil::GetFileNameWithoutExtension(SceneFile); + + + XMLElement* pScene = doc.FirstChildElement(XML_TAG__SCENE); + if (pScene) + { + XMLElement* pCurrentSceneElement = pScene->FirstChildElement(); + if (!pCurrentSceneElement) + { + SceneRepresentations.push_back(SceneRep); + continue; + } + + do + { + // Environment Map + const std::string CurrEle = pCurrentSceneElement->Value(); + if (XML_TAG__ENVIRONMENT_MAP == CurrEle) + { + XMLElement* pPreset = pCurrentSceneElement->FirstChildElement(XML_TAG__ENVIRONMENT_MAP_PRESET); + if (pPreset) + { + fnParseXMLStringVal(pPreset, SceneRep.EnvironmentMapPreset); + } + } + + // Cameras + else if (XML_TAG__CAMERA == CurrEle) + { + FCameraParameters cam; + XMLElement*& pCam = pCurrentSceneElement; + + // transform + XMLElement* pPos = pCam->FirstChildElement("Position"); + XMLElement* pPitch = pCam->FirstChildElement("Pitch"); + XMLElement* pYaw = pCam->FirstChildElement("Yaw"); + + // projection + XMLElement* pProj = pCam->FirstChildElement("Projection"); + XMLElement* pFoV = pCam->FirstChildElement("FoV"); + XMLElement* pNear = pCam->FirstChildElement("Near"); + XMLElement* pFar = pCam->FirstChildElement("Far"); + + // attributes + XMLElement* pFP = pCam->FirstChildElement("FirstPerson"); + XMLElement* pTSpeed = pFP ? pFP->FirstChildElement("TranslationSpeed") : nullptr; + XMLElement* pASpeed = pFP ? pFP->FirstChildElement("AngularSpeed") : nullptr; + XMLElement* pDrag = pFP ? pFP->FirstChildElement("Drag") : nullptr; + + // transform ---------------------------------------- + if (pPos) + { + XMFLOAT3 xyz; + fnParseXMLFloat3Val(pPos, xyz); + cam.x = xyz.x; + cam.y = xyz.y; + cam.z = xyz.z; + } + if (pPitch) fnParseXMLFloatVal(pPitch, cam.Pitch); + if (pYaw) fnParseXMLFloatVal(pYaw, cam.Yaw); + + // projection---------------------------------------- + if(pProj) + { + std::string projVal; + fnParseXMLStringVal(pProj, projVal); + cam.bPerspectiveProjection = projVal == "Perspective"; + } + if(pFoV ) fnParseXMLFloatVal(pFoV, cam.FovV_Degrees); + if(pNear) fnParseXMLFloatVal(pNear, cam.NearPlane); + if(pFar ) fnParseXMLFloatVal(pFar, cam.FarPlane); + + + // attributes---------------------------------------- + if (pFP) + { + if(pTSpeed) fnParseXMLFloatVal(pTSpeed, cam.TranslationSpeed); + if(pASpeed) fnParseXMLFloatVal(pASpeed, cam.AngularSpeed); + if(pDrag ) fnParseXMLFloatVal(pDrag , cam.Drag); + } + + SceneRep.Cameras.push_back(cam); + } + + + // Game Objects + else if (XML_TAG__GAMEOBJECT == CurrEle) + { + GameObjectRepresentation obj; + + XMLElement*& pObj = pCurrentSceneElement; + XMLElement* pTransform = pObj->FirstChildElement("Transform"); + XMLElement* pModel = pObj->FirstChildElement("Model"); + + // Transform + if (pTransform) + { + obj.tf = fnParseTransform(pTransform); + } + + // Model (WIP) + if (pModel) + { + XMLElement* pMesh = pModel->FirstChildElement("Mesh"); + XMLElement* pMaterial = pModel->FirstChildElement("Material"); + + if (pMesh) + { + fnParseXMLStringVal(pMesh, obj.BuiltinMeshName); + } + + if (pMaterial) + { + // TODO + } + + // TODO: model loading from disk + //obj.ModelName + } + + + SceneRep.Objects.push_back(obj); + } + + pCurrentSceneElement = pCurrentSceneElement->NextSiblingElement(); + } while (pCurrentSceneElement); + } + + SceneRepresentations.push_back(SceneRep); + } + + + return SceneRepresentations; +} diff --git a/Source/Application/Scene.cpp b/Source/Application/Scene.cpp index f93da58b..f931d691 100644 --- a/Source/Application/Scene.cpp +++ b/Source/Application/Scene.cpp @@ -147,10 +147,13 @@ void Scene::OnLoadComplete() { Log::Info("[Scene] %s loaded.", mSceneRepresentation.SceneName.c_str()); mSceneRepresentation.loadSuccess = 1; + this->InitializeScene(); } void Scene::Unload() { + this->UnloadScene(); + mSceneRepresentation = {}; const size_t sz = mFrameSceneViews.size(); diff --git a/Source/Application/Scene.h b/Source/Application/Scene.h index 6527c6f2..554bcc30 100644 --- a/Source/Application/Scene.h +++ b/Source/Application/Scene.h @@ -117,13 +117,18 @@ class Scene // SCENE INTERFACE //---------------------------------------------------------------------------------------------------------------- protected: - // Update() is called each frame before Engine::Render(). Scene-specific update logic goes here. + // Scene-specific loading logic goes here. + // LoadScene() is called right before loading begins. // - virtual void UpdateScene(float dt, FSceneView& view) = 0; + virtual void LoadScene(FSceneRepresentation& scene) = 0; + + // InitializeScene() is called after the scene data is loaded from the disk. + // + virtual void InitializeScene() = 0; - // Scene-specific loading logic goes here + // Update() is called each frame before Engine::Render(). Scene-specific update logic goes here. // - virtual void LoadScene(FSceneRepresentation& scene) = 0; + virtual void UpdateScene(float dt, FSceneView& view) = 0; // Scene-specific unloading logic goes here // diff --git a/Source/Application/VQEngine_Main.cpp b/Source/Application/VQEngine_Main.cpp index 1efbcd3a..0cd911e3 100644 --- a/Source/Application/VQEngine_Main.cpp +++ b/Source/Application/VQEngine_Main.cpp @@ -20,10 +20,6 @@ #include "../Scenes/Scenes.h" -#include "Libs/VQUtils/Source/utils.h" -#include "Libs/VQUtils/Libs/tinyxml2/tinyxml2.h" - -#include #include #ifdef _DEBUG @@ -34,42 +30,6 @@ constexpr char* BUILD_CONFIG = ""; constexpr char* VQENGINE_VERSION = "v0.5.0"; -static std::pair ParseLineINI(const std::string& iniLine, bool* pbSectionTag) -{ - assert(!iniLine.empty()); - std::pair SettingNameValuePair; - - const bool bSectionTag = iniLine[0] == '['; - if(pbSectionTag) - *pbSectionTag = bSectionTag; - - if (bSectionTag) - { - auto vecSettingNameValue = StrUtil::split(iniLine.substr(1), ']'); - SettingNameValuePair.first = vecSettingNameValue[0]; - } - else - { - auto vecSettingNameValue = StrUtil::split(iniLine, '='); - assert(vecSettingNameValue.size() >= 2); - SettingNameValuePair.first = vecSettingNameValue[0]; - SettingNameValuePair.second = vecSettingNameValue[1]; - } - - return SettingNameValuePair; -} - -static std::unordered_map S_LOOKUP_STR_TO_DISPLAYMODE = -{ - { "Fullscreen" , EDisplayMode::EXCLUSIVE_FULLSCREEN } - , { "Borderless" , EDisplayMode::BORDERLESS_FULLSCREEN } - , { "BorderlessFullscreen" , EDisplayMode::BORDERLESS_FULLSCREEN } - , { "BorderlessWindowed" , EDisplayMode::BORDERLESS_FULLSCREEN } - , { "Windowed" , EDisplayMode::WINDOWED } -}; - - - #define REPORT_SYSTEM_INFO 1 #if REPORT_SYSTEM_INFO void ReportSystemInfo(const VQSystemInfo::FSystemInfo& i, bool bDetailed = false) @@ -154,7 +114,7 @@ void VQEngine::InitializeInput() // initialize input states RegisterWindowForInput(mpWinMain); - RegisterWindowForInput(mpWinDebug); + if (mpWinDebug) RegisterWindowForInput(mpWinDebug); } void VQEngine::InitializeEngineSettings(const FStartupParameters& Params) @@ -190,8 +150,8 @@ void VQEngine::InitializeEngineSettings(const FStartupParameters& Params) // Override #0 : from file FStartupParameters paramFile = VQEngine::ParseEngineSettingsFile(); const FEngineSettings& pf = paramFile.EngineSettings; - if (paramFile.bOverrideGFXSetting_bVSync ) s.gfx.bVsync = pf.gfx.bVsync; - if (paramFile.bOverrideGFXSetting_bAA ) s.gfx.bAntiAliasing = pf.gfx.bAntiAliasing; + if (paramFile.bOverrideGFXSetting_bVSync) s.gfx.bVsync = pf.gfx.bVsync; + if (paramFile.bOverrideGFXSetting_bAA) s.gfx.bAntiAliasing = pf.gfx.bAntiAliasing; if (paramFile.bOverrideGFXSetting_bUseTripleBuffering) s.gfx.bUseTripleBuffering = pf.gfx.bUseTripleBuffering; if (paramFile.bOverrideGFXSetting_RenderScale) s.gfx.RenderScale = pf.gfx.RenderScale; if (paramFile.bOverrideGFXSetting_bMaxFrameRate) s.gfx.MaxFrameRate = pf.gfx.MaxFrameRate; @@ -218,8 +178,8 @@ void VQEngine::InitializeEngineSettings(const FStartupParameters& Params) if (paramFile.bOverrideENGSetting_StartupScene) s.StartupScene = pf.StartupScene; // Override #1 : if there's command line params - if (Params.bOverrideGFXSetting_bVSync ) s.gfx.bVsync = p.gfx.bVsync; - if (Params.bOverrideGFXSetting_bAA ) s.gfx.bAntiAliasing = p.gfx.bAntiAliasing; + if (Params.bOverrideGFXSetting_bVSync) s.gfx.bVsync = p.gfx.bVsync; + if (Params.bOverrideGFXSetting_bAA) s.gfx.bAntiAliasing = p.gfx.bAntiAliasing; if (Params.bOverrideGFXSetting_bUseTripleBuffering) s.gfx.bUseTripleBuffering = p.gfx.bUseTripleBuffering; if (Params.bOverrideGFXSetting_RenderScale) s.gfx.RenderScale = p.gfx.RenderScale; if (Params.bOverrideGFXSetting_bMaxFrameRate) s.gfx.MaxFrameRate = p.gfx.MaxFrameRate; @@ -455,551 +415,3 @@ void VQEngine::UnregisterWindowForInput(const std::unique_ptr& pWnd) } } - -FStartupParameters VQEngine::ParseEngineSettingsFile() -{ - constexpr char* ENGINE_SETTINGS_FILE_NAME = "Data/EngineSettings.ini"; - FStartupParameters params = {}; - - std::ifstream file(ENGINE_SETTINGS_FILE_NAME); - if (file.is_open()) - { - std::string line; - std::string currSection; - bool bReadingSection = false; - while (std::getline(file, line)) - { - if (line[0] == ';') continue; // skip comment lines - if (line == "") continue; // skip empty lines - - const std::pair SettingNameValuePair = ParseLineINI(line, &bReadingSection); - const std::string& SettingName = SettingNameValuePair.first; - const std::string& SettingValue = SettingNameValuePair.second; - - // Header sections; - if (bReadingSection) - { - currSection = SettingName; - continue; - } - - - // - // Graphics - // - if (SettingName == "VSync") - { - params.bOverrideGFXSetting_bVSync = true; - params.EngineSettings.gfx.bVsync = StrUtil::ParseBool(SettingValue); - } - if (SettingName == "RenderScale") - { - params.bOverrideGFXSetting_RenderScale = true; - params.EngineSettings.gfx.RenderScale = StrUtil::ParseFloat(SettingValue); - } - if (SettingName == "TripleBuffer") - { - params.bOverrideGFXSetting_bUseTripleBuffering = true; - params.EngineSettings.gfx.bUseTripleBuffering = StrUtil::ParseBool(SettingValue); - } - if (SettingName == "AntiAliasing" || SettingName == "AA") - { - params.bOverrideGFXSetting_bAA = true; - params.EngineSettings.gfx.bAntiAliasing = StrUtil::ParseBool(SettingValue); - } - if (SettingName == "MaxFrameRate" || SettingName == "MaxFPS") - { - params.bOverrideGFXSetting_bMaxFrameRate = true; - if (SettingValue == "Unlimited" || SettingValue == "0") - params.EngineSettings.gfx.MaxFrameRate = 0; - else if (SettingValue == "Auto" || SettingValue == "Automatic" || SettingValue == "-1") - params.EngineSettings.gfx.MaxFrameRate = -1; - else - params.EngineSettings.gfx.MaxFrameRate = StrUtil::ParseInt(SettingValue); - } - - // - // Engine - // - if (SettingName == "Width") - { - params.bOverrideENGSetting_MainWindowWidth = true; - params.EngineSettings.WndMain.Width = StrUtil::ParseInt(SettingValue); - } - if (SettingName == "Height") - { - params.bOverrideENGSetting_MainWindowHeight = true; - params.EngineSettings.WndMain.Height = StrUtil::ParseInt(SettingValue); - } - if (SettingName == "DisplayMode") - { - if (S_LOOKUP_STR_TO_DISPLAYMODE.find(SettingValue) != S_LOOKUP_STR_TO_DISPLAYMODE.end()) - { - params.bOverrideENGSetting_bDisplayMode = true; - params.EngineSettings.WndMain.DisplayMode = S_LOOKUP_STR_TO_DISPLAYMODE.at(SettingValue); - } - } - if (SettingName == "PreferredDisplay") - { - params.bOverrideENGSetting_PreferredDisplay = true; - params.EngineSettings.WndMain.PreferredDisplay = StrUtil::ParseInt(SettingValue); - } - if (SettingName == "HDR") - { - params.bOverrideGFXSetting_bHDR = true; - params.EngineSettings.WndMain.bEnableHDR = StrUtil::ParseBool(SettingValue); - } - - - if (SettingName == "DebugWindow") - { - params.bOverrideENGSetting_bDebugWindowEnable = true; - params.EngineSettings.bShowDebugWindow = StrUtil::ParseBool(SettingValue); - } - if (SettingName == "DebugWindowWidth") - { - params.bOverrideENGSetting_DebugWindowWidth = true; - params.EngineSettings.WndDebug.Width = StrUtil::ParseInt(SettingValue); - } - if (SettingName == "DebugWindowHeight") - { - params.bOverrideENGSetting_DebugWindowHeight = true; - params.EngineSettings.WndDebug.Height = StrUtil::ParseInt(SettingValue); - } - if (SettingName == "DebugWindowDisplayMode") - { - if (S_LOOKUP_STR_TO_DISPLAYMODE.find(SettingValue) != S_LOOKUP_STR_TO_DISPLAYMODE.end()) - { - params.bOverrideENGSetting_DebugWindowDisplayMode = true; - params.EngineSettings.WndDebug.DisplayMode = S_LOOKUP_STR_TO_DISPLAYMODE.at(SettingValue); - } - } - if (SettingName == "DebugWindowPreferredDisplay") - { - params.bOverrideENGSetting_DebugWindowPreferredDisplay = true; - params.EngineSettings.WndDebug.PreferredDisplay = StrUtil::ParseInt(SettingValue); - } - - if (SettingName == "Scene") - { - params.bOverrideENGSetting_StartupScene = true; - params.EngineSettings.StartupScene = SettingValue; - } - - } - } - else - { - Log::Warning("Cannot find settings file %s in current directory: %s", ENGINE_SETTINGS_FILE_NAME, DirectoryUtil::GetCurrentPath().c_str()); - Log::Warning("Will use default settings for Engine & Graphics.", ENGINE_SETTINGS_FILE_NAME, DirectoryUtil::GetCurrentPath().c_str()); - } - - file.close(); - - return params; -} - -std::vector> VQEngine::ParseSceneIndexMappingFile() -{ - constexpr char* SCENE_MAPPING_FILE_NAME = "Data/Scenes.ini"; - - std::vector> SceneIndexMappings; - - std::ifstream file(SCENE_MAPPING_FILE_NAME); - if (file.is_open()) - { - std::string line; - std::string currSection; - bool bReadingSection = false; - while (std::getline(file, line)) - { - if (line[0] == ';') continue; // skip comment lines - if (line == "") continue; // skip empty lines - - const std::pair SettingNameValuePair = ParseLineINI(line, &bReadingSection); - const std::string& SettingName = SettingNameValuePair.first; - const std::string& SettingValue = SettingNameValuePair.second; - - // Header sections; - if (bReadingSection) - { - currSection = SettingName; - continue; - } - - const int SceneIndex = StrUtil::ParseInt(SettingValue); - const std::string& SceneName = SettingName; - SceneIndexMappings.push_back(std::make_pair(SceneName, SceneIndex)); - } - } - else - { - Log::Warning("Cannot find settings file %s in current directory: %s", SCENE_MAPPING_FILE_NAME, DirectoryUtil::GetCurrentPath().c_str()); - Log::Warning("Default scene mapping will be used."); - } - - std::sort(SceneIndexMappings.begin(), SceneIndexMappings.end(), [](const auto& l, const auto& r) { return l.second < r.second; }); - - return SceneIndexMappings; -} - -std::vector VQEngine::ParseEnvironmentMapsFile() -{ - constexpr char* SETTINGS_FILE_NAME = "Data/EnvironmentMaps.ini"; - - std::vector EnvironmentMapDescriptors; - - std::ifstream file(SETTINGS_FILE_NAME); - if (file.is_open()) - { - std::string line; - bool bReadingSection = false; - bool bRecentlyReadEmptyLine = false; - bool bCurrentlyReadingEnvMap = false; - FEnvironmentMapDescriptor desc = {}; - while (std::getline(file, line)) - { - if (line[0] == ';') continue; // skip comment lines - if (line == "") { bRecentlyReadEmptyLine = true; continue; } // skip empty lines - - const std::pair SettingNameValuePair = ParseLineINI(line, &bReadingSection); - const std::string& SettingName = SettingNameValuePair.first; - const std::string& SettingValue = SettingNameValuePair.second; - - // Header sections; - if (bReadingSection) - { - bCurrentlyReadingEnvMap = true; - if (bRecentlyReadEmptyLine) - { - EnvironmentMapDescriptors.push_back(desc); - desc = {}; - bRecentlyReadEmptyLine = false; - } - desc.Name = SettingName; - continue; - } - - if (SettingName == "Path") - { - desc.FilePath = SettingValue; - } - if (SettingName == "MaxCLL") - { - desc.MaxContentLightLevel = StrUtil::ParseFloat(SettingValue); - } - bRecentlyReadEmptyLine = false; - } - if (bCurrentlyReadingEnvMap) - { - EnvironmentMapDescriptors.push_back(desc); - desc = {}; - bCurrentlyReadingEnvMap = false; - } - } - else - { - Log::Error("Cannot find settings file %s in current directory: %s", SETTINGS_FILE_NAME, DirectoryUtil::GetCurrentPath().c_str()); - } - - return EnvironmentMapDescriptors; -} - -std::vector VQEngine::ParseHDRProfilesFile() -{ - constexpr char* SETTINGS_FILE_NAME = "Data/HDRDisplayProfiles.ini"; - - std::vector HDRProfiles; - - std::ifstream file(SETTINGS_FILE_NAME); - if (file.is_open()) - { - std::string line; - bool bReadingSection = false; // Section is an .ini term - bool bRecentlyReadEmptyLine = false; - bool bCurrentlyReadingProfile = false; - FDisplayHDRProfile profile = {}; - while (std::getline(file, line)) - { - if (line[0] == ';') continue; // skip comment lines - if (line == "") { bRecentlyReadEmptyLine = true; continue; } // skip empty lines - - const std::pair SettingNameValuePair = ParseLineINI(line, &bReadingSection); - const std::string& SettingName = SettingNameValuePair.first; - const std::string& SettingValue = SettingNameValuePair.second; - - // Header sections; - if (bReadingSection) - { - bCurrentlyReadingProfile = true; - if (bRecentlyReadEmptyLine) - { - HDRProfiles.push_back(profile); - profile = {}; - bRecentlyReadEmptyLine = false; - } - profile.DisplayName = SettingName; - continue; - } - - if (SettingName == "MaxBrightness") - { - profile.MaxBrightness = StrUtil::ParseFloat(SettingValue); - } - if (SettingName == "MinBrightness") - { - profile.MinBrightness = StrUtil::ParseFloat(SettingValue); - } - bRecentlyReadEmptyLine = false; - } - if (bCurrentlyReadingProfile) // Take into account the last item we're reading (.push_back() isn't called above for the last item) - { - HDRProfiles.push_back(profile); - profile = {}; - bCurrentlyReadingProfile = false; - } - } - else - { - Log::Error("Cannot find settings file %s in current directory: %s", SETTINGS_FILE_NAME, DirectoryUtil::GetCurrentPath().c_str()); - } - return HDRProfiles; -} - -std::vector< FSceneRepresentation> VQEngine::ParseScenesFile() -{ - using namespace DirectX; - using namespace tinyxml2; - //----------------------------------------------------------------- - constexpr char* XML_TAG__SCENE = "Scene"; - constexpr char* XML_TAG__ENVIRONMENT_MAP = "EnvironmentMap"; - constexpr char* XML_TAG__ENVIRONMENT_MAP_PRESET = "Preset"; - constexpr char* XML_TAG__CAMERA = "Camera"; - constexpr char* XML_TAG__GAMEOBJECT = "GameObject"; - //----------------------------------------------------------------- - constexpr char* SCENE_FILES_DIRECTORY = "Data/Levels/"; - //----------------------------------------------------------------- - std::vector< FSceneRepresentation> SceneRepresentations; - const std::vector< std::string> SceneFiles = DirectoryUtil::ListFilesInDirectory(SCENE_FILES_DIRECTORY, ".xml"); - //----------------------------------------------------------------- - - // parse vectors -------------------------------------------------- - // e.g." 0.0 9 -1.0f" -> [0.0f, 9.0f, -1.0f] - auto fnParseF3 = [](const std::string& xyz) -> XMFLOAT3 - { - XMFLOAT3 f3; - std::vector tokens = StrUtil::split(xyz, ' '); - assert(tokens.size() == 3); - f3.x = StrUtil::ParseFloat(tokens[0]); - f3.y = StrUtil::ParseFloat(tokens[1]); - f3.z = StrUtil::ParseFloat(tokens[2]); - return f3; - }; - auto fnParseF4 = [](const std::string& xyzw) -> XMFLOAT4 - { - XMFLOAT4 f4; - std::vector tokens = StrUtil::split(xyzw, ' '); - assert(tokens.size() == 4); - f4.x = StrUtil::ParseFloat(tokens[0]); - f4.y = StrUtil::ParseFloat(tokens[1]); - f4.z = StrUtil::ParseFloat(tokens[2]); - f4.w = StrUtil::ParseFloat(tokens[3]); - return f4; - }; - // parse xml elements --------------------------------------------- - auto fnParseXMLStringVal = [](XMLElement* pEle, std::string& dest) - { - XMLNode* pNode = pEle->FirstChild(); - if (pNode) - { - dest = pNode->Value(); - } - }; - auto fnParseXMLFloatVal = [](XMLElement* pEle, float& dest) - { - XMLNode* pNode = pEle->FirstChild(); - if (pNode) - { - dest = StrUtil::ParseFloat(pNode->Value()); - } - }; - auto fnParseXMLFloat3Val = [&](XMLElement* pEle, XMFLOAT3& f3) - { - XMLNode* pNode = pEle->FirstChild(); - if (pNode) - { - f3 = fnParseF3(pNode->Value()); - } - }; - auto fnParseXMLFloat4Val = [&](XMLElement* pEle, XMFLOAT4& f4) - { - XMLNode* pNode = pEle->FirstChild(); - if (pNode) - { - f4 = fnParseF4(pNode->Value()); - } - }; - // parse engine stuff ------------------------------------------- - auto fnParseTransform = [&](XMLElement* pTransform) -> Transform - { - Transform tf; - - XMLElement* pPos = pTransform->FirstChildElement("Position"); - XMLElement* pRot = pTransform->FirstChildElement("Quaternion"); - XMLElement* pScl = pTransform->FirstChildElement("Scale"); - if (pPos) fnParseXMLFloat3Val(pPos, tf._position); - if (pScl) fnParseXMLFloat3Val(pScl, tf._scale); - if (pRot) - { - XMFLOAT4 qf4; fnParseXMLFloat4Val(pRot, qf4); - tf._rotation = Quaternion(qf4.w, XMFLOAT3(qf4.x, qf4.y, qf4.z)); - } - return tf; - }; - - //----------------------------------------------------------------- - - // Start reading scene XML files - for (const std::string SceneFile : SceneFiles) - { - FSceneRepresentation SceneRep = {}; - - // parse XML - tinyxml2::XMLDocument doc; - doc.LoadFile(SceneFile.c_str()); - - // scene name - SceneRep.SceneName = DirectoryUtil::GetFileNameWithoutExtension(SceneFile); - - - XMLElement* pScene = doc.FirstChildElement(XML_TAG__SCENE); - if (pScene) - { - XMLElement* pCurrentSceneElement = pScene->FirstChildElement(); - if (!pCurrentSceneElement) - { - SceneRepresentations.push_back(SceneRep); - continue; - } - - do - { - // Environment Map - const std::string CurrEle = pCurrentSceneElement->Value(); - if (XML_TAG__ENVIRONMENT_MAP == CurrEle) - { - XMLElement* pPreset = pCurrentSceneElement->FirstChildElement(XML_TAG__ENVIRONMENT_MAP_PRESET); - if (pPreset) - { - fnParseXMLStringVal(pPreset, SceneRep.EnvironmentMapPreset); - } - } - - // Cameras - else if (XML_TAG__CAMERA == CurrEle) - { - FCameraParameters cam; - XMLElement*& pCam = pCurrentSceneElement; - - // transform - XMLElement* pPos = pCam->FirstChildElement("Position"); - XMLElement* pPitch = pCam->FirstChildElement("Pitch"); - XMLElement* pYaw = pCam->FirstChildElement("Yaw"); - - // projection - XMLElement* pProj = pCam->FirstChildElement("Projection"); - XMLElement* pFoV = pCam->FirstChildElement("FoV"); - XMLElement* pNear = pCam->FirstChildElement("Near"); - XMLElement* pFar = pCam->FirstChildElement("Far"); - - // attributes - XMLElement* pFP = pCam->FirstChildElement("FirstPerson"); - XMLElement* pTSpeed = pFP ? pFP->FirstChildElement("TranslationSpeed") : nullptr; - XMLElement* pASpeed = pFP ? pFP->FirstChildElement("AngularSpeed") : nullptr; - XMLElement* pDrag = pFP ? pFP->FirstChildElement("Drag") : nullptr; - - // transform ---------------------------------------- - if (pPos) - { - XMFLOAT3 xyz; - fnParseXMLFloat3Val(pPos, xyz); - cam.x = xyz.x; - cam.y = xyz.y; - cam.z = xyz.z; - } - if (pPitch) fnParseXMLFloatVal(pPitch, cam.Pitch); - if (pYaw) fnParseXMLFloatVal(pYaw, cam.Yaw); - - // projection---------------------------------------- - if(pProj) - { - std::string projVal; - fnParseXMLStringVal(pProj, projVal); - cam.bPerspectiveProjection = projVal == "Perspective"; - } - if(pFoV ) fnParseXMLFloatVal(pFoV, cam.FovV_Degrees); - if(pNear) fnParseXMLFloatVal(pNear, cam.NearPlane); - if(pFar ) fnParseXMLFloatVal(pFar, cam.FarPlane); - - - // attributes---------------------------------------- - if (pFP) - { - if(pTSpeed) fnParseXMLFloatVal(pTSpeed, cam.TranslationSpeed); - if(pASpeed) fnParseXMLFloatVal(pASpeed, cam.AngularSpeed); - if(pDrag ) fnParseXMLFloatVal(pDrag , cam.Drag); - } - - SceneRep.Cameras.push_back(cam); - } - - - // Game Objects - else if (XML_TAG__GAMEOBJECT == CurrEle) - { - GameObjectRepresentation obj; - - XMLElement*& pObj = pCurrentSceneElement; - XMLElement* pTransform = pObj->FirstChildElement("Transform"); - XMLElement* pModel = pObj->FirstChildElement("Model"); - - // Transform - if (pTransform) - { - obj.tf = fnParseTransform(pTransform); - } - - // Model (WIP) - if (pModel) - { - XMLElement* pMesh = pModel->FirstChildElement("Mesh"); - XMLElement* pMaterial = pModel->FirstChildElement("Material"); - - if (pMesh) - { - fnParseXMLStringVal(pMesh, obj.BuiltinMeshName); - } - - if (pMaterial) - { - // TODO - } - - // TODO: model loading from disk - //obj.ModelName - } - - - SceneRep.Objects.push_back(obj); - } - - pCurrentSceneElement = pCurrentSceneElement->NextSiblingElement(); - } while (pCurrentSceneElement); - } - - SceneRepresentations.push_back(SceneRep); - } - - - return SceneRepresentations; -} diff --git a/Source/Scenes/DefaultScene.cpp b/Source/Scenes/DefaultScene.cpp index e9b87a78..17b90318 100644 --- a/Source/Scenes/DefaultScene.cpp +++ b/Source/Scenes/DefaultScene.cpp @@ -11,13 +11,19 @@ static void Toggle(bool& b) { b = !b; } void DefaultScene::UpdateScene(float dt, FSceneView& SceneView) { - // TODO: - //FFrameData& FrameData = GetCurrentFrameData(hwnd); + assert(pObject); + assert(mIndex_SelectedCamera < mCameras.size()); + + Camera& cam = mCameras[mIndex_SelectedCamera]; // handle input if (mInput.IsKeyTriggered('R')) - //FrameData.SceneCamera.InitializeCamera(GenerateCameraInitializationParameters(mpWinMain)); - ; // TODO: reset camera to initial stat + { + FCameraParameters params = mSceneRepresentation.Cameras[mIndex_SelectedCamera]; + params.Width = static_cast(mpWindow->GetWidth() ); + params.Height = static_cast(mpWindow->GetHeight()); + cam.InitializeCamera(params); + } constexpr float CAMERA_MOVEMENT_SPEED_MULTIPLER = 0.75f; constexpr float CAMERA_MOVEMENT_SPEED_SHIFT_MULTIPLER = 2.0f; @@ -31,46 +37,51 @@ void DefaultScene::UpdateScene(float dt, FSceneView& SceneView) if (mInput.IsKeyDown(VK_SHIFT)) LocalSpaceTranslation *= CAMERA_MOVEMENT_SPEED_SHIFT_MULTIPLER; LocalSpaceTranslation *= CAMERA_MOVEMENT_SPEED_MULTIPLER; -#if 0 - if (mInput.IsKeyTriggered("Space")) Toggle(FrameData.bCubeAnimating); + if (mInput.IsKeyTriggered("Space")) Toggle(this->bObjectAnimation); + Transform* pTF = mpTransforms[pObject->mTransformID]; constexpr float MOUSE_BUTTON_ROTATION_SPEED_MULTIPLIER = 1.0f; - if (mInput.IsMouseDown(Input::EMouseButtons::MOUSE_BUTTON_LEFT)) FrameData.TFCube.RotateAroundAxisRadians(ZAxis, dt * PI * MOUSE_BUTTON_ROTATION_SPEED_MULTIPLIER); - if (mInput.IsMouseDown(Input::EMouseButtons::MOUSE_BUTTON_RIGHT)) FrameData.TFCube.RotateAroundAxisRadians(YAxis, dt * PI * MOUSE_BUTTON_ROTATION_SPEED_MULTIPLIER); - if (mInput.IsMouseDown(Input::EMouseButtons::MOUSE_BUTTON_MIDDLE)) FrameData.TFCube.RotateAroundAxisRadians(XAxis, dt * PI * MOUSE_BUTTON_ROTATION_SPEED_MULTIPLIER); + if (mInput.IsMouseDown(Input::EMouseButtons::MOUSE_BUTTON_LEFT)) pTF->RotateAroundAxisRadians(ZAxis, dt * PI * MOUSE_BUTTON_ROTATION_SPEED_MULTIPLIER); + if (mInput.IsMouseDown(Input::EMouseButtons::MOUSE_BUTTON_RIGHT)) pTF->RotateAroundAxisRadians(YAxis, dt * PI * MOUSE_BUTTON_ROTATION_SPEED_MULTIPLIER); + if (mInput.IsMouseDown(Input::EMouseButtons::MOUSE_BUTTON_MIDDLE)) pTF->RotateAroundAxisRadians(XAxis, dt * PI * MOUSE_BUTTON_ROTATION_SPEED_MULTIPLIER); constexpr float DOUBLE_CLICK_MULTIPLIER = 4.0f; - if (mInput.IsMouseDoubleClick(Input::EMouseButtons::MOUSE_BUTTON_LEFT)) FrameData.TFCube.RotateAroundAxisRadians(ZAxis, dt * PI * DOUBLE_CLICK_MULTIPLIER); - if (mInput.IsMouseDoubleClick(Input::EMouseButtons::MOUSE_BUTTON_RIGHT)) FrameData.TFCube.RotateAroundAxisRadians(YAxis, dt * PI * DOUBLE_CLICK_MULTIPLIER); - if (mInput.IsMouseDoubleClick(Input::EMouseButtons::MOUSE_BUTTON_MIDDLE)) FrameData.TFCube.RotateAroundAxisRadians(XAxis, dt * PI * DOUBLE_CLICK_MULTIPLIER); + if (mInput.IsMouseDoubleClick(Input::EMouseButtons::MOUSE_BUTTON_LEFT)) pTF->RotateAroundAxisRadians(ZAxis, dt * PI * DOUBLE_CLICK_MULTIPLIER); + if (mInput.IsMouseDoubleClick(Input::EMouseButtons::MOUSE_BUTTON_RIGHT)) pTF->RotateAroundAxisRadians(YAxis, dt * PI * DOUBLE_CLICK_MULTIPLIER); + if (mInput.IsMouseDoubleClick(Input::EMouseButtons::MOUSE_BUTTON_MIDDLE)) pTF->RotateAroundAxisRadians(XAxis, dt * PI * DOUBLE_CLICK_MULTIPLIER); constexpr float SCROLL_SCALE_DELTA = 1.1f; - const float CubeScale = FrameData.TFCube._scale.x; - if (mInput.IsMouseScrollUp()) FrameData.TFCube.SetUniformScale(CubeScale * SCROLL_SCALE_DELTA); - if (mInput.IsMouseScrollDown()) FrameData.TFCube.SetUniformScale(std::max(0.5f, CubeScale / SCROLL_SCALE_DELTA)); -#endif - + const float CubeScale = pTF->_scale.x; + if (mInput.IsMouseScrollUp()) pTF->SetUniformScale(CubeScale * SCROLL_SCALE_DELTA); + if (mInput.IsMouseScrollDown()) pTF->SetUniformScale(std::max(0.5f, CubeScale / SCROLL_SCALE_DELTA)); // update camera FCameraInput camInput(LocalSpaceTranslation); camInput.DeltaMouseXY = mInput.GetMouseDelta(); - mCameras[mIndex_SelectedCamera].Update(dt, camInput); + cam.Update(dt, camInput); -#if 0 // update scene data - if (FrameData.bCubeAnimating) - FrameData.TFCube.RotateAroundAxisRadians(YAxis, dt * 0.2f * PI); -#endif + if (this->bObjectAnimation) + pTF->RotateAroundAxisRadians(YAxis, dt * 0.2f * PI); } -void DefaultScene::LoadScene(FSceneRepresentation& scene) + +void DefaultScene::InitializeScene() { + assert(!mpObjects.empty()); + this->pObject = mpObjects.front(); + this->bObjectAnimation = true; +} + +void DefaultScene::LoadScene(FSceneRepresentation& scene) +{ } void DefaultScene::UnloadScene() { + } void DefaultScene::RenderSceneUI() const diff --git a/Source/Scenes/Scenes.h b/Source/Scenes/Scenes.h index 76747991..cfa5bce7 100644 --- a/Source/Scenes/Scenes.h +++ b/Source/Scenes/Scenes.h @@ -8,6 +8,7 @@ class VQEngine; #define DECLARE_SCENE_INTERFACE()\ protected:\ + void InitializeScene() override;\ void UpdateScene(float dt, FSceneView& SceneView) override;\ void LoadScene(FSceneRepresentation& scene) override;\ void UnloadScene() override;\ @@ -39,4 +40,5 @@ class SponzaScene : public Scene DECLARE_SCENE_INTERFACE() DECLARE_CTOR(SponzaScene) -}; \ No newline at end of file +}; + diff --git a/Source/Scenes/Sponza.cpp b/Source/Scenes/Sponza.cpp index ed81f40d..6b8f17e7 100644 --- a/Source/Scenes/Sponza.cpp +++ b/Source/Scenes/Sponza.cpp @@ -1,5 +1,10 @@ #include "Scenes.h" +void SponzaScene::InitializeScene() +{ +} + + void SponzaScene::UpdateScene(float dt, FSceneView& SceneView) { From 4bb7de8bc83fdb8080aa6121e434eb70229dc22e Mon Sep 17 00:00:00 2001 From: Volkan Date: Mon, 17 Aug 2020 13:14:24 -0700 Subject: [PATCH 08/67] Moved scene input handling code into Scene.cpp --- Source/Application/Memory.h | 1 + Source/Application/Scene.cpp | 54 ++++++++++++++++++- Source/Application/Scene.h | 23 ++------ Source/Application/VQEngine.h | 35 ++++++++---- Source/Application/VQEngine_Main.cpp | 3 +- Source/Application/VQEngine_Render.cpp | 8 +-- Source/Application/VQEngine_Update.cpp | 74 ++++++++------------------ 7 files changed, 110 insertions(+), 88 deletions(-) diff --git a/Source/Application/Memory.h b/Source/Application/Memory.h index e823c978..943c48ea 100644 --- a/Source/Application/Memory.h +++ b/Source/Application/Memory.h @@ -20,6 +20,7 @@ // // Resources on memory management // +// - https://akkadia.org/drepper/cpumemory.pdf // - http://allenchou.net/memory-management-series/ // - https://www.gamasutra.com/blogs/MichaelKissner/20151104/258271/Writing_a_Game_Engine_from_Scratch__Part_2_Memory.php // - https://gamasutra.com/blogs/MichaelKissner/20151120/259561/Writing_a_Game_Engine_from_Scratch__Part_3_Data__Cache.php diff --git a/Source/Application/Scene.cpp b/Source/Application/Scene.cpp index f931d691..3ea9ce44 100644 --- a/Source/Application/Scene.cpp +++ b/Source/Application/Scene.cpp @@ -24,11 +24,25 @@ using namespace DirectX; +Scene::Scene(VQEngine& engine, int NumFrameBuffers, const Input& input, const std::unique_ptr& pWin) + : mInput(input) + , mpWindow(pWin) + , mEngine(engine) + , mFrameSceneViews(NumFrameBuffers) + , mIndex_SelectedCamera(0) + , mIndex_ActiveEnvironmentMapPreset(0) + , mGameObjectPool(NUM_GAMEOBJECT_POOL_SIZE, GAMEOBJECT_BYTE_ALIGNMENT) + , mTransformPool(NUM_GAMEOBJECT_POOL_SIZE, GAMEOBJECT_BYTE_ALIGNMENT) + , mResourceNames(engine.GetResourceNames()) +{} + void Scene::Update(float dt, int FRAME_DATA_INDEX) { + assert(FRAME_DATA_INDEX < mFrameSceneViews.size()); FSceneView& SceneView = mFrameSceneViews[FRAME_DATA_INDEX]; + this->HandleInput(); this->UpdateScene(dt, SceneView); } @@ -73,7 +87,6 @@ void Scene::StartLoading(FSceneRepresentation& scene) // scene-specific load this->LoadScene(scene); - // GAME OBJECTS auto fnDeserializeGameObject = [&](GameObjectRepresentation& ObjRep) { // Transform @@ -117,6 +130,7 @@ void Scene::StartLoading(FSceneRepresentation& scene) if constexpr (B_LOAD_SERIAL) { + // GAME OBJECTS for (GameObjectRepresentation& ObjRep : scene.Objects) { fnDeserializeGameObject(ObjRep); @@ -188,3 +202,41 @@ void Scene::RenderUI() // TODO } +void Scene::HandleInput() +{ + const int NumEnvMaps = static_cast(mResourceNames.mEnvironmentMapPresetNames.size()); + + const bool bIsShiftDown = mInput.IsKeyDown("Shift"); + if (mInput.IsKeyTriggered("PageUp")) + { + // Change Scene + if (bIsShiftDown) + { + + } + + // Change Env Map + else + { + mIndex_ActiveEnvironmentMapPreset = (mIndex_ActiveEnvironmentMapPreset + 1) % NumEnvMaps; + mEngine.StartLoadingEnvironmentMap(mIndex_ActiveEnvironmentMapPreset); + } + } + if (mInput.IsKeyTriggered("PageDown")) + { + // Change Scene + if (bIsShiftDown) + { + + } + + // Change Env Map + else + { + mIndex_ActiveEnvironmentMapPreset = mIndex_ActiveEnvironmentMapPreset == 0 + ? NumEnvMaps - 1 + : mIndex_ActiveEnvironmentMapPreset - 1; + mEngine.StartLoadingEnvironmentMap(mIndex_ActiveEnvironmentMapPreset); + } + } +} diff --git a/Source/Application/Scene.h b/Source/Application/Scene.h index 554bcc30..8ec879ed 100644 --- a/Source/Application/Scene.h +++ b/Source/Application/Scene.h @@ -26,10 +26,9 @@ #include "Memory.h" class Input; - +struct FResourceNames; //------------------------------------------------------ - struct GameObjectRepresentation { Transform tf; @@ -40,7 +39,6 @@ struct GameObjectRepresentation std::string BuiltinMeshName; struct Material { float data[16]; }; }; - struct FSceneRepresentation { std::string SceneName; @@ -52,9 +50,7 @@ struct FSceneRepresentation char loadSuccess = 0; }; - //------------------------------------------------------ - struct FPostProcessParameters { EColorSpace ContentColorSpace = EColorSpace::REC_709; @@ -62,15 +58,12 @@ struct FPostProcessParameters float DisplayReferenceBrightnessLevel = 200.0f; int ToggleGammaCorrection = 1; }; - - struct FMeshRenderCommand { MeshID meshID = INVALID_ID; MaterialID matID = INVALID_ID; DirectX::XMMATRIX WorldTransformationMatrix; }; - struct FSceneView { DirectX::XMMATRIX view; @@ -90,6 +83,7 @@ struct FSceneView std::vector meshRenderCommands; }; +//------------------------------------------------------ constexpr size_t NUM_GAMEOBJECT_POOL_SIZE = 4096; constexpr size_t GAMEOBJECT_BYTE_ALIGNMENT = 64; // assumed typical cache-line size @@ -144,16 +138,7 @@ class Scene // ENGINE INTERFACE //---------------------------------------------------------------------------------------------------------------- public: - Scene(VQEngine& engine, int NumFrameBuffers, const Input& input, const std::unique_ptr& pWin) - : mInput(input) - , mpWindow(pWin) - , mEngine(engine) - , mFrameSceneViews(NumFrameBuffers) - , mIndex_SelectedCamera(0) - , mIndex_ActiveEnvironmentMapPreset(0) - , mGameObjectPool(NUM_GAMEOBJECT_POOL_SIZE, GAMEOBJECT_BYTE_ALIGNMENT) - , mTransformPool(NUM_GAMEOBJECT_POOL_SIZE, GAMEOBJECT_BYTE_ALIGNMENT) - {} + Scene(VQEngine& engine, int NumFrameBuffers, const Input& input, const std::unique_ptr& pWin); private: // Derived Scenes shouldn't access these functions void Update(float dt, int FRAME_DATA_INDEX); @@ -162,6 +147,7 @@ class Scene void OnLoadComplete(); void Unload(); // serial-only for now. maybe MT later. void RenderUI(); + void HandleInput(); public: inline const FSceneView& GetSceneView(int FRAME_DATA_INDEX) const { return mFrameSceneViews[FRAME_DATA_INDEX]; } @@ -215,6 +201,7 @@ class Scene const Input& mInput; const std::unique_ptr& mpWindow; VQEngine& mEngine; + const FResourceNames& mResourceNames; FSceneRepresentation mSceneRepresentation; //---------------------------------------------------------------------------------------------------------------- diff --git a/Source/Application/VQEngine.h b/Source/Application/VQEngine.h index 843133f2..2408acb2 100644 --- a/Source/Application/VQEngine.h +++ b/Source/Application/VQEngine.h @@ -114,15 +114,19 @@ enum EAppState NUM_APP_STATES }; - +using BuiltinMeshNameArray_t = std::array; +struct FResourceNames +{ + BuiltinMeshNameArray_t mBuiltinMeshNames; + std::vector mEnvironmentMapPresetNames; + std::vector mSceneNames; +}; // // VQENGINE // class VQEngine : public IWindowOwner { -public: - public: // --------------------------------------------------------- @@ -190,12 +194,12 @@ class VQEngine : public IWindowOwner void UpdateThread_WaitForRenderThread(); void UpdateThread_SignalRenderThread(); - // PRE_UPDATE() + // PreUpdate() // - Updates timer // - Updates input state reading from Main Thread's input queue void UpdateThread_PreUpdate(float& dt); - // UPDATE() + // Update() // - Updates program state (init/load/sim/unload/exit) // - Starts loading tasks // - Animates loading screen @@ -204,8 +208,7 @@ class VQEngine : public IWindowOwner void UpdateThread_UpdateScene_MainWnd(const float dt); void UpdateThread_UpdateScene_DebugWnd(const float dt); - - // POST_UPDATE() + // PostUpdate() // - Computes visibility per FSceneView void UpdateThread_PostUpdate(); @@ -218,18 +221,30 @@ class VQEngine : public IWindowOwner inline const std::string& GetWindowName(const std::unique_ptr& pWin) const { return GetWindowName(pWin->GetHWND()); } inline const std::string& GetWindowName(const Window* pWin) const { return GetWindowName(pWin->GetHWND()); } + + // --------------------------------------------------------- + // Scene Interface + // --------------------------------------------------------- + void StartLoadingEnvironmentMap(int IndexEnvMap); + + // Busy waits until render thread catches up with update thread + void WaitUntilRenderingFinishes(); + // Mesh & Model management ModelID CreateModel(); + // Getters MeshID GetBuiltInMeshID(const std::string& MeshName) const; Model& GetModel(ModelID id); const Model& GetModel(ModelID id) const; + inline const FResourceNames& GetResourceNames() const { return mResourceNames; } + + private: //------------------------------------------------------------------------------------------------- using BuiltinMeshArray_t = std::array; - using BuiltinMeshNameArray_t = std::array; using MeshLookup_t = std::unordered_map; using ModelLookup_t = std::unordered_map; using EnvironmentMapDescLookup_t = std::unordered_map; @@ -286,9 +301,7 @@ class VQEngine : public IWindowOwner EnvironmentMapDescLookup_t mLookup_EnvironmentMapDescriptors; // data: strings - BuiltinMeshNameArray_t mBuiltinMeshNames; - std::vector mEnvironmentMapPresetNames; - std::vector mSceneNames; + FResourceNames mResourceNames; // state EAppState mAppState; diff --git a/Source/Application/VQEngine_Main.cpp b/Source/Application/VQEngine_Main.cpp index 0cd911e3..ff5ece32 100644 --- a/Source/Application/VQEngine_Main.cpp +++ b/Source/Application/VQEngine_Main.cpp @@ -251,7 +251,7 @@ void VQEngine::InitializeEnvironmentMaps() for (const FEnvironmentMapDescriptor& desc : descs) { mLookup_EnvironmentMapDescriptors[desc.Name] = desc; - mEnvironmentMapPresetNames.push_back(desc.Name); + mResourceNames.mEnvironmentMapPresetNames.push_back(desc.Name); } } @@ -259,6 +259,7 @@ void VQEngine::InitializeScenes() { const int NUM_SWAPCHAIN_BACKBUFFERS = mSettings.gfx.bUseTripleBuffering ? 3 : 2; const Input& input = mInputStates.at(mpWinMain->GetHWND()); + std::vector& mSceneNames = mResourceNames.mSceneNames; auto fnCreateSceneInstance = [&](const std::string& SceneType, std::unique_ptr& pScene) -> void { diff --git a/Source/Application/VQEngine_Render.cpp b/Source/Application/VQEngine_Render.cpp index 6e879a68..25826f13 100644 --- a/Source/Application/VQEngine_Render.cpp +++ b/Source/Application/VQEngine_Render.cpp @@ -179,13 +179,13 @@ void VQEngine::InitializeBuiltinMeshes() { { GeometryGenerator::GeometryData data = GeometryGenerator::Triangle(1.0f); - mBuiltinMeshNames[EBuiltInMeshes::TRIANGLE] = "Triangle"; - mBuiltinMeshes[EBuiltInMeshes::TRIANGLE] = Mesh(&mRenderer, data.Vertices, data.Indices, mBuiltinMeshNames[EBuiltInMeshes::TRIANGLE]); + mResourceNames.mBuiltinMeshNames[EBuiltInMeshes::TRIANGLE] = "Triangle"; + mBuiltinMeshes[EBuiltInMeshes::TRIANGLE] = Mesh(&mRenderer, data.Vertices, data.Indices, mResourceNames.mBuiltinMeshNames[EBuiltInMeshes::TRIANGLE]); } { GeometryGenerator::GeometryData data = GeometryGenerator::Cube(); - mBuiltinMeshNames[EBuiltInMeshes::CUBE] = "Cube"; - mBuiltinMeshes[EBuiltInMeshes::CUBE] = Mesh(&mRenderer, data.Vertices, data.Indices, mBuiltinMeshNames[EBuiltInMeshes::CUBE]); + mResourceNames.mBuiltinMeshNames[EBuiltInMeshes::CUBE] = "Cube"; + mBuiltinMeshes[EBuiltInMeshes::CUBE] = Mesh(&mRenderer, data.Vertices, data.Indices, mResourceNames.mBuiltinMeshNames[EBuiltInMeshes::CUBE]); } // ... diff --git a/Source/Application/VQEngine_Update.cpp b/Source/Application/VQEngine_Update.cpp index 7273cc16..b3d000f9 100644 --- a/Source/Application/VQEngine_Update.cpp +++ b/Source/Application/VQEngine_Update.cpp @@ -213,11 +213,7 @@ void VQEngine::HandleEngineInput() mEventQueue_VQEToWin_Main.AddItem(std::make_shared(hwnd, true, false)); } } - - // - // Graphics Settings Controls - // - if (pWin == mpWinMain) + if (pWin == mpWinMain) // Graphics Settings Controls { if (input.IsKeyTriggered("V")) { @@ -336,13 +332,13 @@ const std::string& VQEngine::GetWindowName(HWND hwnd) const MeshID VQEngine::GetBuiltInMeshID(const std::string& MeshName) const { - const auto it = std::find(mBuiltinMeshNames.begin(), mBuiltinMeshNames.end(), MeshName); - if (it == mBuiltinMeshNames.end()) + const auto it = std::find(mResourceNames.mBuiltinMeshNames.begin(), mResourceNames.mBuiltinMeshNames.end(), MeshName); + if (it == mResourceNames.mBuiltinMeshNames.end()) { Log::Error("Builtin Mesh Not Found: %s", MeshName.c_str()); return INVALID_ID; } - return static_cast(it - mBuiltinMeshNames.begin()); + return static_cast(it - mResourceNames.mBuiltinMeshNames.begin()); } Model& VQEngine::GetModel(ModelID id) @@ -357,6 +353,21 @@ const Model& VQEngine::GetModel(ModelID id) const return mModels.at(id); } +void VQEngine::StartLoadingEnvironmentMap(int IndexEnvMap) +{ + mAppState = EAppState::LOADING; + mbLoadingLevel = true; + mWorkers_Load.AddTask([&, IndexEnvMap]() + { + LoadEnvironmentMap(mResourceNames.mEnvironmentMapPresetNames[IndexEnvMap]); + }); +} + +void VQEngine::WaitUntilRenderingFinishes() +{ + while ((mNumRenderLoopsExecuted + 1) != mNumUpdateLoopsExecuted); +} + ModelID VQEngine::CreateModel() { static ModelID LAST_USED_MODEL_ID = 0; @@ -384,54 +395,11 @@ void VQEngine::UpdateThread_UpdateScene_MainWnd(const float dt) { std::unique_ptr& pWin = mpWinMain; HWND hwnd = pWin->GetHWND(); - const Input& input = mInputStates.at(hwnd); const int NUM_BACK_BUFFERS = mRenderer.GetSwapChainBackBufferCount(hwnd); const int FRAME_DATA_INDEX = mNumUpdateLoopsExecuted % NUM_BACK_BUFFERS; mpScene->Update(dt, FRAME_DATA_INDEX); - - - auto fnBusyWaitUntilRenderThreadCatchesUp = [&]() - { - while ((mNumRenderLoopsExecuted + 1) != mNumUpdateLoopsExecuted); - }; - - const FEnvironmentMap& env = mResources_MainWnd.EnvironmentMap; - const int NumEnvMaps = static_cast(mEnvironmentMapPresetNames.size()); - - if (input.IsKeyTriggered("PageUp")) - { - fnBusyWaitUntilRenderThreadCatchesUp(); - - int& ACTIVE_ENV_MAP_INDEX = mpScene->mIndex_ActiveEnvironmentMapPreset; - ACTIVE_ENV_MAP_INDEX = (ACTIVE_ENV_MAP_INDEX + 1) % NumEnvMaps; - - mAppState = EAppState::LOADING; - mbLoadingLevel = true; - mWorkers_Load.AddTask([&]() - { - LoadEnvironmentMap(mEnvironmentMapPresetNames[ACTIVE_ENV_MAP_INDEX]); - }); - - - } - if (input.IsKeyTriggered("PageDown")) - { - fnBusyWaitUntilRenderThreadCatchesUp(); - - int& ACTIVE_ENV_MAP_INDEX = mpScene->mIndex_ActiveEnvironmentMapPreset; - ACTIVE_ENV_MAP_INDEX = ACTIVE_ENV_MAP_INDEX == 0 - ? NumEnvMaps - 1 - : ACTIVE_ENV_MAP_INDEX - 1; - - mAppState = EAppState::LOADING; - mbLoadingLevel = true; - mWorkers_Load.AddTask([&]() - { - LoadEnvironmentMap(mEnvironmentMapPresetNames[ACTIVE_ENV_MAP_INDEX]); - }); - } } void VQEngine::UpdateThread_UpdateScene_DebugWnd(const float dt) @@ -483,8 +451,8 @@ void VQEngine::LoadEnvironmentMap(const std::string& EnvMapName) } const FEnvironmentMapDescriptor& desc = this->GetEnvironmentMapDesc(EnvMapName); - std::vector::iterator it = std::find(mEnvironmentMapPresetNames.begin(), mEnvironmentMapPresetNames.end(), EnvMapName); - const size_t ActiveEnvMapIndex = it - mEnvironmentMapPresetNames.begin(); + std::vector::iterator it = std::find(mResourceNames.mEnvironmentMapPresetNames.begin(), mResourceNames.mEnvironmentMapPresetNames.end(), EnvMapName); + const size_t ActiveEnvMapIndex = it - mResourceNames.mEnvironmentMapPresetNames.begin(); if (!desc.FilePath.empty()) // check whether the env map was found or not { Log::Info("Loading Environment Map: %s", EnvMapName.c_str()); From d1fb35c8e934ae5826ec626f263448b48af1c8d2 Mon Sep 17 00:00:00 2001 From: Volkan Date: Mon, 17 Aug 2020 17:29:33 -0700 Subject: [PATCH 09/67] Add Camera controllers, cameras no longer need to be manually updated in the scene implementation --- Source/Application/Camera.cpp | 152 +++++++++++---- Source/Application/Camera.h | 178 +++++++++--------- Source/Application/FileParser.cpp | 31 +-- Source/Application/Math.h | 68 ++++++- Source/Application/Scene.cpp | 52 +++-- Source/Application/VQEngine.h | 14 +- Source/Application/VQEngine_EventHandlers.cpp | 2 +- Source/Application/VQEngine_Main.cpp | 13 +- Source/Application/VQEngine_Render.cpp | 2 +- Source/Application/VQEngine_Update.cpp | 11 ++ Source/Scenes/DefaultScene.cpp | 18 -- 11 files changed, 359 insertions(+), 182 deletions(-) diff --git a/Source/Application/Camera.cpp b/Source/Application/Camera.cpp index 9faff36a..99e8782d 100644 --- a/Source/Application/Camera.cpp +++ b/Source/Application/Camera.cpp @@ -17,20 +17,17 @@ // Contact: volkanilbeyli@gmail.com #include "Camera.h" +#include "Input.h" #define CAMERA_DEBUG 1 using namespace DirectX; Camera::Camera() - : - MoveSpeed(1000.0f), - AngularSpeedDeg(0.05f), - Drag(9.5f), - mPitch(0.0f), - mYaw(0.0f), - mPosition(0,0,0), - mVelocity(0,0,0) + : mPitch(0.0f) + , mYaw(0.0f) + , mPosition(0,0,0) + , mVelocity(0,0,0) { XMStoreFloat4x4(&mMatProj, XMMatrixIdentity()); XMStoreFloat4x4(&mMatView, XMMatrixIdentity()); @@ -39,6 +36,32 @@ Camera::Camera() Camera::~Camera(void) {} +Camera::Camera(Camera && other) +{ + mPosition = other.mPosition; + mYaw = other.mYaw; + mVelocity = other.mVelocity; + mPitch = other.mPitch; + mProjParams = other.mProjParams; + mMatProj = other.mMatProj; + mMatView = other.mMatView; + pController = std::move(other.pController); +} + +Camera Camera::Clone() +{ + Camera c = {}; + c.mPosition = this->mPosition; + c.mYaw = this->mYaw; + c.mVelocity = this->mVelocity; + c.mPitch = this->mPitch; + c.mProjParams = this->mProjParams; + c.mMatProj = this->mMatProj; + c.mMatView = this->mMatView; + c.pController = std::move(this->pController->Clone(&c)); + return c; // is this dangling too? +} + void Camera::InitializeCamera(const FCameraParameters& data) { const auto& NEAR_PLANE = data.NearPlane; @@ -58,10 +81,21 @@ void Camera::InitializeCamera(const FCameraParameters& data) mYaw = mPitch = 0; SetProjectionMatrix(this->mProjParams); SetPosition(data.x, data.y, data.z); - Rotate(data.Yaw * DEG2RAD, data.Pitch * DEG2RAD, 1.0f); + Rotate(data.Yaw * DEG2RAD, data.Pitch * DEG2RAD); UpdateViewMatrix(); } +void Camera::InitializeController(bool bFirstPersonController) +{ + if (bFirstPersonController) + { + pController = std::make_unique(this); + } + else + { + pController = std::make_unique(this); + } +} void Camera::SetProjectionMatrix(const FProjectionMatrixParameters& params) { @@ -90,21 +124,6 @@ void Camera::UpdateViewMatrix() XMStoreFloat4x4(&mMatView, XMMatrixLookAtLH(pos, lookAt, up)); } -void Camera::Update(const float dt, const FCameraInput& input) -{ - Rotate(dt, input); - Move(dt, input); - - UpdateViewMatrix(); - - // move based on velocity - XMVECTOR P = XMLoadFloat3(&mPosition); - XMVECTOR V = XMLoadFloat3(&mVelocity); - P += V * dt; - XMStoreFloat3(&mPosition, P); -} - - XMFLOAT3 Camera::GetPositionF() const { return mPosition; @@ -167,31 +186,88 @@ void Camera::SetPosition(float x, float y, float z) mPosition = XMFLOAT3(x, y, z); } -void Camera::Rotate(float yaw, float pitch, const float dt) +void Camera::Rotate(float yaw, float pitch) { - mYaw += yaw * dt; - mPitch += pitch * dt; + mYaw += yaw; + mPitch += pitch; if (mPitch > +90.0f * DEG2RAD) mPitch = +90.0f * DEG2RAD; if (mPitch < -90.0f * DEG2RAD) mPitch = -90.0f * DEG2RAD; } -// internal update functions -void Camera::Rotate(const float dt, const FCameraInput& input) +//============================================================================================================== + + +OrbitController::OrbitController(Camera* pCam) + : CameraController(pCam) { - const float& dy = input.DeltaMouseXY[1]; - const float& dx = input.DeltaMouseXY[0]; +} + +void OrbitController::UpdateCamera(const Input& input, float dt) - const float delta = AngularSpeedDeg * DEG2RAD; // rotation doesn't depend on time - Rotate(dx, dy, delta); +{ +} + +CameraController* OrbitController::Clone_impl(Camera* pNewCam) +{ + OrbitController* p = new OrbitController(pNewCam); + p->mF3LookAt = this->mF3LookAt; + return p; +} + +FirstPersonController::FirstPersonController(Camera* pCam) + : CameraController(pCam) +{ } -void Camera::Move(const float dt, const FCameraInput& input) +void FirstPersonController::UpdateCamera(const Input& input, float dt) { - const XMMATRIX MRotation = GetRotationMatrix(); - const XMVECTOR WorldSpaceTranslation = XMVector3TransformCoord(input.LocalTranslationVector, MRotation); + constexpr float CAMERA_MOVEMENT_SPEED_MULTIPLER = 0.75f; + constexpr float CAMERA_MOVEMENT_SPEED_SHIFT_MULTIPLER = 2.0f; + + XMVECTOR LocalSpaceTranslation = XMVectorSet(0, 0, 0, 0); + if (input.IsKeyDown('A')) LocalSpaceTranslation += XMLoadFloat3(&LeftVector); + if (input.IsKeyDown('D')) LocalSpaceTranslation += XMLoadFloat3(&RightVector); + if (input.IsKeyDown('W')) LocalSpaceTranslation += XMLoadFloat3(&ForwardVector); + if (input.IsKeyDown('S')) LocalSpaceTranslation += XMLoadFloat3(&BackVector); + if (input.IsKeyDown('E')) LocalSpaceTranslation += XMLoadFloat3(&UpVector); + if (input.IsKeyDown('Q')) LocalSpaceTranslation += XMLoadFloat3(&DownVector); + if (input.IsKeyDown(VK_SHIFT)) LocalSpaceTranslation *= CAMERA_MOVEMENT_SPEED_SHIFT_MULTIPLER; + LocalSpaceTranslation *= CAMERA_MOVEMENT_SPEED_MULTIPLER; + + // update camera + FCameraInput camInput(LocalSpaceTranslation); + camInput.DeltaMouseXY = input.GetMouseDelta(); + - XMVECTOR V = XMLoadFloat3(&mVelocity); + //this->mpCamera->Update(dt, camInput); + const float RotationSpeed = this->AngularSpeedDeg * DEG2RAD; // rotation doesn't depend on time + const float dy = camInput.DeltaMouseXY[1] * RotationSpeed; + const float dx = camInput.DeltaMouseXY[0] * RotationSpeed; + this->mpCamera->Rotate(dx, dy); + + + //this->mpCamera->Move(dt, camInput); + const XMMATRIX MRotation = this->mpCamera->GetRotationMatrix(); + const XMVECTOR WorldSpaceTranslation = XMVector3TransformCoord(camInput.LocalTranslationVector, MRotation); + + XMVECTOR V = XMLoadFloat3(&this->mpCamera->mVelocity); V += (WorldSpaceTranslation * MoveSpeed - V * Drag) * dt; - XMStoreFloat3(&mVelocity, V); + XMStoreFloat3(&this->mpCamera->mVelocity, V); + + this->mpCamera->UpdateViewMatrix(); + + // move based on velocity + XMVECTOR P = XMLoadFloat3(&this->mpCamera->mPosition); + P += V * dt; + XMStoreFloat3(&this->mpCamera->mPosition, P); +} + +CameraController* FirstPersonController::Clone_impl(Camera* pNewCam) +{ + FirstPersonController* p = new FirstPersonController(pNewCam); + p->AngularSpeedDeg = this->AngularSpeedDeg; + p->Drag = this->Drag; + p->MoveSpeed = this->MoveSpeed; + return p; } diff --git a/Source/Application/Camera.h b/Source/Application/Camera.h index d25b35e4..9432c2f1 100644 --- a/Source/Application/Camera.h +++ b/Source/Application/Camera.h @@ -23,73 +23,39 @@ #include "Math.h" #include +#include -struct FFrustumPlaneset -{ // plane equations: aX + bY + cZ + d = 0 - DirectX::XMFLOAT4 abcd[6]; // r, l, t, b, n, f - enum EPlaneset - { - PL_RIGHT = 0, - PL_LEFT, - PL_TOP, - PL_BOTTOM, - PL_FAR, - PL_NEAR - }; - - // src: http://gamedevs.org/uploads/fast-extraction-viewing-frustum-planes-from-world-view-projection-matrix.pdfe - // gets the frustum planes based on @projectionTransformation. if: - // - // - @projectionTransformation is proj matrix -> view space plane equations - // - @projectionTransformation is viewProj matrix -> world space plane equations - // - @projectionTransformation is worldViewProj matrix -> model space plane equations - // - inline static FFrustumPlaneset ExtractFromMatrix(const DirectX::XMMATRIX& projectionTransformation) - { - const DirectX::XMMATRIX& m = projectionTransformation; - - FFrustumPlaneset viewPlanes; - // TODO: XMVECTOR impl; - viewPlanes.abcd[FFrustumPlaneset::PL_RIGHT] = DirectX::XMFLOAT4( - m.r[0].m128_f32[3] - m.r[0].m128_f32[0], - m.r[1].m128_f32[3] - m.r[1].m128_f32[0], - m.r[2].m128_f32[3] - m.r[2].m128_f32[0], - m.r[3].m128_f32[3] - m.r[3].m128_f32[0] - ); - viewPlanes.abcd[FFrustumPlaneset::PL_LEFT] = DirectX::XMFLOAT4( - m.r[0].m128_f32[3] + m.r[0].m128_f32[0], - m.r[1].m128_f32[3] + m.r[1].m128_f32[0], - m.r[2].m128_f32[3] + m.r[2].m128_f32[0], - m.r[3].m128_f32[3] + m.r[3].m128_f32[0] - ); - viewPlanes.abcd[FFrustumPlaneset::PL_TOP] = DirectX::XMFLOAT4( - m.r[0].m128_f32[3] - m.r[0].m128_f32[1], - m.r[1].m128_f32[3] - m.r[1].m128_f32[1], - m.r[2].m128_f32[3] - m.r[2].m128_f32[1], - m.r[3].m128_f32[3] - m.r[3].m128_f32[1] - ); - viewPlanes.abcd[FFrustumPlaneset::PL_BOTTOM] = DirectX::XMFLOAT4( - m.r[0].m128_f32[3] + m.r[0].m128_f32[1], - m.r[1].m128_f32[3] + m.r[1].m128_f32[1], - m.r[2].m128_f32[3] + m.r[2].m128_f32[1], - m.r[3].m128_f32[3] + m.r[3].m128_f32[1] - ); - viewPlanes.abcd[FFrustumPlaneset::PL_FAR] = DirectX::XMFLOAT4( - m.r[0].m128_f32[3] - m.r[0].m128_f32[2], - m.r[1].m128_f32[3] - m.r[1].m128_f32[2], - m.r[2].m128_f32[3] - m.r[2].m128_f32[2], - m.r[3].m128_f32[3] - m.r[3].m128_f32[2] - ); - viewPlanes.abcd[FFrustumPlaneset::PL_NEAR] = DirectX::XMFLOAT4( - m.r[0].m128_f32[2], - m.r[1].m128_f32[2], - m.r[2].m128_f32[2], - m.r[3].m128_f32[2] - ); - return viewPlanes; - } +class Camera; +class Input; + + + +// --------------------------------------------------------- +// DATA +// --------------------------------------------------------- +struct FProjectionMatrixParameters +{ + float ViewporWidth; // needed for orthographic projection + float ViewporHeight; // needed for orthographic projection + float NearZ; + float FarZ; + float FieldOfView; + bool bPerspectiveProjection; }; +#if 0 // TODO: remove duplication +struct FCameraParameters +{ + float x, y, z; // position + float Yaw, Pitch; // in degrees + + FProjectionMatrixParameters ProjectionParams; + bool FirstPerson; // First Person / orbit + float TranslationSpeed; + float AngularSpeed; + float Drag; +}; +#else struct FCameraParameters { float x, y, z; // position @@ -102,20 +68,13 @@ struct FCameraParameters float FarPlane; float FovV_Degrees; - bool FirstPerson; // First Person / orbit + bool bInitializeCameraController; + bool bFirstPerson; // First Person / orbit float TranslationSpeed; float AngularSpeed; float Drag; }; -struct FProjectionMatrixParameters -{ - float ViewporWidth; // needed for orthographic projection - float ViewporHeight; // needed for orthographic projection - float NearZ; - float FarZ; - float FieldOfView; - bool bPerspectiveProjection; -}; +#endif struct FCameraInput { @@ -126,35 +85,87 @@ struct FCameraInput std::array DeltaMouseXY; }; + + +// --------------------------------------------------------- +// CAMERA CONTROLLERS +// --------------------------------------------------------- +class CameraController +{ +public: + virtual void UpdateCamera(const Input& input, float dt) = 0; + inline std::unique_ptr Clone(Camera* pNewCam) { return std::unique_ptr(Clone_impl(pNewCam)); } +protected: + virtual CameraController* Clone_impl(Camera* pNewCam) = 0; + + CameraController() = delete; + CameraController(Camera* pCamera) : mpCamera(pCamera) {} + +protected: + Camera* mpCamera = nullptr; +}; +class FirstPersonController : public CameraController +{ +public: + FirstPersonController(Camera* pCam);// : CameraController(pCam) + void UpdateCamera(const Input& input, float dt) override; +protected: + CameraController* Clone_impl(Camera* pNewCam) override; +private: + float Drag = 9.5f; + float AngularSpeedDeg = 0.05f; + float MoveSpeed = 1000.0f; +}; +class OrbitController : public CameraController +{ +public: + OrbitController(Camera* pCam); + void UpdateCamera(const Input& input, float dt) override; +protected: + CameraController* Clone_impl(Camera* pNewCam) override; +private: + DirectX::XMFLOAT3 mF3LookAt; +}; + + + +// --------------------------------------------------------- +// CAMERA +// --------------------------------------------------------- class Camera { + friend class OrbitController; + friend class FirstPersonController; public: Camera(); ~Camera(void); + Camera(Camera&& other); + //Camera(const Camera& other); + Camera Clone(); void InitializeCamera(const FCameraParameters& data); + void InitializeController(bool bFirstPersonController); void SetProjectionMatrix(const FProjectionMatrixParameters& params); - void UpdateViewMatrix(); - // updates View Matrix @mMatView - void Update(const float dt, const FCameraInput& input); + void UpdateViewMatrix(); + inline void Update(float dt, const Input& input) { if(pController) pController->UpdateCamera(input, dt); } DirectX::XMFLOAT3 GetPositionF() const; DirectX::XMMATRIX GetViewMatrix() const; DirectX::XMMATRIX GetViewInverseMatrix() const; DirectX::XMMATRIX GetProjectionMatrix() const; DirectX::XMMATRIX GetRotationMatrix() const; + inline const FProjectionMatrixParameters& GetProjectionParameters() const { return mProjParams; } + inline FProjectionMatrixParameters& GetProjectionParameters() { return mProjParams; } // returns World Space frustum plane set FFrustumPlaneset GetViewFrustumPlanes() const; void SetPosition(float x, float y, float z); - void Rotate(float yaw, float pitch, const float dt); - void Move(const float dt, const FCameraInput& input); - void Rotate(const float dt, const FCameraInput& input); - + void Rotate(float yaw, float pitch); +private: //-------------------------- DirectX::XMFLOAT3 mPosition; float mYaw = 0.0f; @@ -164,12 +175,9 @@ class Camera // ------------------------- FProjectionMatrixParameters mProjParams; // ------------------------- - float Drag; - float AngularSpeedDeg; - float MoveSpeed; - // ------------------------- DirectX::XMFLOAT4X4 mMatProj; // ------------------------- DirectX::XMFLOAT4X4 mMatView; // ------------------------- + std::unique_ptr pController; }; diff --git a/Source/Application/FileParser.cpp b/Source/Application/FileParser.cpp index 0bc15b15..3a58dd57 100644 --- a/Source/Application/FileParser.cpp +++ b/Source/Application/FileParser.cpp @@ -378,7 +378,7 @@ std::vector VQEngine::ParseHDRProfilesFile() return HDRProfiles; } -std::vector< FSceneRepresentation> VQEngine::ParseScenesFile() +std::vector< FSceneRepresentation> VQEngine::ParseSceneFiles() { using namespace DirectX; using namespace tinyxml2; @@ -389,10 +389,10 @@ std::vector< FSceneRepresentation> VQEngine::ParseScenesFile() constexpr char* XML_TAG__CAMERA = "Camera"; constexpr char* XML_TAG__GAMEOBJECT = "GameObject"; //----------------------------------------------------------------- - constexpr char* SCENE_FILES_DIRECTORY = "Data/Levels/"; + constexpr char* SCENE_FILES_DIRECTORY = "Data/Levels/"; //----------------------------------------------------------------- - std::vector< FSceneRepresentation> SceneRepresentations; - const std::vector< std::string> SceneFiles = DirectoryUtil::ListFilesInDirectory(SCENE_FILES_DIRECTORY, ".xml"); + std::vector SceneRepresentations; + const std::vector SceneFiles = DirectoryUtil::ListFilesInDirectory(SCENE_FILES_DIRECTORY, ".xml"); //----------------------------------------------------------------- // parse vectors -------------------------------------------------- @@ -518,7 +518,7 @@ std::vector< FSceneRepresentation> VQEngine::ParseScenesFile() // Cameras else if (XML_TAG__CAMERA == CurrEle) { - FCameraParameters cam; + FCameraParameters cam = {}; XMLElement*& pCam = pCurrentSceneElement; // transform @@ -537,6 +537,7 @@ std::vector< FSceneRepresentation> VQEngine::ParseScenesFile() XMLElement* pTSpeed = pFP ? pFP->FirstChildElement("TranslationSpeed") : nullptr; XMLElement* pASpeed = pFP ? pFP->FirstChildElement("AngularSpeed") : nullptr; XMLElement* pDrag = pFP ? pFP->FirstChildElement("Drag") : nullptr; + XMLElement* pOrbit = pCam->FirstChildElement("Orbit"); // transform ---------------------------------------- if (pPos) @@ -565,10 +566,18 @@ std::vector< FSceneRepresentation> VQEngine::ParseScenesFile() // attributes---------------------------------------- if (pFP) { + cam.bInitializeCameraController = true; + cam.bFirstPerson = true; if(pTSpeed) fnParseXMLFloatVal(pTSpeed, cam.TranslationSpeed); if(pASpeed) fnParseXMLFloatVal(pASpeed, cam.AngularSpeed); if(pDrag ) fnParseXMLFloatVal(pDrag , cam.Drag); } + if (pOrbit) + { + cam.bInitializeCameraController = true; + cam.bFirstPerson = false; + + } SceneRep.Cameras.push_back(cam); } @@ -594,19 +603,17 @@ std::vector< FSceneRepresentation> VQEngine::ParseScenesFile() { XMLElement* pMesh = pModel->FirstChildElement("Mesh"); XMLElement* pMaterial = pModel->FirstChildElement("Material"); + XMLElement* pModelPath = pModel->FirstChildElement("Path"); + XMLElement* pModelName = pModel->FirstChildElement("Name"); - if (pMesh) - { - fnParseXMLStringVal(pMesh, obj.BuiltinMeshName); - } + if (pMesh) fnParseXMLStringVal(pMesh, obj.BuiltinMeshName); if (pMaterial) { // TODO } - - // TODO: model loading from disk - //obj.ModelName + if (pModelPath) fnParseXMLStringVal(pModelPath, obj.ModelFilePath); + if (pModelName) fnParseXMLStringVal(pModelName, obj.ModelName); } diff --git a/Source/Application/Math.h b/Source/Application/Math.h index 36c903b0..f55b850c 100644 --- a/Source/Application/Math.h +++ b/Source/Application/Math.h @@ -38,4 +38,70 @@ constexpr DirectX::XMFLOAT3 ZAxis = DirectX::XMFLOAT3(0, 0, 1); DirectX::XMFLOAT4X4 MakeOthographicProjectionMatrix(float screenWidth, float screenHeight, float screenNear, float screenFar); DirectX::XMFLOAT4X4 MakePerspectiveProjectionMatrix(float fovy, float screenAspect, float screenNear, float screenFar); -DirectX::XMFLOAT4X4 MakePerspectiveProjectionMatrixHFov(float fovx, float screenAspectInverse, float screenNear, float screenFar); \ No newline at end of file +DirectX::XMFLOAT4X4 MakePerspectiveProjectionMatrixHFov(float fovx, float screenAspectInverse, float screenNear, float screenFar); + +struct FFrustumPlaneset +{ // plane equations: aX + bY + cZ + d = 0 + DirectX::XMFLOAT4 abcd[6]; // r, l, t, b, n, f + enum EPlaneset + { + PL_RIGHT = 0, + PL_LEFT, + PL_TOP, + PL_BOTTOM, + PL_FAR, + PL_NEAR + }; + + // src: http://gamedevs.org/uploads/fast-extraction-viewing-frustum-planes-from-world-view-projection-matrix.pdfe + // gets the frustum planes based on @projectionTransformation. if: + // + // - @projectionTransformation is proj matrix -> view space plane equations + // - @projectionTransformation is viewProj matrix -> world space plane equations + // - @projectionTransformation is worldViewProj matrix -> model space plane equations + // + inline static FFrustumPlaneset ExtractFromMatrix(const DirectX::XMMATRIX& projectionTransformation) + { + const DirectX::XMMATRIX& m = projectionTransformation; + + FFrustumPlaneset viewPlanes; + // TODO: XMVECTOR impl; + viewPlanes.abcd[FFrustumPlaneset::PL_RIGHT] = DirectX::XMFLOAT4( + m.r[0].m128_f32[3] - m.r[0].m128_f32[0], + m.r[1].m128_f32[3] - m.r[1].m128_f32[0], + m.r[2].m128_f32[3] - m.r[2].m128_f32[0], + m.r[3].m128_f32[3] - m.r[3].m128_f32[0] + ); + viewPlanes.abcd[FFrustumPlaneset::PL_LEFT] = DirectX::XMFLOAT4( + m.r[0].m128_f32[3] + m.r[0].m128_f32[0], + m.r[1].m128_f32[3] + m.r[1].m128_f32[0], + m.r[2].m128_f32[3] + m.r[2].m128_f32[0], + m.r[3].m128_f32[3] + m.r[3].m128_f32[0] + ); + viewPlanes.abcd[FFrustumPlaneset::PL_TOP] = DirectX::XMFLOAT4( + m.r[0].m128_f32[3] - m.r[0].m128_f32[1], + m.r[1].m128_f32[3] - m.r[1].m128_f32[1], + m.r[2].m128_f32[3] - m.r[2].m128_f32[1], + m.r[3].m128_f32[3] - m.r[3].m128_f32[1] + ); + viewPlanes.abcd[FFrustumPlaneset::PL_BOTTOM] = DirectX::XMFLOAT4( + m.r[0].m128_f32[3] + m.r[0].m128_f32[1], + m.r[1].m128_f32[3] + m.r[1].m128_f32[1], + m.r[2].m128_f32[3] + m.r[2].m128_f32[1], + m.r[3].m128_f32[3] + m.r[3].m128_f32[1] + ); + viewPlanes.abcd[FFrustumPlaneset::PL_FAR] = DirectX::XMFLOAT4( + m.r[0].m128_f32[3] - m.r[0].m128_f32[2], + m.r[1].m128_f32[3] - m.r[1].m128_f32[2], + m.r[2].m128_f32[3] - m.r[2].m128_f32[2], + m.r[3].m128_f32[3] - m.r[3].m128_f32[2] + ); + viewPlanes.abcd[FFrustumPlaneset::PL_NEAR] = DirectX::XMFLOAT4( + m.r[0].m128_f32[2], + m.r[1].m128_f32[2], + m.r[2].m128_f32[2], + m.r[3].m128_f32[2] + ); + return viewPlanes; + } +}; diff --git a/Source/Application/Scene.cpp b/Source/Application/Scene.cpp index 3ea9ce44..9a1f2964 100644 --- a/Source/Application/Scene.cpp +++ b/Source/Application/Scene.cpp @@ -38,10 +38,11 @@ Scene::Scene(VQEngine& engine, int NumFrameBuffers, const Input& input, const st void Scene::Update(float dt, int FRAME_DATA_INDEX) { - assert(FRAME_DATA_INDEX < mFrameSceneViews.size()); FSceneView& SceneView = mFrameSceneViews[FRAME_DATA_INDEX]; - + Camera& Cam = this->mCameras[this->mIndex_SelectedCamera]; + + Cam.Update(dt, mInput); this->HandleInput(); this->UpdateScene(dt, SceneView); } @@ -100,24 +101,24 @@ void Scene::StartLoading(FSceneRepresentation& scene) const bool bModelIsBuiltinMesh = !ObjRep.BuiltinMeshName.empty(); const bool bModelIsLoadedFromFile = !ObjRep.ModelFilePath.empty(); assert(bModelIsBuiltinMesh != bModelIsLoadedFromFile); + ModelID mID = mEngine.CreateModel(); + Model& model = mEngine.GetModel(mID); - ModelID mID = INVALID_ID; if (bModelIsBuiltinMesh) { - // create model - mID = mEngine.CreateModel(); - Model& model = mEngine.GetModel(mID); - // create/get mesh MeshID meshID = mEngine.GetBuiltInMeshID(ObjRep.BuiltinMeshName); model.mData.mMeshIDs.push_back(meshID); // TODO: material + + model.mbLoaded = true; } else { - // TODO: load/create model? - //ObjRep.ModelName; // TODO + model.mbLoaded = false; + model.mModelName = ObjRep.ModelName; + model.mModelDirectory = ObjRep.ModelFilePath; } @@ -150,9 +151,21 @@ void Scene::StartLoading(FSceneRepresentation& scene) Camera c; c.InitializeCamera(param); - mCameras.push_back(c); + mCameras.emplace_back(std::move(c)); } + // CAMERA CONTROLLERS + // controllers need to be initialized after mCameras are populated in order + // to prevent dangling pointers in @pController->mpCamera + for (size_t i = 0; i < mCameras.size(); ++i) + { + if (scene.Cameras[i].bInitializeCameraController) + { + mCameras[i].InitializeController(scene.Cameras[i].bFirstPerson); + } + } + + // assign scene rep mSceneRepresentation = scene; } @@ -202,11 +215,22 @@ void Scene::RenderUI() // TODO } +template static inline T CircularIncrement(T currVal, T maxVal) { return (currVal + 1) % maxVal; } +template static inline T CircularDecrement(T currVal, T maxVal) { return currVal == 0 ? maxVal : currVal-1; } + void Scene::HandleInput() { + const bool bIsShiftDown = mInput.IsKeyDown("Shift"); const int NumEnvMaps = static_cast(mResourceNames.mEnvironmentMapPresetNames.size()); - const bool bIsShiftDown = mInput.IsKeyDown("Shift"); + if (mInput.IsKeyTriggered("C")) + { + const int NumCameras = static_cast(mCameras.size()); + mIndex_SelectedCamera = bIsShiftDown + ? CircularDecrement(mIndex_SelectedCamera, NumCameras) + : CircularIncrement(mIndex_SelectedCamera, NumCameras); + } + if (mInput.IsKeyTriggered("PageUp")) { // Change Scene @@ -218,7 +242,7 @@ void Scene::HandleInput() // Change Env Map else { - mIndex_ActiveEnvironmentMapPreset = (mIndex_ActiveEnvironmentMapPreset + 1) % NumEnvMaps; + mIndex_ActiveEnvironmentMapPreset = CircularIncrement(mIndex_ActiveEnvironmentMapPreset, NumEnvMaps); mEngine.StartLoadingEnvironmentMap(mIndex_ActiveEnvironmentMapPreset); } } @@ -233,9 +257,7 @@ void Scene::HandleInput() // Change Env Map else { - mIndex_ActiveEnvironmentMapPreset = mIndex_ActiveEnvironmentMapPreset == 0 - ? NumEnvMaps - 1 - : mIndex_ActiveEnvironmentMapPreset - 1; + mIndex_ActiveEnvironmentMapPreset = CircularDecrement(mIndex_ActiveEnvironmentMapPreset, NumEnvMaps - 1); mEngine.StartLoadingEnvironmentMap(mIndex_ActiveEnvironmentMapPreset); } } diff --git a/Source/Application/VQEngine.h b/Source/Application/VQEngine.h index 2408acb2..6b8caf6a 100644 --- a/Source/Application/VQEngine.h +++ b/Source/Application/VQEngine.h @@ -226,9 +226,7 @@ class VQEngine : public IWindowOwner // Scene Interface // --------------------------------------------------------- void StartLoadingEnvironmentMap(int IndexEnvMap); - - // Busy waits until render thread catches up with update thread - void WaitUntilRenderingFinishes(); + void StartLoadingScene(int IndexScene); // Mesh & Model management ModelID CreateModel(); @@ -318,7 +316,8 @@ class VQEngine : public IWindowOwner // scene FLoadingScreenData mLoadingScreenData; std::queue mQueue_SceneLoad; - + + std::vector< FSceneRepresentation> mSceneRepresentations; int mIndex_SelectedScene; std::unique_ptr mpScene; @@ -387,8 +386,8 @@ class VQEngine : public IWindowOwner void TransitionForPostProcessing(FWindowRenderContext& ctx); void RenderPostProcess(FWindowRenderContext& ctx, const FPostProcessParameters& PPParams); void RenderUI(FWindowRenderContext& ctx); - HRESULT PresentFrame(FWindowRenderContext& ctx); void CompositUIToHDRSwapchain(FWindowRenderContext& ctx); // TODO + HRESULT PresentFrame(FWindowRenderContext& ctx); // temp struct FrameConstantBuffer { DirectX::XMMATRIX matModelViewProj; }; @@ -417,6 +416,9 @@ class VQEngine : public IWindowOwner const FDisplayHDRProfile* GetHDRProfileIfExists(const wchar_t* pwStrLogicalDisplayName); FSetHDRMetaDataParams GatherHDRMetaDataParameters(HWND hwnd); + // Busy waits until render thread catches up with update thread + void WaitUntilRenderingFinishes(); + private: // Reads EngineSettings.ini from next to the executable and returns a @@ -425,7 +427,7 @@ class VQEngine : public IWindowOwner static std::vector> ParseSceneIndexMappingFile(); static std::vector ParseEnvironmentMapsFile(); static std::vector ParseHDRProfilesFile(); - static std::vector ParseScenesFile(); + static std::vector ParseSceneFiles(); public: // Supported HDR Formats { DXGI_FORMAT_R10G10B10A2_UNORM, DXGI_FORMAT_R16G16B16A16_FLOAT } diff --git a/Source/Application/VQEngine_EventHandlers.cpp b/Source/Application/VQEngine_EventHandlers.cpp index 41a7912d..a9703bb0 100644 --- a/Source/Application/VQEngine_EventHandlers.cpp +++ b/Source/Application/VQEngine_EventHandlers.cpp @@ -189,7 +189,7 @@ void VQEngine::UpdateThread_HandleWindowResizeEvent(const std::shared_ptrGetActiveCamera(); - FProjectionMatrixParameters UpdatedProjectionMatrixParams = cam.mProjParams; + FProjectionMatrixParameters UpdatedProjectionMatrixParams = cam.GetProjectionParameters(); UpdatedProjectionMatrixParams.ViewporWidth = static_cast(p->width ); UpdatedProjectionMatrixParams.ViewporHeight = static_cast(p->height); diff --git a/Source/Application/VQEngine_Main.cpp b/Source/Application/VQEngine_Main.cpp index ff5ece32..48ed21ec 100644 --- a/Source/Application/VQEngine_Main.cpp +++ b/Source/Application/VQEngine_Main.cpp @@ -275,7 +275,9 @@ void VQEngine::InitializeScenes() mSceneNames.push_back(std::move(nameIndex.first)); } // read scene files from disk: Data/Scenes/ - std::vector< FSceneRepresentation> SceneReps = VQEngine::ParseScenesFile(); + this->mSceneRepresentations = VQEngine::ParseSceneFiles(); + std::vector< FSceneRepresentation>& SceneReps = this->mSceneRepresentations; + // --------------------------------------------- // find out which scene to load auto it = std::find_if(SceneReps.begin(), SceneReps.end(), [&](const FSceneRepresentation& s) { return s.SceneName == mSettings.StartupScene; }); @@ -285,17 +287,16 @@ void VQEngine::InitializeScenes() Log::Error("Couldn't find scene '%s' among parsed scene files.", mSettings.StartupScene.c_str()); Log::Warning("DefaultScene will be loaded"); it = std::find_if(SceneReps.begin(), SceneReps.end(), [&](const FSceneRepresentation& s) { return s.SceneName == "Default"; }); + assert(it != SceneReps.end()); mSettings.StartupScene = "Default"; } // Create the scene instance fnCreateSceneInstance(mSettings.StartupScene, mpScene); - // queue the selected scene (@mSettings.StartupScene) for loading - assert(it != SceneReps.end()); - mQueue_SceneLoad.push(*it); + // --------------------------------------------- - // set the selected scene index for easily + // set the selected scene index auto it2 = std::find_if(mSceneNames.begin(), mSceneNames.end(), [&](const std::string& scn) { return scn == mSettings.StartupScene; }); bSceneFound = it2 != mSceneNames.end(); if (!bSceneFound) @@ -304,6 +305,8 @@ void VQEngine::InitializeScenes() it2 = mSceneNames.begin(); } mIndex_SelectedScene = static_cast(it2 - mSceneNames.begin()); + + this->StartLoadingScene(mIndex_SelectedScene); } void VQEngine::InitializeThreads() diff --git a/Source/Application/VQEngine_Render.cpp b/Source/Application/VQEngine_Render.cpp index 25826f13..5d3f2bfd 100644 --- a/Source/Application/VQEngine_Render.cpp +++ b/Source/Application/VQEngine_Render.cpp @@ -753,7 +753,7 @@ void VQEngine::RenderSceneColor(FWindowRenderContext& ctx, const FSceneView& Sce { ID3D12DescriptorHeap* ppHeaps[] = { mRenderer.GetDescHeap(EResourceHeapType::CBV_SRV_UAV_HEAP) }; - Camera skyCam = mpScene->GetActiveCamera(); + Camera skyCam = mpScene->GetActiveCamera().Clone(); skyCam.SetPosition(0, 0, 0); skyCam.UpdateViewMatrix(); diff --git a/Source/Application/VQEngine_Update.cpp b/Source/Application/VQEngine_Update.cpp index b3d000f9..85100f6a 100644 --- a/Source/Application/VQEngine_Update.cpp +++ b/Source/Application/VQEngine_Update.cpp @@ -363,6 +363,17 @@ void VQEngine::StartLoadingEnvironmentMap(int IndexEnvMap) }); } +void VQEngine::StartLoadingScene(int IndexScene) +{ + assert(IndexScene >= 0 && IndexScene < mResourceNames.mSceneNames.size()); + + // get scene representation + const std::string& SceneName = mResourceNames.mSceneNames[IndexScene]; + + // queue the selected scene for loading + mQueue_SceneLoad.push(mSceneRepresentations[IndexScene]); +} + void VQEngine::WaitUntilRenderingFinishes() { while ((mNumRenderLoopsExecuted + 1) != mNumUpdateLoopsExecuted); diff --git a/Source/Scenes/DefaultScene.cpp b/Source/Scenes/DefaultScene.cpp index 17b90318..203b3bfb 100644 --- a/Source/Scenes/DefaultScene.cpp +++ b/Source/Scenes/DefaultScene.cpp @@ -25,18 +25,6 @@ void DefaultScene::UpdateScene(float dt, FSceneView& SceneView) cam.InitializeCamera(params); } - constexpr float CAMERA_MOVEMENT_SPEED_MULTIPLER = 0.75f; - constexpr float CAMERA_MOVEMENT_SPEED_SHIFT_MULTIPLER = 2.0f; - XMVECTOR LocalSpaceTranslation = XMVectorSet(0, 0, 0, 0); - if (mInput.IsKeyDown('A')) LocalSpaceTranslation += XMLoadFloat3(&LeftVector); - if (mInput.IsKeyDown('D')) LocalSpaceTranslation += XMLoadFloat3(&RightVector); - if (mInput.IsKeyDown('W')) LocalSpaceTranslation += XMLoadFloat3(&ForwardVector); - if (mInput.IsKeyDown('S')) LocalSpaceTranslation += XMLoadFloat3(&BackVector); - if (mInput.IsKeyDown('E')) LocalSpaceTranslation += XMLoadFloat3(&UpVector); - if (mInput.IsKeyDown('Q')) LocalSpaceTranslation += XMLoadFloat3(&DownVector); - if (mInput.IsKeyDown(VK_SHIFT)) LocalSpaceTranslation *= CAMERA_MOVEMENT_SPEED_SHIFT_MULTIPLER; - LocalSpaceTranslation *= CAMERA_MOVEMENT_SPEED_MULTIPLER; - if (mInput.IsKeyTriggered("Space")) Toggle(this->bObjectAnimation); Transform* pTF = mpTransforms[pObject->mTransformID]; @@ -55,12 +43,6 @@ void DefaultScene::UpdateScene(float dt, FSceneView& SceneView) if (mInput.IsMouseScrollUp()) pTF->SetUniformScale(CubeScale * SCROLL_SCALE_DELTA); if (mInput.IsMouseScrollDown()) pTF->SetUniformScale(std::max(0.5f, CubeScale / SCROLL_SCALE_DELTA)); - - // update camera - FCameraInput camInput(LocalSpaceTranslation); - camInput.DeltaMouseXY = mInput.GetMouseDelta(); - cam.Update(dt, camInput); - // update scene data if (this->bObjectAnimation) pTF->RotateAroundAxisRadians(YAxis, dt * 0.2f * PI); From 04e575202db1efb88a33c96b6022634db3a9b988 Mon Sep 17 00:00:00 2001 From: Volkan Date: Tue, 18 Aug 2020 01:26:33 -0700 Subject: [PATCH 10/67] Scene load/unload and scene switching with Shift+PageUp/Dwn --- Data/Levels/Sponza.xml | 2 +- Source/Application/Memory.h | 2 +- Source/Application/Platform.h | 4 +++ Source/Application/Scene.cpp | 33 ++++----------------- Source/Application/VQEngine_Main.cpp | 14 --------- Source/Application/VQEngine_Update.cpp | 41 +++++++++++++++++++++++++- 6 files changed, 51 insertions(+), 45 deletions(-) diff --git a/Data/Levels/Sponza.xml b/Data/Levels/Sponza.xml index 6b577621..8b95b173 100644 --- a/Data/Levels/Sponza.xml +++ b/Data/Levels/Sponza.xml @@ -66,7 +66,7 @@ 1 1 1 - Cube + Triangle diff --git a/Source/Application/Memory.h b/Source/Application/Memory.h index 943c48ea..eec399dd 100644 --- a/Source/Application/Memory.h +++ b/Source/Application/Memory.h @@ -35,7 +35,7 @@ inline constexpr size_t AlignTo(size_t size, size_t alignment = 64) return (size + alignment - 1) & ~(alignment - 1); } -#define MEMORY_POOL__ENABLE_DEBUG_LOG 1 +#define MEMORY_POOL__ENABLE_DEBUG_LOG 0 #define MEMORY_POOL__LOG_VERBOSE 0 #if MEMORY_POOL__ENABLE_DEBUG_LOG #include "../../Libs/VQUtils/Source/Log.h" diff --git a/Source/Application/Platform.h b/Source/Application/Platform.h index 8537f14f..f582f862 100644 --- a/Source/Application/Platform.h +++ b/Source/Application/Platform.h @@ -63,3 +63,7 @@ struct FStartupParameters LRESULT CALLBACK WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam); // ------------------------------------------------------------------------------- + + +template static inline T CircularIncrement(T currVal, T maxVal) { return (currVal + 1) % maxVal; } +template static inline T CircularDecrement(T currVal, T maxVal) { return currVal == 0 ? maxVal : currVal - 1; } \ No newline at end of file diff --git a/Source/Application/Scene.cpp b/Source/Application/Scene.cpp index 9a1f2964..33ce7bc1 100644 --- a/Source/Application/Scene.cpp +++ b/Source/Application/Scene.cpp @@ -156,7 +156,7 @@ void Scene::StartLoading(FSceneRepresentation& scene) // CAMERA CONTROLLERS // controllers need to be initialized after mCameras are populated in order - // to prevent dangling pointers in @pController->mpCamera + // to prevent dangling pointers in @pController->mpCamera (circular ptrs) for (size_t i = 0; i < mCameras.size(); ++i) { if (scene.Cameras[i].bInitializeCameraController) @@ -215,9 +215,6 @@ void Scene::RenderUI() // TODO } -template static inline T CircularIncrement(T currVal, T maxVal) { return (currVal + 1) % maxVal; } -template static inline T CircularDecrement(T currVal, T maxVal) { return currVal == 0 ? maxVal : currVal-1; } - void Scene::HandleInput() { const bool bIsShiftDown = mInput.IsKeyDown("Shift"); @@ -233,32 +230,12 @@ void Scene::HandleInput() if (mInput.IsKeyTriggered("PageUp")) { - // Change Scene - if (bIsShiftDown) - { - - } - - // Change Env Map - else - { - mIndex_ActiveEnvironmentMapPreset = CircularIncrement(mIndex_ActiveEnvironmentMapPreset, NumEnvMaps); - mEngine.StartLoadingEnvironmentMap(mIndex_ActiveEnvironmentMapPreset); - } + mIndex_ActiveEnvironmentMapPreset = CircularIncrement(mIndex_ActiveEnvironmentMapPreset, NumEnvMaps); + mEngine.StartLoadingEnvironmentMap(mIndex_ActiveEnvironmentMapPreset); } if (mInput.IsKeyTriggered("PageDown")) { - // Change Scene - if (bIsShiftDown) - { - - } - - // Change Env Map - else - { - mIndex_ActiveEnvironmentMapPreset = CircularDecrement(mIndex_ActiveEnvironmentMapPreset, NumEnvMaps - 1); - mEngine.StartLoadingEnvironmentMap(mIndex_ActiveEnvironmentMapPreset); - } + mIndex_ActiveEnvironmentMapPreset = CircularDecrement(mIndex_ActiveEnvironmentMapPreset, NumEnvMaps - 1); + mEngine.StartLoadingEnvironmentMap(mIndex_ActiveEnvironmentMapPreset); } } diff --git a/Source/Application/VQEngine_Main.cpp b/Source/Application/VQEngine_Main.cpp index 48ed21ec..ca946d5b 100644 --- a/Source/Application/VQEngine_Main.cpp +++ b/Source/Application/VQEngine_Main.cpp @@ -18,8 +18,6 @@ #include "VQEngine.h" -#include "../Scenes/Scenes.h" - #include #ifdef _DEBUG @@ -257,17 +255,8 @@ void VQEngine::InitializeEnvironmentMaps() void VQEngine::InitializeScenes() { - const int NUM_SWAPCHAIN_BACKBUFFERS = mSettings.gfx.bUseTripleBuffering ? 3 : 2; - const Input& input = mInputStates.at(mpWinMain->GetHWND()); std::vector& mSceneNames = mResourceNames.mSceneNames; - auto fnCreateSceneInstance = [&](const std::string& SceneType, std::unique_ptr& pScene) -> void - { - if (SceneType == "Default") pScene = std::make_unique(*this, NUM_SWAPCHAIN_BACKBUFFERS, input, mpWinMain); - else if (SceneType == "Sponza") pScene = std::make_unique(*this, NUM_SWAPCHAIN_BACKBUFFERS, input, mpWinMain); - }; - - // Read Scene Index Mappings from file and initialize @mSceneNames { std::vector> SceneIndexMappings = VQEngine::ParseSceneIndexMappingFile(); @@ -291,9 +280,6 @@ void VQEngine::InitializeScenes() mSettings.StartupScene = "Default"; } - // Create the scene instance - fnCreateSceneInstance(mSettings.StartupScene, mpScene); - // --------------------------------------------- // set the selected scene index diff --git a/Source/Application/VQEngine_Update.cpp b/Source/Application/VQEngine_Update.cpp index 85100f6a..71fb987a 100644 --- a/Source/Application/VQEngine_Update.cpp +++ b/Source/Application/VQEngine_Update.cpp @@ -21,6 +21,8 @@ #include "VQEngine.h" #include "Math.h" #include "Scene.h" +#include "../Scenes/Scenes.h" + #include "Libs/VQUtils/Source/utils.h" @@ -190,6 +192,7 @@ void VQEngine::HandleEngineInput() HWND hwnd = it->first; Input& input = it->second; auto& pWin = this->GetWindow(hwnd); + const bool bIsShiftDown = input.IsKeyDown("Shift"); // // Process-level input handling @@ -232,6 +235,20 @@ void VQEngine::HandleEngineInput() Log::Info("Tonemapper: ApplyGamma=%d (SDR-only)", PPParams.ToggleGammaCorrection); } } + if (bIsShiftDown) + { + const int NumScenes = static_cast(mSceneRepresentations.size()); + if (input.IsKeyTriggered("PageUp") && !mbLoadingLevel) + { + mIndex_SelectedScene = CircularIncrement(mIndex_SelectedScene, NumScenes); + this->StartLoadingScene(mIndex_SelectedScene); + } + if (input.IsKeyTriggered("PageDown") && !mbLoadingLevel) + { + mIndex_SelectedScene = CircularDecrement(mIndex_SelectedScene, NumScenes-1); + this->StartLoadingScene(mIndex_SelectedScene); + } + } } } @@ -355,6 +372,7 @@ const Model& VQEngine::GetModel(ModelID id) const void VQEngine::StartLoadingEnvironmentMap(int IndexEnvMap) { + this->WaitUntilRenderingFinishes(); mAppState = EAppState::LOADING; mbLoadingLevel = true; mWorkers_Load.AddTask([&, IndexEnvMap]() @@ -372,11 +390,14 @@ void VQEngine::StartLoadingScene(int IndexScene) // queue the selected scene for loading mQueue_SceneLoad.push(mSceneRepresentations[IndexScene]); + + mAppState = INITIALIZING; + Log::Info("StartLoadingScene: %d", IndexScene); } void VQEngine::WaitUntilRenderingFinishes() { - while ((mNumRenderLoopsExecuted + 1) != mNumUpdateLoopsExecuted); + while (mNumRenderLoopsExecuted != mNumUpdateLoopsExecuted); } ModelID VQEngine::CreateModel() @@ -433,6 +454,24 @@ void VQEngine::Load_SceneData_Dispatch() FSceneRepresentation SceneRep = mQueue_SceneLoad.front(); mQueue_SceneLoad.pop(); + const int NUM_SWAPCHAIN_BACKBUFFERS = mSettings.gfx.bUseTripleBuffering ? 3 : 2; + const Input& input = mInputStates.at(mpWinMain->GetHWND()); + + auto fnCreateSceneInstance = [&](const std::string& SceneType, std::unique_ptr& pScene) -> void + { + if (SceneType == "Default") pScene = std::make_unique(*this, NUM_SWAPCHAIN_BACKBUFFERS, input, mpWinMain); + else if (SceneType == "Sponza") pScene = std::make_unique(*this, NUM_SWAPCHAIN_BACKBUFFERS, input, mpWinMain); + }; + + if (mpScene) + { + this->WaitUntilRenderingFinishes(); + mpScene->Unload(); + } + + fnCreateSceneInstance(SceneRep.SceneName, mpScene); + + // let the custom scene logic edit the scene representation mpScene->StartLoading(SceneRep); From 714acf1c212eca828198d8bf43e4d6630a4aebae Mon Sep 17 00:00:00 2001 From: Volkan Date: Tue, 18 Aug 2020 02:47:09 -0700 Subject: [PATCH 11/67] Fix environment map unloading on scene loading --- Source/Application/Scene.cpp | 6 +-- Source/Application/VQEngine.h | 2 + Source/Application/VQEngine_Update.cpp | 56 ++++++++++++++++++-------- 3 files changed, 45 insertions(+), 19 deletions(-) diff --git a/Source/Application/Scene.cpp b/Source/Application/Scene.cpp index 33ce7bc1..c3f86e8c 100644 --- a/Source/Application/Scene.cpp +++ b/Source/Application/Scene.cpp @@ -205,9 +205,9 @@ void Scene::Unload() mMeshBoundingBoxes.clear(); mGameObjectBoundingBoxes.clear(); - mIndex_SelectedCamera - = mIndex_ActiveEnvironmentMapPreset - = 0; + mIndex_SelectedCamera = 0; + mIndex_ActiveEnvironmentMapPreset = -1; + mEngine.UnloadEnvironmentMap(); } void Scene::RenderUI() diff --git a/Source/Application/VQEngine.h b/Source/Application/VQEngine.h index 6b8caf6a..81266f04 100644 --- a/Source/Application/VQEngine.h +++ b/Source/Application/VQEngine.h @@ -228,6 +228,8 @@ class VQEngine : public IWindowOwner void StartLoadingEnvironmentMap(int IndexEnvMap); void StartLoadingScene(int IndexScene); + void UnloadEnvironmentMap(); + // Mesh & Model management ModelID CreateModel(); diff --git a/Source/Application/VQEngine_Update.cpp b/Source/Application/VQEngine_Update.cpp index 71fb987a..2150b3b2 100644 --- a/Source/Application/VQEngine_Update.cpp +++ b/Source/Application/VQEngine_Update.cpp @@ -105,12 +105,13 @@ void VQEngine::UpdateThread_UpdateAppState(const float dt) if (mAppState == EAppState::INITIALIZING) { // start loading - Log::Info("Update Thread starts loading..."); + Log::Info("UpdateThread: loading..."); // start load level Load_SceneData_Dispatch(); - mAppState = EAppState::LOADING;// not thread-safe + // set state + mAppState = EAppState::LOADING;// not thread-safe mbLoadingLevel.store(true); // thread-safe } @@ -216,8 +217,9 @@ void VQEngine::HandleEngineInput() mEventQueue_VQEToWin_Main.AddItem(std::make_shared(hwnd, true, false)); } } - if (pWin == mpWinMain) // Graphics Settings Controls + if (pWin == mpWinMain) { + // Graphics Settings Controls if (input.IsKeyTriggered("V")) { auto& SwapChain = mRenderer.GetWindowSwapChain(hwnd); @@ -234,18 +236,30 @@ void VQEngine::HandleEngineInput() PPParams.ToggleGammaCorrection = PPParams.ToggleGammaCorrection == 1 ? 0 : 1; Log::Info("Tonemapper: ApplyGamma=%d (SDR-only)", PPParams.ToggleGammaCorrection); } - } - if (bIsShiftDown) - { - const int NumScenes = static_cast(mSceneRepresentations.size()); - if (input.IsKeyTriggered("PageUp") && !mbLoadingLevel) + + // Scene switching + if (bIsShiftDown) + { + const int NumScenes = static_cast(mSceneRepresentations.size()); + if (input.IsKeyTriggered("PageUp") && !mbLoadingLevel) + { + mIndex_SelectedScene = CircularIncrement(mIndex_SelectedScene, NumScenes); + this->StartLoadingScene(mIndex_SelectedScene); + } + if (input.IsKeyTriggered("PageDown") && !mbLoadingLevel) + { + mIndex_SelectedScene = CircularDecrement(mIndex_SelectedScene, NumScenes - 1); + this->StartLoadingScene(mIndex_SelectedScene); + } + } + if (input.IsKeyTriggered("1") && !mbLoadingLevel) { - mIndex_SelectedScene = CircularIncrement(mIndex_SelectedScene, NumScenes); + mIndex_SelectedScene = 0; this->StartLoadingScene(mIndex_SelectedScene); } - if (input.IsKeyTriggered("PageDown") && !mbLoadingLevel) + if (input.IsKeyTriggered("2") && !mbLoadingLevel) { - mIndex_SelectedScene = CircularDecrement(mIndex_SelectedScene, NumScenes-1); + mIndex_SelectedScene = 1; this->StartLoadingScene(mIndex_SelectedScene); } } @@ -395,6 +409,20 @@ void VQEngine::StartLoadingScene(int IndexScene) Log::Info("StartLoadingScene: %d", IndexScene); } +void VQEngine::UnloadEnvironmentMap() +{ + FEnvironmentMap& env = mResources_MainWnd.EnvironmentMap; + if (env.Tex_HDREnvironment != INVALID_ID) + { + // GPU-sync assumed + mRenderer.GetWindowSwapChain(mpWinMain->GetHWND()).WaitForGPU(); + mRenderer.DestroySRV(env.SRV_HDREnvironment); + mRenderer.DestroyTexture(env.Tex_HDREnvironment); + env.SRV_HDREnvironment = env.Tex_HDREnvironment = INVALID_ID; + env.MaxContentLightLevel = 0; + } +} + void VQEngine::WaitUntilRenderingFinishes() { while (mNumRenderLoopsExecuted != mNumUpdateLoopsExecuted); @@ -493,11 +521,7 @@ void VQEngine::LoadEnvironmentMap(const std::string& EnvMapName) if (env.Tex_HDREnvironment != INVALID_ID) { assert(env.SRV_HDREnvironment != INVALID_ID); - // GPU-sync assumed - mRenderer.GetWindowSwapChain(mpWinMain->GetHWND()).WaitForGPU(); - mRenderer.DestroySRV(env.SRV_HDREnvironment); - mRenderer.DestroyTexture(env.Tex_HDREnvironment); - env.MaxContentLightLevel = 0; + UnloadEnvironmentMap(); } const FEnvironmentMapDescriptor& desc = this->GetEnvironmentMapDesc(EnvMapName); From 34391777238e8a5abf608396e716b396678f8e82 Mon Sep 17 00:00:00 2001 From: Volkan Date: Tue, 18 Aug 2020 03:10:07 -0700 Subject: [PATCH 12/67] Add 2 new scenes: stress test + geometry unit test --- CMakeLists.txt | 6 +- Data/EngineSettings.ini | 2 +- Data/Levels/GeometryUnitTest.xml | 82 +++++++++++++++++++ Data/Levels/StressTest.xml | 79 ++++++++++++++++++ Data/Scenes.ini | 4 +- Source/Application/VQEngine_Update.cpp | 32 +++----- Source/Scenes/GeometryUnitTestScene.cpp | 27 ++++++ Source/Scenes/Scenes.h | 13 +++ Source/Scenes/{Sponza.cpp => SponzaScene.cpp} | 0 Source/Scenes/StressTestScene.cpp | 63 ++++++++++++++ 10 files changed, 282 insertions(+), 26 deletions(-) create mode 100644 Data/Levels/GeometryUnitTest.xml create mode 100644 Data/Levels/StressTest.xml create mode 100644 Source/Scenes/GeometryUnitTestScene.cpp rename Source/Scenes/{Sponza.cpp => SponzaScene.cpp} (100%) create mode 100644 Source/Scenes/StressTestScene.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index d44b6cec..14da7220 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -20,9 +20,13 @@ set (Resource set (Scenes "Data/Levels/Default.xml" "Data/Levels/Sponza.xml" + "Data/Levels/GeometryUnitTest.xml" + "Data/Levels/StressTest.xml" "Source/Scenes/Scenes.h" "Source/Scenes/DefaultScene.cpp" - "Source/Scenes/Sponza.cpp" + "Source/Scenes/SponzaScene.cpp" + "Source/Scenes/GeometryUnitTestScene.cpp" + "Source/Scenes/StressTestScene.cpp" ) set (Config diff --git a/Data/EngineSettings.ini b/Data/EngineSettings.ini index 050f09b5..07744e88 100644 --- a/Data/EngineSettings.ini +++ b/Data/EngineSettings.ini @@ -13,7 +13,7 @@ Width=768 Height=432 DisplayMode=Windowed PreferredDisplay=0 -Scene=Default +Scene=Sponza DebugWindow=false DebugWindowWidth=450 diff --git a/Data/Levels/GeometryUnitTest.xml b/Data/Levels/GeometryUnitTest.xml new file mode 100644 index 00000000..35e9681f --- /dev/null +++ b/Data/Levels/GeometryUnitTest.xml @@ -0,0 +1,82 @@ + + + + + + + + + + + + 0.0 3.0 -5 + 15 + 0 + Perspective + 60.0 + 0.01 + 1000 + + + 1000 + 0.05 + 9.5 + + + + + + + 0.0 3.0 14 + 30 0 15 + 3.1 3.1 3.1 + + + Cube + + + + + + + + + 0 0 0 + 0 0 0 1 + 1 1 1 + + + Triangle + + + + + + + + + + + diff --git a/Data/Levels/StressTest.xml b/Data/Levels/StressTest.xml new file mode 100644 index 00000000..413d4f6c --- /dev/null +++ b/Data/Levels/StressTest.xml @@ -0,0 +1,79 @@ + + + + + + + + + + + + 0.0 3.0 -5 + 15 + 0 + Perspective + 60.0 + 0.01 + 1000 + + + 1000 + 0.05 + 9.5 + + + + + + -10 0 0 + 0 0 0 1 + 1 1 1 + + + Triangle + + + + + + + + -5 0 0 + 0 0 0 1 + 1 1 1 + + + Cube + + + + + + + + + + diff --git a/Data/Scenes.ini b/Data/Scenes.ini index f824eb96..4b060833 100644 --- a/Data/Scenes.ini +++ b/Data/Scenes.ini @@ -1,5 +1,5 @@ [SceneMapping] Default=0 Sponza=1 -HelloGeometry=2 -HelloLights=3 \ No newline at end of file +GeometryUnitTest=2 +StressTest=3 \ No newline at end of file diff --git a/Source/Application/VQEngine_Update.cpp b/Source/Application/VQEngine_Update.cpp index 2150b3b2..ad89d349 100644 --- a/Source/Application/VQEngine_Update.cpp +++ b/Source/Application/VQEngine_Update.cpp @@ -241,27 +241,13 @@ void VQEngine::HandleEngineInput() if (bIsShiftDown) { const int NumScenes = static_cast(mSceneRepresentations.size()); - if (input.IsKeyTriggered("PageUp") && !mbLoadingLevel) - { - mIndex_SelectedScene = CircularIncrement(mIndex_SelectedScene, NumScenes); - this->StartLoadingScene(mIndex_SelectedScene); - } - if (input.IsKeyTriggered("PageDown") && !mbLoadingLevel) - { - mIndex_SelectedScene = CircularDecrement(mIndex_SelectedScene, NumScenes - 1); - this->StartLoadingScene(mIndex_SelectedScene); - } - } - if (input.IsKeyTriggered("1") && !mbLoadingLevel) - { - mIndex_SelectedScene = 0; - this->StartLoadingScene(mIndex_SelectedScene); - } - if (input.IsKeyTriggered("2") && !mbLoadingLevel) - { - mIndex_SelectedScene = 1; - this->StartLoadingScene(mIndex_SelectedScene); + if (input.IsKeyTriggered("PageUp") && !mbLoadingLevel) { mIndex_SelectedScene = CircularIncrement(mIndex_SelectedScene, NumScenes); this->StartLoadingScene(mIndex_SelectedScene); } + if (input.IsKeyTriggered("PageDown") && !mbLoadingLevel){ mIndex_SelectedScene = CircularDecrement(mIndex_SelectedScene, NumScenes - 1); this->StartLoadingScene(mIndex_SelectedScene); } } + if (input.IsKeyTriggered("1") && !mbLoadingLevel) { mIndex_SelectedScene = 0; this->StartLoadingScene(mIndex_SelectedScene); } + if (input.IsKeyTriggered("2") && !mbLoadingLevel) { mIndex_SelectedScene = 1; this->StartLoadingScene(mIndex_SelectedScene); } + if (input.IsKeyTriggered("3") && !mbLoadingLevel) { mIndex_SelectedScene = 2; this->StartLoadingScene(mIndex_SelectedScene); } + if (input.IsKeyTriggered("4") && !mbLoadingLevel) { mIndex_SelectedScene = 3; this->StartLoadingScene(mIndex_SelectedScene); } } } } @@ -487,8 +473,10 @@ void VQEngine::Load_SceneData_Dispatch() auto fnCreateSceneInstance = [&](const std::string& SceneType, std::unique_ptr& pScene) -> void { - if (SceneType == "Default") pScene = std::make_unique(*this, NUM_SWAPCHAIN_BACKBUFFERS, input, mpWinMain); - else if (SceneType == "Sponza") pScene = std::make_unique(*this, NUM_SWAPCHAIN_BACKBUFFERS, input, mpWinMain); + if (SceneType == "Default") pScene = std::make_unique(*this, NUM_SWAPCHAIN_BACKBUFFERS, input, mpWinMain); + else if (SceneType == "Sponza") pScene = std::make_unique(*this, NUM_SWAPCHAIN_BACKBUFFERS, input, mpWinMain); + else if (SceneType == "StressTest") pScene = std::make_unique(*this, NUM_SWAPCHAIN_BACKBUFFERS, input, mpWinMain); + else if (SceneType == "GeometryUnitTest") pScene = std::make_unique(*this, NUM_SWAPCHAIN_BACKBUFFERS, input, mpWinMain); }; if (mpScene) diff --git a/Source/Scenes/GeometryUnitTestScene.cpp b/Source/Scenes/GeometryUnitTestScene.cpp new file mode 100644 index 00000000..8df40f70 --- /dev/null +++ b/Source/Scenes/GeometryUnitTestScene.cpp @@ -0,0 +1,27 @@ +#include "Scenes.h" + +void GeometryUnitTestScene::UpdateScene(float dt, FSceneView& SceneView) +{ + +} + + +void GeometryUnitTestScene::InitializeScene() +{ + +} + + +void GeometryUnitTestScene::LoadScene(FSceneRepresentation& scene) +{ +} + +void GeometryUnitTestScene::UnloadScene() +{ + +} + +void GeometryUnitTestScene::RenderSceneUI() const +{ +} + diff --git a/Source/Scenes/Scenes.h b/Source/Scenes/Scenes.h index cfa5bce7..8d4b2e52 100644 --- a/Source/Scenes/Scenes.h +++ b/Source/Scenes/Scenes.h @@ -42,3 +42,16 @@ class SponzaScene : public Scene DECLARE_CTOR(SponzaScene) }; +class GeometryUnitTestScene : public Scene +{ + DECLARE_SCENE_INTERFACE() + + DECLARE_CTOR(GeometryUnitTestScene) +}; + +class StressTestScene : public Scene +{ + DECLARE_SCENE_INTERFACE() + + DECLARE_CTOR(StressTestScene) +}; \ No newline at end of file diff --git a/Source/Scenes/Sponza.cpp b/Source/Scenes/SponzaScene.cpp similarity index 100% rename from Source/Scenes/Sponza.cpp rename to Source/Scenes/SponzaScene.cpp diff --git a/Source/Scenes/StressTestScene.cpp b/Source/Scenes/StressTestScene.cpp new file mode 100644 index 00000000..2f3922dd --- /dev/null +++ b/Source/Scenes/StressTestScene.cpp @@ -0,0 +1,63 @@ +#define NOMINMAX + +#include "Scenes.h" + +#include "../Application/Input.h" + +using namespace DirectX; + + +void StressTestScene::UpdateScene(float dt, FSceneView& SceneView) +{ + +} + + +void StressTestScene::InitializeScene() +{ + +} + + +void StressTestScene::LoadScene(FSceneRepresentation& scene) +{ + constexpr int NUM_OBJECTS = 1024; + + constexpr int DIMENSION_X = 16; + constexpr int DIMENSION_Y = 4; + constexpr int DIMENSION_Z = 16; +#if 0 + for (int i = 0; i < NUM_OBJECTS; ++i) +#else + constexpr float distance = 5.0f; + for(int x=-DIMENSION_X/2; x Date: Tue, 18 Aug 2020 12:02:37 -0700 Subject: [PATCH 13/67] Remove dead code, fix copyrights --- Source/Application/Camera.cpp | 4 +- Source/Application/GameObject.cpp | 4 +- Source/Application/GameObject.h | 4 +- Source/Application/Light.cpp | 212 +----------------------------- Source/Application/Light.h | 186 +------------------------- Source/Application/Scene.cpp | 4 +- Source/Application/Scene.h | 4 +- Source/Renderer/Texture.h | 24 ++++ 8 files changed, 42 insertions(+), 400 deletions(-) diff --git a/Source/Application/Camera.cpp b/Source/Application/Camera.cpp index 99e8782d..52f37e98 100644 --- a/Source/Application/Camera.cpp +++ b/Source/Application/Camera.cpp @@ -1,5 +1,5 @@ -// VQEngine | DirectX11 Renderer -// Copyright(C) 2018 - Volkan Ilbeyli +// VQE +// Copyright(C) 2020 - Volkan Ilbeyli // // This program is free software : you can redistribute it and / or modify // it under the terms of the GNU General Public License as published by diff --git a/Source/Application/GameObject.cpp b/Source/Application/GameObject.cpp index 2d25a6f4..b5e3d538 100644 --- a/Source/Application/GameObject.cpp +++ b/Source/Application/GameObject.cpp @@ -1,5 +1,5 @@ -// VQEngine | DirectX11 Renderer -// Copyright(C) 2018 - Volkan Ilbeyli +// VQE +// Copyright(C) 2020 - Volkan Ilbeyli // // This program is free software : you can redistribute it and / or modify // it under the terms of the GNU General Public License as published by diff --git a/Source/Application/GameObject.h b/Source/Application/GameObject.h index 9ac2ffbf..d6555b18 100644 --- a/Source/Application/GameObject.h +++ b/Source/Application/GameObject.h @@ -1,5 +1,5 @@ -// VQEngine | DirectX11 Renderer -// Copyright(C) 2018 - Volkan Ilbeyli +// VQE +// Copyright(C) 2020 - Volkan Ilbeyli // // This program is free software : you can redistribute it and / or modify // it under the terms of the GNU General Public License as published by diff --git a/Source/Application/Light.cpp b/Source/Application/Light.cpp index 5c469c39..41b8e9f8 100644 --- a/Source/Application/Light.cpp +++ b/Source/Application/Light.cpp @@ -1,5 +1,5 @@ -// VQEngine | DirectX11 Renderer -// Copyright(C) 2018 - Volkan Ilbeyli +// VQE +// Copyright(C) 2020 - Volkan Ilbeyli // // This program is free software : you can redistribute it and / or modify // it under the terms of the GNU General Public License as published by @@ -18,210 +18,4 @@ #include "Light.h" -#if 0 -#include "Engine/GameObject.h" - -#include "Utilities/Log.h" - -#include - -using std::string; - -// [OPTIMIZATION] -// -// caching light matrices will make the Scene calculate matrices once and -// store them in the mViewMatrix[6] and mProjectionMatrix. This way, we avoid -// matrix creation function calls during point light shadow view culling phase -// and just return the cached float16. Saves ~25% from point light culling CPU time. -// -#define CACHE_LIGHT_MATRICES 1 - - -// I want my parameter names, Windows... -#ifdef near -#undef near -#endif -#ifdef far -#undef far -#endif - - -DirectX::XMMATRIX Light::CalculateSpotLightViewMatrix(const Transform& mTransform) -{ - XMVECTOR up = vec3::Up; - XMVECTOR lookAt = vec3::Forward; // spot light default orientation looks up - lookAt = XMVector3TransformCoord(lookAt, mTransform.RotationMatrix()); - up = XMVector3TransformCoord(up, mTransform.RotationMatrix()); - XMVECTOR pos = mTransform._position; - XMVECTOR taraget = pos + lookAt; - return XMMatrixLookAtLH(pos, taraget, up); -} - -DirectX::XMMATRIX Light::CalculatePointLightViewMatrix(Texture::CubemapUtility::ECubeMapLookDirections lookDir, const vec3& position) -{ - return Texture::CubemapUtility::CalculateViewMatrix(lookDir, position); -} - -DirectX::XMMATRIX Light::CalculateDirectionalLightViewMatrix(const Light& mDirLight) -{ - if (mDirLight.mViewportX < 1.0f) - { - return XMMatrixIdentity(); - } - - const XMVECTOR up = vec3::Up; - const XMVECTOR lookAt = vec3::Zero; - const XMMATRIX mRot = mDirLight.mTransform.RotationMatrix(); - const vec3 direction = XMVector3Transform(vec3::Forward, mRot); - const XMVECTOR lightPos = direction * -mDirLight.mDistanceFromOrigin; // away from the origin along the direction vector - return XMMatrixLookAtLH(lightPos, lookAt, up); -} - -DirectX::XMMATRIX Light::CalculateProjectionMatrix(ELightType lightType, float near, float far, vec2 viewPortSize /*= vec2(0, 0)*/) -{ - switch (lightType) - { - case Light::POINT: - { - constexpr float ASPECT_RATIO = 1.0f; // cubemap aspect ratio - return XMMatrixPerspectiveFovLH(PI_DIV2, ASPECT_RATIO, near, far); - } - case Light::SPOT: - { - constexpr float ASPECT_RATIO = 1.0f; - //return XMMatrixPerspectiveFovLH(mSpotOuterConeAngleDegrees * DEG2RAD, ASPECT_RATIO, mNearPlaneDistance, mFarPlaneDistance); - return XMMatrixPerspectiveFovLH(PI_DIV2, ASPECT_RATIO, near, far); - } - case Light::DIRECTIONAL: - { - if (viewPortSize.x() < 1.0f) return XMMatrixIdentity(); - return XMMatrixOrthographicLH(viewPortSize.x(), viewPortSize.y(), near, far); - } - default: - Log::Warning("GetProjectionMatrix() called on invalid light type!"); - return XMMatrixIdentity(); - } -} - - - -DirectX::XMMATRIX Light::GetProjectionMatrix() const -{ -#if CACHE_LIGHT_MATRICES - return mProjectionMatrix; -#else - return CalculateProjectionMatrix(mType, mNearPlaneDistance, mFarPlaneDistance, vec2(mViewportX, mViewportY)); -#endif -} - -DirectX::XMMATRIX Light::GetViewMatrix(Texture::CubemapUtility::ECubeMapLookDirections lookDir /*= DEFAULT_POINT_LIGHT_LOOK_DIRECTION*/) const -{ -#if CACHE_LIGHT_MATRICES - switch (mType) - { - case Light::POINT: return mViewMatrix[lookDir]; - case Light::SPOT: return mViewMatrix[0]; - case Light::DIRECTIONAL: return mViewMatrix[0]; - default: - Log::Warning("GetViewMatrix() called on invalid light type!"); - return mViewMatrix[0]; - } -#else - switch (mType) - { - case Light::POINT: return CalculatePointLightViewMatrix(lookDir, mTransform._position); - case Light::SPOT: return CalculateSpotLightViewMatrix(mTransform); - case Light::DIRECTIONAL: return CalculateDirectionalLightViewMatrix(*this); - default: - Log::Warning("GetViewMatrix() called on invalid light type!"); - return XMMatrixIdentity(); - } -#endif -} - - - -void Light::GetGPUData(DirectionalLightGPU& l) const -{ - assert(mType == ELightType::DIRECTIONAL); - const XMMATRIX mRot = mTransform.RotationMatrix(); - const vec3 direction = XMVector3Transform(vec3::Forward, mRot); - - l.brightness = this->mBrightness; - l.color = this->mColor; - - l.lightDirection = direction; - l.depthBias = this->mDepthBias; - - l.shadowing = this->mbCastingShadows; - l.enabled = this->mbEnabled; -} -void Light::GetGPUData(SpotLightGPU& l) const -{ - assert(mType == ELightType::SPOT); - const vec3 spotDirection = XMVector3TransformCoord(vec3::Forward, mTransform.RotationMatrix()); - - l.position = mTransform._position; - l.halfAngle = mSpotOuterConeAngleDegrees * DEG2RAD; - - l.color = mColor.Value(); - l.brightness = mBrightness; - - l.spotDir = spotDirection; - l.depthBias = mDepthBias; - - l.innerConeAngle = mSpotInnerConeAngleDegrees * DEG2RAD; -} -void Light::GetGPUData(PointLightGPU& l) const -{ - assert(mType == ELightType::POINT); - - l.position = mTransform._position; - l.range = mRange; - - l.color = mColor.Value(); - l.brightness = mBrightness; - - l.attenuation = vec3(mAttenuationConstant, mAttenuationLinear, mAttenuationQuadratic); - l.depthBias = mDepthBias; -} - - - -Settings::ShadowMap Light::GetSettings() const -{ - Settings::ShadowMap settings; - settings.directionalShadowMapDimensions = static_cast(mViewportX); - return settings; -} - - - -void Light::SetMatrices() -{ -#if !CACHE_LIGHT_MATRICES - return; -#endif - - // VIEW - switch (mType) - { - case Light::POINT: - { - for(int i=0; i<6; ++i) - mViewMatrix[i] = CalculatePointLightViewMatrix(static_cast(i), mTransform._position); - break; - } - case Light::SPOT: mViewMatrix[0] = CalculateSpotLightViewMatrix(mTransform); break; - case Light::DIRECTIONAL: mViewMatrix[0] = CalculateDirectionalLightViewMatrix(*this); break; - default: - Log::Warning("SetViewMatrix() called on invalid light type!"); - mViewMatrix[0] = XMMatrixIdentity(); - break; - } - - // PROJ - mProjectionMatrix = CalculateProjectionMatrix(mType, mNearPlaneDistance, mFarPlaneDistance, vec2(mViewportX, mViewportY)); -} - -#endif \ No newline at end of file +// TBA \ No newline at end of file diff --git a/Source/Application/Light.h b/Source/Application/Light.h index 57f3e0e0..616b66f8 100644 --- a/Source/Application/Light.h +++ b/Source/Application/Light.h @@ -1,5 +1,5 @@ -// VQEngine | DirectX11 Renderer -// Copyright(C) 2018 - Volkan Ilbeyli +// VQE +// Copyright(C) 2020 - Volkan Ilbeyli // // This program is free software : you can redistribute it and / or modify // it under the terms of the GNU General Public License as published by @@ -65,186 +65,10 @@ struct Light // static DirectX::XMMATRIX CalculateDirectionalLightViewMatrix(const Light& mDirLight); static DirectX::XMMATRIX CalculateSpotLightViewMatrix(const Transform& mTransform); - //static DirectX::XMMATRIX CalculatePointLightViewMatrix(Texture::CubemapUtility::ECubeMapLookDirections lookDir, const vec3& position); - #if 0 - // returns a projection matrix based on @lightType, @near, @far and in the directional light case, @viewPortSize as well. - // - static DirectX::XMMATRIX CalculateProjectionMatrix(Light::ELightType lightType, float near, float far, vec2 viewPortSize = vec2(0, 0)); - - - //-------------------------------------------------------------------------------------------------------------- - // INTERFACE - //-------------------------------------------------------------------------------------------------------------- - Light() // DEFAULTS - : mColor(LinearColor::white) - , mbEnabled(true) - , mType(LIGHT_TYPE_COUNT) - , mBrightness(300.0f) - , mbCastingShadows(false) - , mDepthBias(0.0f) - , mNearPlaneDistance(0.0f) - , mFarPlaneDistance(0.0f) - , mRange(100.0f) - , mTransform() - , mMeshID(EGeometry::SPHERE) - {} - Light - ( - LinearColor color - , ELightType type - , float brightness - , bool bCastShadows - , float depthBias - , float nearPlaneDistance - , float range - , Transform transform - , EGeometry mesh - ) - : mColor(color) - , mType(type) - , mBrightness(brightness) - , mbCastingShadows(bCastShadows) - , mDepthBias(depthBias) - , mNearPlaneDistance(nearPlaneDistance) - , mRange(range) - , mTransform(transform) - , mMeshID(mesh) - {} - - - // returns the projection matrix for the light space transformation. - // - DirectX::XMMATRIX GetProjectionMatrix() const; - - // returns the view matrix for Directional/Spot lights. - // Use 'Texture::CubemapUtility::ECubeMapLookDirections' to get view matrices for cubemap faces for PointLight. - // - DirectX::XMMATRIX GetViewMatrix(Texture::CubemapUtility::ECubeMapLookDirections lookDir = DEFAULT_POINT_LIGHT_LOOK_DIRECTION) const; - - // returns the frustum plane data for the light. - // Use 'Texture::CubemapUtility::ECubeMapLookDirections' to get frustum planes for each direction for PointLight. - // - inline FrustumPlaneset GetViewFrustumPlanes(Texture::CubemapUtility::ECubeMapLookDirections lookDir = DEFAULT_POINT_LIGHT_LOOK_DIRECTION) const - { - return FrustumPlaneset::ExtractFromMatrix(GetLightSpaceMatrix(lookDir)); - } - - // Returns the View*Projection matrix that describes the light-space transformation of a world space position. - // Use 'Texture::CubemapUtility::ECubeMapLookDirections' to get the light space matrix for each direction for PointLight. - // - inline DirectX::XMMATRIX GetLightSpaceMatrix(Texture::CubemapUtility::ECubeMapLookDirections lookDir = DEFAULT_POINT_LIGHT_LOOK_DIRECTION) const - { - return GetViewMatrix(lookDir) * GetProjectionMatrix(); - } - - - void GetGPUData(PointLightGPU& refData) const; - void GetGPUData(SpotLightGPU& refData) const; - void GetGPUData(DirectionalLightGPU& refData) const; - - // TODO: remove this arbitrary function for directional lights - Settings::ShadowMap GetSettings() const; // ? - -private: - // cache the View and Projection matrices in the struct as computing a lot - // of them is quite expensive (many point lights) during frustum culling. - DirectX::XMMATRIX mProjectionMatrix; - std::array mViewMatrix; - -public: - void SetMatrices(); - - inline const Transform& GetTransform() const { return mTransform; } - const void SetTransform(const Transform& transform); - -public: - //-------------------------------------------------------------------------------------------------------------- - // DATA - //-------------------------------------------------------------------------------------------------------------- - ELightType mType; - LinearColor mColor; - float mBrightness; - - bool mbCastingShadows; - float mDepthBias; - float mNearPlaneDistance; - union - { - // well, they're not essentially the same but good enough for saving space for now - float mFarPlaneDistance; - float mRange; - }; - - Transform mTransform; - EGeometry mMeshID; - - bool mbEnabled; - - union // LIGHT-SPECIFIC DATA - { - // DIRECTIONAL LIGHT ---------------------------------------- - // - // | | | | | - // | | | | | - // v v v v v - // - struct - { - float mViewportX; - float mViewportY; - float mDistanceFromOrigin; - }; - - - - // POINT LIGHT ----------------------------------------------- - // - // \|/ - // --*-- - // /|\ - // - struct // Point - { - float mAttenuationConstant ; // Currently Unused: attenuation = 1/distance^2 in the shaders - float mAttenuationLinear ; // Currently Unused: attenuation = 1/distance^2 in the shaders - float mAttenuationQuadratic; // Currently Unused: attenuation = 1/distance^2 in the shaders - }; - - - - // SPOT LIGHT -------------------------------------------------- - // - // * - // / \ - // /_____\ - // ' ' ' ' ' - // - struct // Spot - { - float mSpotOuterConeAngleDegrees; - float mSpotInnerConeAngleDegrees; - float dummy1; - }; - - - - // TODO: v0.6.0 linear lights from GPU Zen - // Eric Heitz Slides: https://drive.google.com/file/d/0BzvWIdpUpRx_Z2pZWWFtam5xTFE/view - // LINEAR LIGHT ------------------------------------------------ - // - // - // - // - // - // - struct // Area - { - float dummy2; - float dummy3; - float dummy4; - }; - }; + static DirectX::XMMATRIX CalculatePointLightViewMatrix(Texture::CubemapUtility::ECubeMapLookDirections lookDir, const vec3& position); #endif + + // TODO }; constexpr size_t SZ_LIGHT_STRUCT = sizeof(Light); diff --git a/Source/Application/Scene.cpp b/Source/Application/Scene.cpp index c3f86e8c..54312308 100644 --- a/Source/Application/Scene.cpp +++ b/Source/Application/Scene.cpp @@ -1,5 +1,5 @@ -// VQEngine | DirectX11 Renderer -// Copyright(C) 2018 - Volkan Ilbeyli +// VQE +// Copyright(C) 2020 - Volkan Ilbeyli // // This program is free software : you can redistribute it and / or modify // it under the terms of the GNU General Public License as published by diff --git a/Source/Application/Scene.h b/Source/Application/Scene.h index 8ec879ed..94611632 100644 --- a/Source/Application/Scene.h +++ b/Source/Application/Scene.h @@ -1,5 +1,5 @@ -// VQEngine | DirectX11 Renderer -// Copyright(C) 2018 - Volkan Ilbeyli +// VQE +// Copyright(C) 2020 - Volkan Ilbeyli // // This program is free software : you can redistribute it and / or modify // it under the terms of the GNU General Public License as published by diff --git a/Source/Renderer/Texture.h b/Source/Renderer/Texture.h index deb6f00f..e06942e6 100644 --- a/Source/Renderer/Texture.h +++ b/Source/Renderer/Texture.h @@ -20,6 +20,8 @@ #include "Common.h" +#include + #include namespace D3D12MA { class Allocation; class Allocator; } @@ -46,6 +48,28 @@ struct TextureCreateDesc class Texture { public: + struct CubemapUtility + { + // cube face order: https://msdn.microsoft.com/en-us/library/windows/desktop/ff476906(v=vs.85).aspx + //------------------------------------------------------------------------------------------------------ + // 0: RIGHT 1: LEFT + // 2: UP 3: DOWN + // 4: FRONT 5: BACK + //------------------------------------------------------------------------------------------------------ + enum ECubeMapLookDirections + { + CUBEMAP_LOOK_RIGHT = 0, + CUBEMAP_LOOK_LEFT, + CUBEMAP_LOOK_UP, + CUBEMAP_LOOK_DOWN, + CUBEMAP_LOOK_FRONT, + CUBEMAP_LOOK_BACK, + + NUM_CUBEMAP_LOOK_DIRECTIONS + }; + static DirectX::XMMATRIX CalculateViewMatrix(ECubeMapLookDirections cubeFace, const vec3& position = vec3::Zero); + inline static DirectX::XMMATRIX CalculateViewMatrix(int face, const vec3& position = vec3::Zero) { return CalculateViewMatrix(static_cast(face), position); } + }; static std::vector GenerateTexture_Checkerboard(uint Dimension); Texture() = default; From 882b904c6228ec12b76334b1bef7dfd2acd25d3d Mon Sep 17 00:00:00 2001 From: Volkan Date: Tue, 18 Aug 2020 12:24:57 -0700 Subject: [PATCH 14/67] Further encapsulate camera parameters, remove redundant code --- Data/Levels/StressTest.xml | 26 ------------------- Source/Application/Camera.cpp | 22 ++++------------ Source/Application/Camera.h | 24 ++--------------- Source/Application/FileParser.cpp | 8 +++--- Source/Application/Scene.cpp | 4 +-- Source/Application/VQEngine_EventHandlers.cpp | 4 +-- Source/Renderer/Texture.h | 3 +++ Source/Scenes/DefaultScene.cpp | 4 +-- 8 files changed, 20 insertions(+), 75 deletions(-) diff --git a/Data/Levels/StressTest.xml b/Data/Levels/StressTest.xml index 413d4f6c..0697c5c0 100644 --- a/Data/Levels/StressTest.xml +++ b/Data/Levels/StressTest.xml @@ -46,32 +46,6 @@ - - - -10 0 0 - 0 0 0 1 - 1 1 1 - - - Triangle - - - - - - - - -5 0 0 - 0 0 0 1 - 1 1 1 - - - Cube - - - - - diff --git a/Source/Application/Camera.cpp b/Source/Application/Camera.cpp index 52f37e98..d79d61f1 100644 --- a/Source/Application/Camera.cpp +++ b/Source/Application/Camera.cpp @@ -64,20 +64,8 @@ Camera Camera::Clone() void Camera::InitializeCamera(const FCameraParameters& data) { - const auto& NEAR_PLANE = data.NearPlane; - const auto& FAR_PLANE = data.FarPlane; - const float AspectRatio = data.Width / data.Height; - const float VerticalFoV = data.FovV_Degrees * DEG2RAD; - const float& ViewportX = data.Width; - const float& ViewportY = data.Height; - - this->mProjParams.NearZ = NEAR_PLANE; - this->mProjParams.FarZ = FAR_PLANE; - this->mProjParams.ViewporHeight = ViewportY; - this->mProjParams.ViewporWidth = ViewportX; - this->mProjParams.FieldOfView = data.FovV_Degrees * DEG2RAD; - this->mProjParams.bPerspectiveProjection = data.bPerspectiveProjection; - + this->mProjParams = data.ProjectionParams; + this->mProjParams.FieldOfView *= DEG2RAD; // convert FoV to radians mYaw = mPitch = 0; SetProjectionMatrix(this->mProjParams); SetPosition(data.x, data.y, data.z); @@ -99,12 +87,12 @@ void Camera::InitializeController(bool bFirstPersonController) void Camera::SetProjectionMatrix(const FProjectionMatrixParameters& params) { - assert(params.ViewporHeight > 0.0f); - const float AspectRatio = params.ViewporWidth / params.ViewporHeight; + assert(params.ViewportHeight > 0.0f); + const float AspectRatio = params.ViewportWidth / params.ViewportHeight; mMatProj = params.bPerspectiveProjection ? MakePerspectiveProjectionMatrix(params.FieldOfView, AspectRatio, params.NearZ, params.FarZ) - : MakeOthographicProjectionMatrix(params.ViewporWidth, params.ViewporHeight, params.NearZ, params.FarZ); + : MakeOthographicProjectionMatrix(params.ViewportWidth, params.ViewportHeight, params.NearZ, params.FarZ); } void Camera::UpdateViewMatrix() diff --git a/Source/Application/Camera.h b/Source/Application/Camera.h index 9432c2f1..3b404080 100644 --- a/Source/Application/Camera.h +++ b/Source/Application/Camera.h @@ -35,14 +35,13 @@ class Input; // --------------------------------------------------------- struct FProjectionMatrixParameters { - float ViewporWidth; // needed for orthographic projection - float ViewporHeight; // needed for orthographic projection + float ViewportWidth; // needed for orthographic projection + float ViewportHeight; // needed for orthographic projection float NearZ; float FarZ; float FieldOfView; bool bPerspectiveProjection; }; -#if 0 // TODO: remove duplication struct FCameraParameters { float x, y, z; // position @@ -50,31 +49,12 @@ struct FCameraParameters FProjectionMatrixParameters ProjectionParams; - bool FirstPerson; // First Person / orbit - float TranslationSpeed; - float AngularSpeed; - float Drag; -}; -#else -struct FCameraParameters -{ - float x, y, z; // position - float Yaw, Pitch; // in degrees - - bool bPerspectiveProjection; // perspective / orthographic - float Width; - float Height; - float NearPlane; - float FarPlane; - float FovV_Degrees; - bool bInitializeCameraController; bool bFirstPerson; // First Person / orbit float TranslationSpeed; float AngularSpeed; float Drag; }; -#endif struct FCameraInput { diff --git a/Source/Application/FileParser.cpp b/Source/Application/FileParser.cpp index 3a58dd57..4c5c13d3 100644 --- a/Source/Application/FileParser.cpp +++ b/Source/Application/FileParser.cpp @@ -556,11 +556,11 @@ std::vector< FSceneRepresentation> VQEngine::ParseSceneFiles() { std::string projVal; fnParseXMLStringVal(pProj, projVal); - cam.bPerspectiveProjection = projVal == "Perspective"; + cam.ProjectionParams.bPerspectiveProjection = projVal == "Perspective"; } - if(pFoV ) fnParseXMLFloatVal(pFoV, cam.FovV_Degrees); - if(pNear) fnParseXMLFloatVal(pNear, cam.NearPlane); - if(pFar ) fnParseXMLFloatVal(pFar, cam.FarPlane); + if(pFoV ) fnParseXMLFloatVal(pFoV , cam.ProjectionParams.FieldOfView); + if(pNear) fnParseXMLFloatVal(pNear, cam.ProjectionParams.NearZ); + if(pFar ) fnParseXMLFloatVal(pFar , cam.ProjectionParams.FarZ); // attributes---------------------------------------- diff --git a/Source/Application/Scene.cpp b/Source/Application/Scene.cpp index 54312308..8e3784e6 100644 --- a/Source/Application/Scene.cpp +++ b/Source/Application/Scene.cpp @@ -146,8 +146,8 @@ void Scene::StartLoading(FSceneRepresentation& scene) // CAMERAS for (FCameraParameters& param : scene.Cameras) { - param.Width = static_cast( mpWindow->GetWidth() ); - param.Height = static_cast( mpWindow->GetHeight() ); + param.ProjectionParams.ViewportWidth = static_cast( mpWindow->GetWidth() ); + param.ProjectionParams.ViewportHeight = static_cast( mpWindow->GetHeight() ); Camera c; c.InitializeCamera(param); diff --git a/Source/Application/VQEngine_EventHandlers.cpp b/Source/Application/VQEngine_EventHandlers.cpp index a9703bb0..eeb1ef28 100644 --- a/Source/Application/VQEngine_EventHandlers.cpp +++ b/Source/Application/VQEngine_EventHandlers.cpp @@ -190,8 +190,8 @@ void VQEngine::UpdateThread_HandleWindowResizeEvent(const std::shared_ptrGetActiveCamera(); FProjectionMatrixParameters UpdatedProjectionMatrixParams = cam.GetProjectionParameters(); - UpdatedProjectionMatrixParams.ViewporWidth = static_cast(p->width ); - UpdatedProjectionMatrixParams.ViewporHeight = static_cast(p->height); + UpdatedProjectionMatrixParams.ViewportWidth = static_cast(p->width ); + UpdatedProjectionMatrixParams.ViewportHeight = static_cast(p->height); cam.SetProjectionMatrix(UpdatedProjectionMatrixParams); } diff --git a/Source/Renderer/Texture.h b/Source/Renderer/Texture.h index e06942e6..f48791a7 100644 --- a/Source/Renderer/Texture.h +++ b/Source/Renderer/Texture.h @@ -67,8 +67,11 @@ class Texture NUM_CUBEMAP_LOOK_DIRECTIONS }; +#if 0 + // TODO implement with Lights static DirectX::XMMATRIX CalculateViewMatrix(ECubeMapLookDirections cubeFace, const vec3& position = vec3::Zero); inline static DirectX::XMMATRIX CalculateViewMatrix(int face, const vec3& position = vec3::Zero) { return CalculateViewMatrix(static_cast(face), position); } +#endif }; static std::vector GenerateTexture_Checkerboard(uint Dimension); diff --git a/Source/Scenes/DefaultScene.cpp b/Source/Scenes/DefaultScene.cpp index 203b3bfb..38027b57 100644 --- a/Source/Scenes/DefaultScene.cpp +++ b/Source/Scenes/DefaultScene.cpp @@ -20,8 +20,8 @@ void DefaultScene::UpdateScene(float dt, FSceneView& SceneView) if (mInput.IsKeyTriggered('R')) { FCameraParameters params = mSceneRepresentation.Cameras[mIndex_SelectedCamera]; - params.Width = static_cast(mpWindow->GetWidth() ); - params.Height = static_cast(mpWindow->GetHeight()); + params.ProjectionParams.ViewportWidth = static_cast(mpWindow->GetWidth() ); + params.ProjectionParams.ViewportHeight = static_cast(mpWindow->GetHeight()); cam.InitializeCamera(params); } From 3a988eea322b16a2d37fa57d6973dadd64013e6c Mon Sep 17 00:00:00 2001 From: Volkan Date: Tue, 18 Aug 2020 12:34:25 -0700 Subject: [PATCH 15/67] remove dead code (gameobject) --- Source/Application/GameObject.cpp | 126 +----------------------------- Source/Application/GameObject.h | 85 -------------------- 2 files changed, 1 insertion(+), 210 deletions(-) diff --git a/Source/Application/GameObject.cpp b/Source/Application/GameObject.cpp index b5e3d538..add3aa36 100644 --- a/Source/Application/GameObject.cpp +++ b/Source/Application/GameObject.cpp @@ -16,128 +16,4 @@ // // Contact: volkanilbeyli@gmail.com -#include "GameObject.h" -#if 0 -#include "Renderer/Renderer.h" -#include "RenderPasses/RenderPasses.h" -#include "SceneResourceView.h" -#include "SceneView.h" - -#include "Engine.h" - -GameObject::GameObject(Scene* pScene) : mpScene(pScene) {}; - -void GameObject::AddMesh(MeshID meshID) -{ - //if (meshID >= 0 && meshID < EGeometry::MESH_TYPE_COUNT) - mModel.mbLoaded = true; - - mModel.mData.mMeshIDs.push_back(meshID); -} - - -void GameObject::AddMesh(MeshID meshID, const MeshRenderSettings& renderSettings) -{ - mModel.mbLoaded = true; - mModel.mData.mMeshRenderSettingsLookup[meshID] = renderSettings; - mModel.mData.mMeshIDs.push_back(meshID); -} - -void GameObject::AddMaterial(Material * pMat) -{ - if (mModel.mbLoaded) - mModel.AddMaterialToMesh(mModel.mData.mMeshIDs.back(), pMat->ID, pMat->IsTransparent()); - else - mModel.mMaterialAssignmentQueue.push(pMat->ID); -} - - -void GameObject::SetMeshMaterials(const Material* pMat) -{ - if (mModel.mbLoaded) - mModel.OverrideMaterials(pMat->ID); - else - assert(false); // TODO: impl mesh override queue or resolve the ambiguity between material assignment queue and this case -} - -void GameObject::RenderTransparent( - Renderer * pRenderer - , const FSceneView& sceneView - , bool UploadMaterialDataToGPU - , const MaterialPool& materialBuffer) const -{ - const EShaders shader = static_cast(pRenderer->GetActiveShader()); - const XMMATRIX world = mTransform.WorldTransformationMatrix(); - const XMMATRIX wvp = world * sceneView.viewProj; - - // SET MATRICES - switch (shader) - { - case EShaders::TBN: - pRenderer->SetConstant4x4f("world", world); - pRenderer->SetConstant4x4f("viewProj", sceneView.viewProj); - pRenderer->SetConstant4x4f("normalMatrix", mTransform.NormalMatrix(world)); - break; - case EShaders::NORMAL: - pRenderer->SetConstant4x4f("normalMatrix", mTransform.NormalMatrix(world)); - case EShaders::UNLIT: - case EShaders::TEXTURE_COORDINATES: - pRenderer->SetConstant4x4f("worldViewProj", wvp); - break; - default: // lighting shaders - pRenderer->SetConstant4x4f("world", world); - pRenderer->SetConstant4x4f("normalMatrix", mTransform.NormalMatrix(world)); - pRenderer->SetConstant4x4f("worldViewProj", wvp); - break; - } - - // SET GEOMETRY & MATERIAL, THEN DRAW - for(MeshID id : mModel.mData.mTransparentMeshIDs) - { - const auto IABuffer = SceneResourceView::GetVertexAndIndexBufferIDsOfMesh(mpScene, id, this); - - // SET MATERIAL CONSTANTS - if (UploadMaterialDataToGPU) - { - const bool bMeshHasMaterial = mModel.mData.mMaterialLookupPerMesh.find(id) != mModel.mData.mMaterialLookupPerMesh.end(); - - if (bMeshHasMaterial) - { - const MaterialID materialID = mModel.mData.mMaterialLookupPerMesh.at(id); - const Material* pMat = materialBuffer.GetMaterial_const(materialID); - pMat->SetMaterialConstants(pRenderer, shader, sceneView.bIsDeferredRendering && shader != FORWARD_BRDF); - } - else - { - materialBuffer.GetDefaultMaterial(GGX_BRDF)->SetMaterialConstants(pRenderer, shader, sceneView.bIsDeferredRendering); - } - } - - pRenderer->SetVertexBuffer(IABuffer.first); - pRenderer->SetIndexBuffer(IABuffer.second); - pRenderer->Apply(); - pRenderer->DrawIndexed(); - }; -} - -void GameObject::Clear() -{ - mTransform = Transform(); - mModel = Model(); - mBoundingBox = BoundingBox(); - mRenderSettings = GameObjectRenderSettings(); -} - - - - -DirectX::XMMATRIX BoundingBox::GetWorldTransformationMatrix() const -{ - Transform tf; - const vec3 diag = this->hi - this->low; - const vec3 pos = (this->hi + this->low) * 0.5f; - tf.SetScale(diag * 0.5f); - tf.SetPosition(pos); - return tf.WorldTransformationMatrix(); -} -#endif \ No newline at end of file +#include "GameObject.h" \ No newline at end of file diff --git a/Source/Application/GameObject.h b/Source/Application/GameObject.h index d6555b18..8922af84 100644 --- a/Source/Application/GameObject.h +++ b/Source/Application/GameObject.h @@ -33,88 +33,3 @@ class GameObject BoundingBox mBoundingBox; std::vector mMeshBoundingBoxes; }; - -#if 0 -#include "Engine/ObjectCullingSystem.h" - -#include - -struct FSceneView; -class Renderer; -class Scene; -class Parser; - -struct GameObjectRenderSettings -{ - bool bRender = true; - bool bRenderTBN = false; - bool bCastShadow = true; -}; - -class GameObject -{ -// GameObjects only contain Transform data, and the rest of -// the members are references to data either in Scene or Renderer. -// -public: - ~GameObject() { mpScene = nullptr; } - void RenderTransparent(Renderer* pRenderer, const FSceneView& sceneView, bool UploadMaterialDataToGPU, const MaterialPool& materialBuffer) const; - void Clear(); - - inline void SetTransform(const Transform& transform) { mTransform = transform; } - - inline const Transform& GetTransform() const { return mTransform; } - inline const vec3& GetPosition() const { return mTransform._position; } - inline const ModelData& GetModelData() const { return mModel.mData; } - inline const std::string& GetModelName() const { return mModel.mModelName; } - - inline Transform& GetTransform() { return mTransform; } - - void AddMesh(MeshID meshID); - void AddMesh(MeshID meshID, const MeshRenderSettings& renderSettings); - - // Adds materialID to the newest meshID (meshes.back()) - // - void AddMaterial(Material* pMat); - void SetMeshMaterials(const Material* pMat); - - inline const Model& GetModel() const { return mModel; } - inline Model& GetModel() { return mModel; } - inline void SetModel(const Model& model) { mModel = model; } // i don't like this setter... - inline const BoundingBox& GetAABB() const { return mBoundingBox; } - inline const std::vector& GetMeshBBs() const { return mMeshBoundingBoxes; } - - -//--------------------------------------------------------------------------------------------------- - -public: - GameObjectRenderSettings mRenderSettings; - // After a game object is created, we use the pointer field - // as the Scene*. Otherwise, we keep a pointer for the object pool - // to the next available object - a free list of GameObject pointers - union - { - GameObject* pNextFreeObject; - Scene* mpScene; - }; - -private: - // friend std::shared_ptr Scene::CreateNewGameObject(); // #TODO: clean up: use either friend functions or ... - // friend std::shared_ptr FSceneRepresentation::CreateNewGameObject(); - // friend void Parser::ParseScene(Renderer*, const std::vector&, FSceneRepresentation&); - friend class Scene; - friend struct FSceneRepresentation; - friend class Parser; - friend class GameObjectPool; - GameObject(Scene* pScene); - - private: - Transform mTransform; - Model mModel; - BoundingBox mBoundingBox; - std::vector mMeshBoundingBoxes; - -}; - - -#endif \ No newline at end of file From 91dd38a93d33a9de3546e3c47259ccdef22fb0c3 Mon Sep 17 00:00:00 2001 From: Volkan Date: Tue, 18 Aug 2020 20:26:19 -0700 Subject: [PATCH 16/67] Asset loader with queues, loading unique models from the queue --- Source/Application/AssetLoader.cpp | 59 +++++- Source/Application/AssetLoader.h | 39 +++- Source/Application/FileParser.cpp | 239 ++++++++++++------------- Source/Application/Model.h | 57 +----- Source/Application/Scene.cpp | 5 +- Source/Application/Scene.h | 2 + Source/Application/VQEngine.h | 8 +- Source/Application/VQEngine_Main.cpp | 24 +-- Source/Application/VQEngine_Update.cpp | 12 +- 9 files changed, 240 insertions(+), 205 deletions(-) diff --git a/Source/Application/AssetLoader.cpp b/Source/Application/AssetLoader.cpp index 372a1c8a..a9c0b7eb 100644 --- a/Source/Application/AssetLoader.cpp +++ b/Source/Application/AssetLoader.cpp @@ -18,11 +18,68 @@ #include "AssetLoader.h" +#include "Libs/VQUtils/Source/Multithreading.h" +#include "Libs/VQUtils/Source/utils.h" + Model AssetLoader::ImportModel_obj(const std::string& objFilePath, std::string ModelName) { Model::Data modelData; + Log::Info("ImportModel_obj: %s - %s", ModelName.c_str(), objFilePath.c_str()); // TODO: assimp model import return Model(objFilePath, ModelName, std::move(modelData)); -} \ No newline at end of file +} + +Model AssetLoader::ImportModel_gltf(const std::string& objFilePath, std::string ModelName) +{ + assert(false); // TODO + return Model(); +} + +void AssetLoader::QueueAssetLoad(const std::string& ModelPath) +{ + const std::string FileExtension = DirectoryUtil::GetFileExtension(ModelPath); + + static std::unordered_map < std::string, FModelLoadParams::pfnImportModel_t> MODEL_IMPORT_FUNCTIONS = + { + { "obj" , AssetLoader::ImportModel_obj } + , { "gltf", AssetLoader::ImportModel_gltf } // TODO + }; + + std::unique_lock lk(mMtxQueue_ModelLoad); + mModelLoadQueue.push({ModelPath, MODEL_IMPORT_FUNCTIONS.at(FileExtension)}); +} + +void AssetLoader::StartLoadingAssets() +{ + if (mModelLoadQueue.empty()) + { + Log::Warning("AssetLoader::StartLoadingAssets(): no models to load"); + return; + } + + // process model load queue + std::unique_lock lk(mMtxQueue_ModelLoad); + do + { + FModelLoadParams ModelLoadParams = mModelLoadQueue.front(); + const std::string& ModelPath = ModelLoadParams.ModelPath; + mModelLoadQueue.pop(); + + // eliminate duplicates + if (mUniqueModelPaths.find(ModelPath) == mUniqueModelPaths.end()) + { + mUniqueModelPaths.insert(ModelPath); + + // start loading + mWorkers.AddTask([=]() + { + ModelLoadParams.pfnImportModel(ModelLoadParams.ModelPath, ""); + }); + } + } while (!mModelLoadQueue.empty()); + + mUniqueModelPaths.clear(); +} + diff --git a/Source/Application/AssetLoader.h b/Source/Application/AssetLoader.h index 4bcd09b6..52d5c963 100644 --- a/Source/Application/AssetLoader.h +++ b/Source/Application/AssetLoader.h @@ -19,11 +19,46 @@ #include "Model.h" +#include + +class ThreadPool; + class AssetLoader { - +public: + static Model ImportModel_obj (const std::string& objFilePath, std::string ModelName = "NONE"); // TODO: rename to LoadModel_obj() ? + static Model ImportModel_gltf(const std::string& objFilePath, std::string ModelName = "NONE"); // TODO: rename to LoadModel_gltf() ? public: - static Model ImportModel_obj(const std::string& objFilePath, std::string ModelName = "NONE"); // TODO: rename to LoadModel_obj() ? + AssetLoader(ThreadPool& WorkerThreads) + : mWorkers(WorkerThreads) + {} + + void QueueAssetLoad(const std::string& ModelPath); + void StartLoadingAssets(); + +private: + struct FModelLoadParams + { + using pfnImportModel_t = Model(*)(const std::string& objFilePath, std::string ModelName); + std::string ModelPath; + pfnImportModel_t pfnImportModel; + }; + struct FTextureLoadParams + { + std::string TexturePath; + }; + +private: + ThreadPool& mWorkers; + + std::queue mModelLoadQueue; + std::set mUniqueModelPaths; + + std::queue< FTextureLoadParams> mTextureLoadQueue; + std::set mUniqueTexturePaths; + + std::mutex mMtxQueue_ModelLoad; + std::mutex mMtxQueue_TextureLoad; }; \ No newline at end of file diff --git a/Source/Application/FileParser.cpp b/Source/Application/FileParser.cpp index 4c5c13d3..f63fd617 100644 --- a/Source/Application/FileParser.cpp +++ b/Source/Application/FileParser.cpp @@ -378,7 +378,7 @@ std::vector VQEngine::ParseHDRProfilesFile() return HDRProfiles; } -std::vector< FSceneRepresentation> VQEngine::ParseSceneFiles() +FSceneRepresentation VQEngine::ParseSceneFile(const std::string& SceneFile) { using namespace DirectX; using namespace tinyxml2; @@ -391,8 +391,8 @@ std::vector< FSceneRepresentation> VQEngine::ParseSceneFiles() //----------------------------------------------------------------- constexpr char* SCENE_FILES_DIRECTORY = "Data/Levels/"; //----------------------------------------------------------------- - std::vector SceneRepresentations; - const std::vector SceneFiles = DirectoryUtil::ListFilesInDirectory(SCENE_FILES_DIRECTORY, ".xml"); + // std::vector SceneRepresentations; + //const std::vector SceneFiles = DirectoryUtil::ListFilesInDirectory(SCENE_FILES_DIRECTORY, ".xml"); //----------------------------------------------------------------- // parse vectors -------------------------------------------------- @@ -479,154 +479,147 @@ std::vector< FSceneRepresentation> VQEngine::ParseSceneFiles() //----------------------------------------------------------------- - // Start reading scene XML files - for (const std::string SceneFile : SceneFiles) - { - FSceneRepresentation SceneRep = {}; + // Start reading scene XML file + FSceneRepresentation SceneRep = {}; + + // parse XML + tinyxml2::XMLDocument doc; + doc.LoadFile(SceneFile.c_str()); - // parse XML - tinyxml2::XMLDocument doc; - doc.LoadFile(SceneFile.c_str()); + // scene name + SceneRep.SceneName = DirectoryUtil::GetFileNameWithoutExtension(SceneFile); - // scene name - SceneRep.SceneName = DirectoryUtil::GetFileNameWithoutExtension(SceneFile); + XMLElement* pScene = doc.FirstChildElement(XML_TAG__SCENE); + if (pScene) + { + XMLElement* pCurrentSceneElement = pScene->FirstChildElement(); + if (!pCurrentSceneElement) + { + return SceneRep; + } - XMLElement* pScene = doc.FirstChildElement(XML_TAG__SCENE); - if (pScene) + do { - XMLElement* pCurrentSceneElement = pScene->FirstChildElement(); - if (!pCurrentSceneElement) + // Environment Map + const std::string CurrEle = pCurrentSceneElement->Value(); + if (XML_TAG__ENVIRONMENT_MAP == CurrEle) { - SceneRepresentations.push_back(SceneRep); - continue; + XMLElement* pPreset = pCurrentSceneElement->FirstChildElement(XML_TAG__ENVIRONMENT_MAP_PRESET); + if (pPreset) + { + fnParseXMLStringVal(pPreset, SceneRep.EnvironmentMapPreset); + } } - do + // Cameras + else if (XML_TAG__CAMERA == CurrEle) { - // Environment Map - const std::string CurrEle = pCurrentSceneElement->Value(); - if (XML_TAG__ENVIRONMENT_MAP == CurrEle) + FCameraParameters cam = {}; + XMLElement*& pCam = pCurrentSceneElement; + + // transform + XMLElement* pPos = pCam->FirstChildElement("Position"); + XMLElement* pPitch = pCam->FirstChildElement("Pitch"); + XMLElement* pYaw = pCam->FirstChildElement("Yaw"); + + // projection + XMLElement* pProj = pCam->FirstChildElement("Projection"); + XMLElement* pFoV = pCam->FirstChildElement("FoV"); + XMLElement* pNear = pCam->FirstChildElement("Near"); + XMLElement* pFar = pCam->FirstChildElement("Far"); + + // attributes + XMLElement* pFP = pCam->FirstChildElement("FirstPerson"); + XMLElement* pTSpeed = pFP ? pFP->FirstChildElement("TranslationSpeed") : nullptr; + XMLElement* pASpeed = pFP ? pFP->FirstChildElement("AngularSpeed") : nullptr; + XMLElement* pDrag = pFP ? pFP->FirstChildElement("Drag") : nullptr; + XMLElement* pOrbit = pCam->FirstChildElement("Orbit"); + + // transform ---------------------------------------- + if (pPos) { - XMLElement* pPreset = pCurrentSceneElement->FirstChildElement(XML_TAG__ENVIRONMENT_MAP_PRESET); - if (pPreset) - { - fnParseXMLStringVal(pPreset, SceneRep.EnvironmentMapPreset); - } + XMFLOAT3 xyz; + fnParseXMLFloat3Val(pPos, xyz); + cam.x = xyz.x; + cam.y = xyz.y; + cam.z = xyz.z; } + if (pPitch) fnParseXMLFloatVal(pPitch, cam.Pitch); + if (pYaw) fnParseXMLFloatVal(pYaw, cam.Yaw); - // Cameras - else if (XML_TAG__CAMERA == CurrEle) + // projection---------------------------------------- + if(pProj) { - FCameraParameters cam = {}; - XMLElement*& pCam = pCurrentSceneElement; - - // transform - XMLElement* pPos = pCam->FirstChildElement("Position"); - XMLElement* pPitch = pCam->FirstChildElement("Pitch"); - XMLElement* pYaw = pCam->FirstChildElement("Yaw"); - - // projection - XMLElement* pProj = pCam->FirstChildElement("Projection"); - XMLElement* pFoV = pCam->FirstChildElement("FoV"); - XMLElement* pNear = pCam->FirstChildElement("Near"); - XMLElement* pFar = pCam->FirstChildElement("Far"); - - // attributes - XMLElement* pFP = pCam->FirstChildElement("FirstPerson"); - XMLElement* pTSpeed = pFP ? pFP->FirstChildElement("TranslationSpeed") : nullptr; - XMLElement* pASpeed = pFP ? pFP->FirstChildElement("AngularSpeed") : nullptr; - XMLElement* pDrag = pFP ? pFP->FirstChildElement("Drag") : nullptr; - XMLElement* pOrbit = pCam->FirstChildElement("Orbit"); - - // transform ---------------------------------------- - if (pPos) - { - XMFLOAT3 xyz; - fnParseXMLFloat3Val(pPos, xyz); - cam.x = xyz.x; - cam.y = xyz.y; - cam.z = xyz.z; - } - if (pPitch) fnParseXMLFloatVal(pPitch, cam.Pitch); - if (pYaw) fnParseXMLFloatVal(pYaw, cam.Yaw); - - // projection---------------------------------------- - if(pProj) - { - std::string projVal; - fnParseXMLStringVal(pProj, projVal); - cam.ProjectionParams.bPerspectiveProjection = projVal == "Perspective"; - } - if(pFoV ) fnParseXMLFloatVal(pFoV , cam.ProjectionParams.FieldOfView); - if(pNear) fnParseXMLFloatVal(pNear, cam.ProjectionParams.NearZ); - if(pFar ) fnParseXMLFloatVal(pFar , cam.ProjectionParams.FarZ); + std::string projVal; + fnParseXMLStringVal(pProj, projVal); + cam.ProjectionParams.bPerspectiveProjection = projVal == "Perspective"; + } + if(pFoV ) fnParseXMLFloatVal(pFoV , cam.ProjectionParams.FieldOfView); + if(pNear) fnParseXMLFloatVal(pNear, cam.ProjectionParams.NearZ); + if(pFar ) fnParseXMLFloatVal(pFar , cam.ProjectionParams.FarZ); - // attributes---------------------------------------- - if (pFP) - { - cam.bInitializeCameraController = true; - cam.bFirstPerson = true; - if(pTSpeed) fnParseXMLFloatVal(pTSpeed, cam.TranslationSpeed); - if(pASpeed) fnParseXMLFloatVal(pASpeed, cam.AngularSpeed); - if(pDrag ) fnParseXMLFloatVal(pDrag , cam.Drag); - } - if (pOrbit) - { - cam.bInitializeCameraController = true; - cam.bFirstPerson = false; - - } + // attributes---------------------------------------- + if (pFP) + { + cam.bInitializeCameraController = true; + cam.bFirstPerson = true; + if(pTSpeed) fnParseXMLFloatVal(pTSpeed, cam.TranslationSpeed); + if(pASpeed) fnParseXMLFloatVal(pASpeed, cam.AngularSpeed); + if(pDrag ) fnParseXMLFloatVal(pDrag , cam.Drag); + } + if (pOrbit) + { + cam.bInitializeCameraController = true; + cam.bFirstPerson = false; - SceneRep.Cameras.push_back(cam); } + SceneRep.Cameras.push_back(cam); + } - // Game Objects - else if (XML_TAG__GAMEOBJECT == CurrEle) - { - GameObjectRepresentation obj; - XMLElement*& pObj = pCurrentSceneElement; - XMLElement* pTransform = pObj->FirstChildElement("Transform"); - XMLElement* pModel = pObj->FirstChildElement("Model"); + // Game Objects + else if (XML_TAG__GAMEOBJECT == CurrEle) + { + GameObjectRepresentation obj; + + XMLElement*& pObj = pCurrentSceneElement; + XMLElement* pTransform = pObj->FirstChildElement("Transform"); + XMLElement* pModel = pObj->FirstChildElement("Model"); - // Transform - if (pTransform) - { - obj.tf = fnParseTransform(pTransform); - } + // Transform + if (pTransform) + { + obj.tf = fnParseTransform(pTransform); + } - // Model (WIP) - if (pModel) - { - XMLElement* pMesh = pModel->FirstChildElement("Mesh"); - XMLElement* pMaterial = pModel->FirstChildElement("Material"); - XMLElement* pModelPath = pModel->FirstChildElement("Path"); - XMLElement* pModelName = pModel->FirstChildElement("Name"); + // Model (WIP) + if (pModel) + { + XMLElement* pMesh = pModel->FirstChildElement("Mesh"); + XMLElement* pMaterial = pModel->FirstChildElement("Material"); + XMLElement* pModelPath = pModel->FirstChildElement("Path"); + XMLElement* pModelName = pModel->FirstChildElement("Name"); - if (pMesh) fnParseXMLStringVal(pMesh, obj.BuiltinMeshName); - if (pMaterial) - { - // TODO - } - if (pModelPath) fnParseXMLStringVal(pModelPath, obj.ModelFilePath); - if (pModelName) fnParseXMLStringVal(pModelName, obj.ModelName); + if (pMesh) fnParseXMLStringVal(pMesh, obj.BuiltinMeshName); + if (pMaterial) + { + // TODO } - - - SceneRep.Objects.push_back(obj); + if (pModelPath) fnParseXMLStringVal(pModelPath, obj.ModelFilePath); + if (pModelName) fnParseXMLStringVal(pModelName, obj.ModelName); } - pCurrentSceneElement = pCurrentSceneElement->NextSiblingElement(); - } while (pCurrentSceneElement); - } - SceneRepresentations.push_back(SceneRep); - } + SceneRep.Objects.push_back(obj); + } + pCurrentSceneElement = pCurrentSceneElement->NextSiblingElement(); + } while (pCurrentSceneElement); + } - return SceneRepresentations; + return SceneRep; } diff --git a/Source/Application/Model.h b/Source/Application/Model.h index 73b80caf..4f5265aa 100644 --- a/Source/Application/Model.h +++ b/Source/Application/Model.h @@ -60,21 +60,20 @@ struct Model public: struct Data { - std::vector mMeshIDs; - MeshMaterialLookup_t mOpaqueMaterials; - MeshMaterialLookup_t mTransparentMaterials; + std::vector mMeshIDs; + MeshMaterialLookup_t mOpaqueMaterials; + MeshMaterialLookup_t mTransparentMaterials; inline bool HasMaterial() const { return !mOpaqueMaterials.empty() || !mTransparentMaterials.empty(); } bool AddMaterial(MeshID meshID, MaterialID matID, bool bTransparent = false); }; - void AddMaterialToMesh(MeshID meshID, MaterialID materialID, bool bTransparent); - void OverrideMaterials(MaterialID materialID); + //--------------------------------------- Model() = default; Model(const std::string& directoryFullPath, const std::string& modelName, Data&& modelDataIn) : mData(modelDataIn) , mModelName(modelName) - , mModelDirectory(directoryFullPath) + , mModelPath(directoryFullPath) , mbLoaded(true) {} @@ -82,53 +81,9 @@ struct Model Data mData; std::string mModelName; - std::string mModelDirectory; + std::string mModelPath; bool mbLoaded = false; - -private: - friend class GameObject; - friend class Scene; - - // queue of materials to be assigned in case the model has not been loaded yet. - std::queue mMaterialAssignmentQueue; }; - -// -// MODEL LOADER -// -class ModelLoader -{ -public: - inline void Initialize(VQRenderer* pRenderer) { mpRenderer = pRenderer; } - - // Loads the Model in a serial fashion - blocks thread - // - Model LoadModel(const std::string& modelPath, Scene* pScene); - - // Ends async loading. - // - Model LoadModel_Async(const std::string& modelPath, Scene* pScene); - - - void UnloadSceneModels(Scene* pScene); - - -private: - static const char* sRootFolderModels; - - - using ModelLookUpTable = std::unordered_map; - using PerSceneModelNameLookupTable = std::unordered_map>; - - -private: - VQRenderer* mpRenderer; - ModelLookUpTable mLoadedModels; - PerSceneModelNameLookupTable mSceneModels; - - std::mutex mLoadedModelMutex; - std::mutex mSceneModelsMutex; -}; \ No newline at end of file diff --git a/Source/Application/Scene.cpp b/Source/Application/Scene.cpp index 8e3784e6..e63d7e71 100644 --- a/Source/Application/Scene.cpp +++ b/Source/Application/Scene.cpp @@ -34,6 +34,7 @@ Scene::Scene(VQEngine& engine, int NumFrameBuffers, const Input& input, const st , mGameObjectPool(NUM_GAMEOBJECT_POOL_SIZE, GAMEOBJECT_BYTE_ALIGNMENT) , mTransformPool(NUM_GAMEOBJECT_POOL_SIZE, GAMEOBJECT_BYTE_ALIGNMENT) , mResourceNames(engine.GetResourceNames()) + , mAssetLoader(engine.GetAssetLoader()) {} void Scene::Update(float dt, int FRAME_DATA_INDEX) @@ -118,7 +119,8 @@ void Scene::StartLoading(FSceneRepresentation& scene) { model.mbLoaded = false; model.mModelName = ObjRep.ModelName; - model.mModelDirectory = ObjRep.ModelFilePath; + model.mModelPath = ObjRep.ModelFilePath; + mAssetLoader.QueueAssetLoad(model.mModelPath); } @@ -142,6 +144,7 @@ void Scene::StartLoading(FSceneRepresentation& scene) // dispatch workers assert(false); // TODO } + mAssetLoader.StartLoadingAssets(); // CAMERAS for (FCameraParameters& param : scene.Cameras) diff --git a/Source/Application/Scene.h b/Source/Application/Scene.h index 94611632..48b09456 100644 --- a/Source/Application/Scene.h +++ b/Source/Application/Scene.h @@ -26,6 +26,7 @@ #include "Memory.h" class Input; +class AssetLoader; struct FResourceNames; //------------------------------------------------------ @@ -202,6 +203,7 @@ class Scene const std::unique_ptr& mpWindow; VQEngine& mEngine; const FResourceNames& mResourceNames; + AssetLoader& mAssetLoader; FSceneRepresentation mSceneRepresentation; //---------------------------------------------------------------------------------------------------------------- diff --git a/Source/Application/VQEngine.h b/Source/Application/VQEngine.h index 81266f04..f7f2fbe8 100644 --- a/Source/Application/VQEngine.h +++ b/Source/Application/VQEngine.h @@ -128,7 +128,7 @@ struct FResourceNames class VQEngine : public IWindowOwner { public: - + VQEngine(); // --------------------------------------------------------- // Main Thread // --------------------------------------------------------- @@ -239,6 +239,7 @@ class VQEngine : public IWindowOwner Model& GetModel(ModelID id); const Model& GetModel(ModelID id) const; inline const FResourceNames& GetResourceNames() const { return mResourceNames; } + inline AssetLoader& GetAssetLoader() { return mAssetLoader; } @@ -317,9 +318,8 @@ class VQEngine : public IWindowOwner // scene FLoadingScreenData mLoadingScreenData; - std::queue mQueue_SceneLoad; + std::queue mQueue_SceneLoad; - std::vector< FSceneRepresentation> mSceneRepresentations; int mIndex_SelectedScene; std::unique_ptr mpScene; @@ -429,7 +429,7 @@ class VQEngine : public IWindowOwner static std::vector> ParseSceneIndexMappingFile(); static std::vector ParseEnvironmentMapsFile(); static std::vector ParseHDRProfilesFile(); - static std::vector ParseSceneFiles(); + static FSceneRepresentation ParseSceneFile(const std::string& SceneFile); public: // Supported HDR Formats { DXGI_FORMAT_R10G10B10A2_UNORM, DXGI_FORMAT_R16G16B16A16_FLOAT } diff --git a/Source/Application/VQEngine_Main.cpp b/Source/Application/VQEngine_Main.cpp index ca946d5b..3213d956 100644 --- a/Source/Application/VQEngine_Main.cpp +++ b/Source/Application/VQEngine_Main.cpp @@ -36,7 +36,9 @@ void ReportSystemInfo(const VQSystemInfo::FSystemInfo& i, bool bDetailed = false Log::Info("\n%s", sysInfo.c_str()); } #endif - +VQEngine::VQEngine() + : mAssetLoader(mWorkers_Load) +{} void VQEngine::MainThread_Tick() { @@ -263,28 +265,12 @@ void VQEngine::InitializeScenes() for (auto& nameIndex : SceneIndexMappings) mSceneNames.push_back(std::move(nameIndex.first)); } - // read scene files from disk: Data/Scenes/ - this->mSceneRepresentations = VQEngine::ParseSceneFiles(); - std::vector< FSceneRepresentation>& SceneReps = this->mSceneRepresentations; - // --------------------------------------------- - // find out which scene to load - auto it = std::find_if(SceneReps.begin(), SceneReps.end(), [&](const FSceneRepresentation& s) { return s.SceneName == mSettings.StartupScene; }); - bool bSceneFound = it != SceneReps.end(); - if (!bSceneFound) - { - Log::Error("Couldn't find scene '%s' among parsed scene files.", mSettings.StartupScene.c_str()); - Log::Warning("DefaultScene will be loaded"); - it = std::find_if(SceneReps.begin(), SceneReps.end(), [&](const FSceneRepresentation& s) { return s.SceneName == "Default"; }); - assert(it != SceneReps.end()); - mSettings.StartupScene = "Default"; - } - - // --------------------------------------------- + // read scene files from disk: Data/Scenes/ // set the selected scene index auto it2 = std::find_if(mSceneNames.begin(), mSceneNames.end(), [&](const std::string& scn) { return scn == mSettings.StartupScene; }); - bSceneFound = it2 != mSceneNames.end(); + bool bSceneFound = it2 != mSceneNames.end(); if (!bSceneFound) { Log::Error("Couldn't find scene '%s' among scene file names", mSettings.StartupScene.c_str()); diff --git a/Source/Application/VQEngine_Update.cpp b/Source/Application/VQEngine_Update.cpp index ad89d349..30112c0d 100644 --- a/Source/Application/VQEngine_Update.cpp +++ b/Source/Application/VQEngine_Update.cpp @@ -240,7 +240,7 @@ void VQEngine::HandleEngineInput() // Scene switching if (bIsShiftDown) { - const int NumScenes = static_cast(mSceneRepresentations.size()); + const int NumScenes = static_cast(mResourceNames.mSceneNames.size()); if (input.IsKeyTriggered("PageUp") && !mbLoadingLevel) { mIndex_SelectedScene = CircularIncrement(mIndex_SelectedScene, NumScenes); this->StartLoadingScene(mIndex_SelectedScene); } if (input.IsKeyTriggered("PageDown") && !mbLoadingLevel){ mIndex_SelectedScene = CircularDecrement(mIndex_SelectedScene, NumScenes - 1); this->StartLoadingScene(mIndex_SelectedScene); } } @@ -388,8 +388,10 @@ void VQEngine::StartLoadingScene(int IndexScene) // get scene representation const std::string& SceneName = mResourceNames.mSceneNames[IndexScene]; + + // queue the selected scene for loading - mQueue_SceneLoad.push(mSceneRepresentations[IndexScene]); + mQueue_SceneLoad.push(mResourceNames.mSceneNames[IndexScene]); mAppState = INITIALIZING; Log::Info("StartLoadingScene: %d", IndexScene); @@ -465,8 +467,9 @@ void VQEngine::Load_SceneData_Dispatch() if (mQueue_SceneLoad.empty()) return; - FSceneRepresentation SceneRep = mQueue_SceneLoad.front(); + const std::string SceneFileName = mQueue_SceneLoad.front(); mQueue_SceneLoad.pop(); + const int NUM_SWAPCHAIN_BACKBUFFERS = mSettings.gfx.bUseTripleBuffering ? 3 : 2; const Input& input = mInputStates.at(mpWinMain->GetHWND()); @@ -485,9 +488,10 @@ void VQEngine::Load_SceneData_Dispatch() mpScene->Unload(); } + const std::string SceneFilePath = "Data/Levels/" + SceneFileName + ".xml"; + FSceneRepresentation SceneRep = VQEngine::ParseSceneFile(SceneFilePath); fnCreateSceneInstance(SceneRep.SceneName, mpScene); - // let the custom scene logic edit the scene representation mpScene->StartLoading(SceneRep); From 04c171ff296973bb8e1e00a56b4342480e9e9d6f Mon Sep 17 00:00:00 2001 From: Volkan Date: Wed, 19 Aug 2020 17:30:09 -0700 Subject: [PATCH 17/67] Add assimp as a submodule, configure GenerateProjectFiles.bat to include assimp dependency with minimal build, update CmakeLists.txt to enable folder hierarchy in VS project --- .gitmodules | 3 +++ Build/GenerateProjectFiles.bat | 16 ++++++++++++++-- CMakeLists.txt | 23 ++++++++++++++++++++++- Libs/assimp | 1 + README.md | 3 ++- 5 files changed, 42 insertions(+), 4 deletions(-) create mode 160000 Libs/assimp diff --git a/.gitmodules b/.gitmodules index f61f93bb..fd3dfce1 100644 --- a/.gitmodules +++ b/.gitmodules @@ -7,3 +7,6 @@ [submodule "Libs/D3D12MA"] path = Libs/D3D12MA url = https://github.com/vilbeyli/D3D12MemoryAllocator.git +[submodule "Libs/assimp"] + path = Libs/assimp + url = https://github.com/assimp/assimp.git diff --git a/Build/GenerateProjectFiles.bat b/Build/GenerateProjectFiles.bat index d7ec8481..23826247 100644 --- a/Build/GenerateProjectFiles.bat +++ b/Build/GenerateProjectFiles.bat @@ -128,7 +128,19 @@ exit /b 0 :: :RunCmake -cmake ..\.. -G "Visual Studio 16 2019" -A x64 +:: assimp importers +set ASSIMP_IMPORT_FORMATS=-DASSIMP_BUILD_OBJ_IMPORTER=TRUE +:: assimp build options +set CMAKE_ASSIMP_PARAMETERS=-DASSIMP_BUILD_ASSIMP_TOOLS=OFF +set CMAKE_ASSIMP_PARAMETERS=!CMAKE_ASSIMP_PARAMETERS! -DASSIMP_NO_EXPORT=ON +set CMAKE_ASSIMP_PARAMETERS=!CMAKE_ASSIMP_PARAMETERS! -DASSIMP_BUILD_ALL_IMPORTERS_BY_DEFAULT=FALSE +set CMAKE_ASSIMP_PARAMETERS=!CMAKE_ASSIMP_PARAMETERS! -DBUILD_SHARED_LIBS=OFF +set CMAKE_ASSIMP_PARAMETERS=!CMAKE_ASSIMP_PARAMETERS! -DASSIMP_BUILD_TESTS=OFF +set CMAKE_ASSIMP_PARAMETERS=!CMAKE_ASSIMP_PARAMETERS! -DASSIMP_INSTALL=OFF +set CMAKE_ASSIMP_PARAMETERS=!CMAKE_ASSIMP_PARAMETERS! !ASSIMP_IMPORT_FORMATS! + + +cmake ..\.. -G "Visual Studio 16 2019" -A x64 !CMAKE_ASSIMP_PARAMETERS! if !errorlevel! EQU 0 ( echo [VQBuild] Success! @@ -140,7 +152,7 @@ if !errorlevel! EQU 0 ( echo [VQBuild] cmake VS2019 failed, retrying with VS 2017... echo [VQBuild] removing %~dp0SolutionFiles ... rmdir /S /Q %~dp0SolutionFiles - cmake ..\.. -G "Visual Studio 15 2017" -A x64 + cmake ..\.. -G "Visual Studio 15 2017" -A x64 !CMAKE_ASSIMP_PARAMETERS! if !errorlevel! NEQ 0 ( echo [VQBuild] cmake VS2017 failed, retrying without specifying VS version... echo [VQBuild] removing %~dp0SolutionFiles ... diff --git a/CMakeLists.txt b/CMakeLists.txt index 14da7220..3af28169 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -101,10 +101,21 @@ endforeach( OUTPUTCONFIG CMAKE_CONFIGURATION_TYPES ) add_link_options(/SUBSYSTEM:WINDOWS) +# add submodules add_subdirectory(Libs/VQUtils) add_subdirectory(Libs/D3D12MA) add_subdirectory(Source/Renderer) +#add_definitions( +# -DASSIMP_BUILD_ASSIMP_TOOLS=OFF +# -DASSIMP_NO_EXPORT=ON +# -DBUILD_SHARED_LIBS=OFF +# -DASSIMP_BUILD_TESTS=OFF +# -DASSIMP_INSTALL=OFF +#) +add_subdirectory(Libs/assimp) + + source_group("Config" FILES ${Config}) source_group("Resource" FILES ${Resource}) source_group("Icons" FILES ${Icons}) @@ -135,9 +146,19 @@ foreach( OUTPUTCONFIG ${CMAKE_CONFIGURATION_TYPES} ) endforeach( OUTPUTCONFIG CMAKE_CONFIGURATION_TYPES ) set_property(TARGET ${PROJECT_NAME} PROPERTY CXX_STANDARD 17) +set_property(GLOBAL PROPERTY USE_FOLDERS ON) +set_target_properties(assimp PROPERTIES FOLDER assimp) +set_target_properties(IrrXML PROPERTIES FOLDER assimp) +set_target_properties(uninstall PROPERTIES FOLDER assimp) +set_target_properties(UpdateAssimpLibsDebugSymbolsAndDLLs PROPERTIES FOLDER assimp) +set_target_properties(zlibstatic PROPERTIES FOLDER assimp) + +set_target_properties(VQRenderer PROPERTIES FOLDER Libs) +set_target_properties(VQUtils PROPERTIES FOLDER Libs) +set_target_properties(D3D12MA PROPERTIES FOLDER Libs) # Make sure the compiler can find include files for the libraries target_include_directories(${PROJECT_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR} ${Includes}) -target_link_libraries(${PROJECT_NAME} PRIVATE VQUtils VQRenderer ) +target_link_libraries(${PROJECT_NAME} PRIVATE VQUtils VQRenderer assimp) diff --git a/Libs/assimp b/Libs/assimp new file mode 160000 index 00000000..48ec3ef4 --- /dev/null +++ b/Libs/assimp @@ -0,0 +1 @@ +Subproject commit 48ec3ef458011dc21fa8bb2f5cf351490febf5f2 diff --git a/README.md b/README.md index e9610f65..1037405c 100644 --- a/README.md +++ b/README.md @@ -127,4 +127,5 @@ VQE supports the following command line parameters: - [D3DX12](https://github.com/microsoft/DirectX-Graphics-Samples/tree/master/Libraries/D3DX12) - [D3D12MA](https://github.com/GPUOpen-LibrariesAndSDKs/D3D12MemoryAllocator) - [stb](https://github.com/nothings/stb) -- [tinyxml2](https://github.com/leethomason/tinyxml2) \ No newline at end of file +- [tinyxml2](https://github.com/leethomason/tinyxml2) +- [assimp](https://github.com/assimp/assimp) \ No newline at end of file From 7d0fb68e9ae5fc3240bfc1c40c0acbe5652e1e5f Mon Sep 17 00:00:00 2001 From: Volkan Date: Thu, 20 Aug 2020 18:57:01 -0700 Subject: [PATCH 18/67] WIP: Model loading without material textures assignment even though they're loaded --- CMakeLists.txt | 2 + Libs/VQUtils | 2 +- Source/Application/AssetLoader.cpp | 423 +++++++++++++++++++++++- Source/Application/AssetLoader.h | 50 +-- Source/Application/Light.h | 3 +- Source/Application/Material.cpp | 17 + Source/Application/Material.h | 83 +++++ Source/Application/Mesh.h | 9 +- Source/Application/Model.cpp | 428 +------------------------ Source/Application/Model.h | 16 +- Source/Application/Scene.cpp | 85 ++++- Source/Application/Scene.h | 38 ++- Source/Application/VQEngine.h | 9 - Source/Application/VQEngine_Main.cpp | 8 +- Source/Application/VQEngine_Update.cpp | 28 +- Source/Renderer/Renderer.h | 3 + Source/Renderer/Renderer_Resources.cpp | 24 +- Source/Renderer/SwapChain.cpp | 2 +- Source/Scenes/Scenes.h | 3 +- 19 files changed, 703 insertions(+), 530 deletions(-) create mode 100644 Source/Application/Material.cpp create mode 100644 Source/Application/Material.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 3af28169..eaaf9c43 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -54,6 +54,7 @@ set (HeaderVQE "Source/Application/VQEngine.h" "Source/Application/Events.h" "Source/Application/Mesh.h" + "Source/Application/Material.h" "Source/Application/Model.h" "Source/Application/Geometry.h" "Source/Application/Transform.h" @@ -79,6 +80,7 @@ set (SourceVQE "Source/Application/FileParser.cpp" "Source/Application/Events.cpp" "Source/Application/Mesh.cpp" + "Source/Application/Material.cpp" "Source/Application/Model.cpp" "Source/Application/Geometry.cpp" "Source/Application/Transform.cpp" diff --git a/Libs/VQUtils b/Libs/VQUtils index 8e046ab3..1dfc1667 160000 --- a/Libs/VQUtils +++ b/Libs/VQUtils @@ -1 +1 @@ -Subproject commit 8e046ab3335d151c86311321dd8c58c7dab69d54 +Subproject commit 1dfc1667337efd404cba6713543eea343f032cf5 diff --git a/Source/Application/AssetLoader.cpp b/Source/Application/AssetLoader.cpp index a9c0b7eb..deab04d5 100644 --- a/Source/Application/AssetLoader.cpp +++ b/Source/Application/AssetLoader.cpp @@ -17,53 +17,165 @@ // Contact: volkanilbeyli@gmail.com #include "AssetLoader.h" +#include "Mesh.h" +#include "Material.h" +#include "Scene.h" + +#include "../Renderer/Renderer.h" #include "Libs/VQUtils/Source/Multithreading.h" #include "Libs/VQUtils/Source/utils.h" +#include "Libs/VQUtils/Source/Timer.h" +#include "Libs/VQUtils/Source/Log.h" + +#include +#include +#include + +using namespace Assimp; +using namespace DirectX; + -Model AssetLoader::ImportModel_obj(const std::string& objFilePath, std::string ModelName) +struct FMaterialTextureAssignments { - Model::Data modelData; + MaterialID matID; + AssetLoader::TextureLoadResults_t DiffuseIDs; + AssetLoader::TextureLoadResults_t SpecularIDs; + AssetLoader::TextureLoadResults_t NormalsIDs; + AssetLoader::TextureLoadResults_t HeightMapIDs; + AssetLoader::TextureLoadResults_t AlphaMapIDs; +}; + +Model::Data ProcessAssimpNode( + aiNode* const pNode + , const aiScene* pAiScene + , const std::string& modelDirectory + , AssetLoader* pAssetLoader + , Scene* pScene + , VQRenderer* pRenderer + , std::vector& MaterialTextureAssignments +); + + +//---------------------------------------------------------------------------------------------------------------- +// IMPORTERS +//---------------------------------------------------------------------------------------------------------------- + +ModelID AssetLoader::ImportModel_obj(Scene* pScene, AssetLoader* pAssetLoader, VQRenderer* pRenderer, const std::string& objFilePath, std::string ModelName) +{ + constexpr auto ASSIMP_LOAD_FLAGS + = aiProcess_Triangulate + | aiProcess_CalcTangentSpace + | aiProcess_MakeLeftHanded + | aiProcess_FlipUVs + | aiProcess_FlipWindingOrder + //| aiProcess_TransformUVCoords + //| aiProcess_FixInfacingNormals + | aiProcess_JoinIdenticalVertices + | aiProcess_GenSmoothNormals; + + + const std::string modelDirectory = DirectoryUtil::GetFolderPath(objFilePath); Log::Info("ImportModel_obj: %s - %s", ModelName.c_str(), objFilePath.c_str()); - // TODO: assimp model import + Timer t; + t.Start(); + + // Import Assimp Scene + Importer importer; + const aiScene* pAiScene = importer.ReadFile(objFilePath, ASSIMP_LOAD_FLAGS); + if (!pAiScene || pAiScene->mFlags & AI_SCENE_FLAGS_INCOMPLETE || !pAiScene->mRootNode) + { + Log::Error("Assimp error: %s", importer.GetErrorString()); + return INVALID_ID; + } + t.Tick(); float fTimeReadFile = t.DeltaTime(); + Log::Info(" ReadFile(): %.3fs", fTimeReadFile); - return Model(objFilePath, ModelName, std::move(modelData)); + // parse scene and initialize model data + std::vector MaterialTextureAssignments; + Model::Data data = ProcessAssimpNode(pAiScene->mRootNode, pAiScene, modelDirectory, pAssetLoader, pScene, pRenderer, MaterialTextureAssignments); + + std::vector> v = pAssetLoader->StartLoadingTextures(); + + // cache the imported model in Scene + ModelID mID = pScene->CreateModel(); + Model& model = pScene->GetModel(mID); + model = Model(objFilePath, ModelName, std::move(data)); + + // wait for textures to be loaded and assign TextureIDs; + for (FMaterialTextureAssignments& assignment : MaterialTextureAssignments) + { + Material& mat = pScene->GetMaterial(assignment.matID); + + auto fnAssignTextureIDs = [](MaterialID matID, const std::string& strTexType, std::vector>& textures, TextureID& textureMapID) + { + if (textures.size() > 1) + { + Log::Warning("More than 1 %s in MaterialID=%d, will only use the first texture.", strTexType.c_str(), matID); + } + for (std::future& texIDs : textures) + { + assert(texIDs.valid()); + texIDs.wait(); + textureMapID = texIDs.get(); + break; // TODO: currently only 1 diffuse map supported (no texture blending) + } + }; + + fnAssignTextureIDs(assignment.matID, "Diffuse Map" , assignment.DiffuseIDs , mat.diffuseMap); + fnAssignTextureIDs(assignment.matID, "Specular Map" , assignment.SpecularIDs , mat.specularMap); + fnAssignTextureIDs(assignment.matID, "Normal Map" , assignment.NormalsIDs , mat.normalMap); + fnAssignTextureIDs(assignment.matID, "HeightMap Map", assignment.HeightMapIDs, mat.heightMap); + fnAssignTextureIDs(assignment.matID, "Alpha Map" , assignment.AlphaMapIDs , mat.mask); + } + + t.Stop(); + Log::Info("Loaded Model '%s' in %.2f seconds.", ModelName.c_str(), t.DeltaTime()); + return mID; } -Model AssetLoader::ImportModel_gltf(const std::string& objFilePath, std::string ModelName) +ModelID AssetLoader::ImportModel_gltf(Scene* pScene, AssetLoader* pAssetLoader, VQRenderer* pRenderer, const std::string& objFilePath, std::string ModelName) { assert(false); // TODO - return Model(); + return INVALID_ID; } -void AssetLoader::QueueAssetLoad(const std::string& ModelPath) + + +//---------------------------------------------------------------------------------------------------------------- +// ASSET LOADER +//---------------------------------------------------------------------------------------------------------------- + +void AssetLoader::QueueModelLoad(const std::string& ModelPath, const std::string& ModelName) { const std::string FileExtension = DirectoryUtil::GetFileExtension(ModelPath); - static std::unordered_map < std::string, FModelLoadParams::pfnImportModel_t> MODEL_IMPORT_FUNCTIONS = + static const std::unordered_map MODEL_IMPORT_FUNCTIONS = { { "obj" , AssetLoader::ImportModel_obj } , { "gltf", AssetLoader::ImportModel_gltf } // TODO }; std::unique_lock lk(mMtxQueue_ModelLoad); - mModelLoadQueue.push({ModelPath, MODEL_IMPORT_FUNCTIONS.at(FileExtension)}); + mModelLoadQueue.push({ModelPath, ModelName, MODEL_IMPORT_FUNCTIONS.at(FileExtension)}); } -void AssetLoader::StartLoadingAssets() +AssetLoader::ModelLoadResults_t AssetLoader::StartLoadingModels(Scene* pScene) { + ModelLoadResults_t ModelLoadResults; if (mModelLoadQueue.empty()) { - Log::Warning("AssetLoader::StartLoadingAssets(): no models to load"); - return; + Log::Warning("AssetLoader::StartLoadingModels(): no models to load"); + return ModelLoadResults; } // process model load queue + VQRenderer* pRenderer = &mRenderer; std::unique_lock lk(mMtxQueue_ModelLoad); do { - FModelLoadParams ModelLoadParams = mModelLoadQueue.front(); + FModelLoadParams ModelLoadParams = std::move(mModelLoadQueue.front()); const std::string& ModelPath = ModelLoadParams.ModelPath; mModelLoadQueue.pop(); @@ -73,13 +185,294 @@ void AssetLoader::StartLoadingAssets() mUniqueModelPaths.insert(ModelPath); // start loading - mWorkers.AddTask([=]() + std::future modelLoadResult = mWorkers.AddTask([=]() { - ModelLoadParams.pfnImportModel(ModelLoadParams.ModelPath, ""); + return ModelLoadParams.pfnImportModel(pScene, this, pRenderer, ModelLoadParams.ModelPath, ModelLoadParams.ModelName); }); + ModelLoadResults.push_back(std::move(modelLoadResult)); } } while (!mModelLoadQueue.empty()); mUniqueModelPaths.clear(); + return ModelLoadResults; +} + +void AssetLoader::QueueTextureLoad(const FTextureLoadParams& TexLoadParam) +{ + std::unique_lock lk(mMtxQueue_TextureLoad); + mTextureLoadQueue.push(TexLoadParam); +} + +std::vector> AssetLoader::StartLoadingTextures() +{ + std::vector> TextureLoadResults; + if (mTextureLoadQueue.empty()) + { + Log::Warning("AssetLoader::StartLoadingTextures(): no Textures to load"); + return TextureLoadResults; + } + + + // process model load queue + std::unique_lock lk(mMtxQueue_ModelLoad); + do + { + FTextureLoadParams TexLoadParams = std::move(mTextureLoadQueue.front()); + mTextureLoadQueue.pop(); + + // eliminate duplicates + if (mUniqueTexturePaths.find(TexLoadParams.TexturePath) == mUniqueTexturePaths.end()) + { + mUniqueTexturePaths.insert(TexLoadParams.TexturePath); + + std::future loadResult = mWorkers.AddTask([this, TexLoadParams]() + { + return mRenderer.CreateTextureFromFile(TexLoadParams.TexturePath.c_str()); + }); + TextureLoadResults.push_back(std::move(loadResult)); + } + } while (!mTextureLoadQueue.empty()); + + mUniqueTexturePaths.clear(); + + return TextureLoadResults; +} + + + + + +//---------------------------------------------------------------------------------------------------------------- +// ASSIMP HELPER FUNCTIONS +//---------------------------------------------------------------------------------------------------------------- +static std::vector GenerateTextureLoadParams( + aiMaterial* pMaterial + , aiTextureType type + , const std::string& textureName + , const std::string& modelDirectory +) +{ + std::vector TexLoadParams; + for (unsigned int i = 0; i < pMaterial->GetTextureCount(type); ++i) + { + aiString str; + pMaterial->GetTexture(type, i, &str); + std::string path = str.C_Str(); + AssetLoader::FTextureLoadParams params = {}; + params.TexturePath = modelDirectory + path; + TexLoadParams.push_back(params); + } + return TexLoadParams; } +static Mesh ProcessAssimpMesh(VQRenderer* pRenderer, aiMesh* mesh, const aiScene* scene) +{ + std::vector Vertices; + std::vector Indices; + + // Walk through each of the mesh's vertices + for (unsigned int i = 0; i < mesh->mNumVertices; i++) + { + FVertexWithNormalAndTangent Vert; + + // POSITIONS + Vert.position[0] = mesh->mVertices[i].x; + Vert.position[1] = mesh->mVertices[i].y; + Vert.position[2] = mesh->mVertices[i].z; + + // NORMALS + if (mesh->mNormals) + { + Vert.normal[0] = mesh->mNormals[i].x; + Vert.normal[1] = mesh->mNormals[i].y; + Vert.normal[2] = mesh->mNormals[i].z; + } + + // TEXTURE COORDINATES + // a vertex can contain up to 8 different texture coordinates. We thus make the assumption that we won't + // use models where a vertex can have multiple texture coordinates so we always take the first set (0). + Vert.uv[0] = mesh->mTextureCoords[0] ? mesh->mTextureCoords[0][i].x : 0; + Vert.uv[1] = mesh->mTextureCoords[0] ? mesh->mTextureCoords[0][i].y : 0; + + // TANGENT + if (mesh->mTangents) + { + Vert.tangent[0] = mesh->mTangents[i].x; + Vert.tangent[1] = mesh->mTangents[i].y; + Vert.tangent[2] = mesh->mTangents[i].z; + } + + + // BITANGENT ( NOT USED ) + // Vert.bitangent = XMFLOAT3( + // mesh->mBitangents[i].x, + // mesh->mBitangents[i].y, + // mesh->mBitangents[i].z + // ); + Vertices.push_back(Vert); + } + + // now walk through each of the mesh's faces (a face is a mesh its triangle) and retrieve the corresponding vertex indices. + for (unsigned int i = 0; i < mesh->mNumFaces; i++) + { + aiFace face = mesh->mFaces[i]; + // retrieve all indices of the face and store them in the indices vector + for (unsigned int j = 0; j < face.mNumIndices; j++) + Indices.push_back(face.mIndices[j]); + } + + // TODO: mesh name + return Mesh(pRenderer, Vertices, Indices, ""); +} + +static Model::Data ProcessAssimpNode( + aiNode* const pNode, + const aiScene* pAiScene, + const std::string& modelDirectory, + AssetLoader* pAssetLoader, + Scene* pScene, + VQRenderer* pRenderer, + std::vector& MaterialTextureAssignments +) +{ + Model::Data modelData; + + for (unsigned int i = 0; i < pNode->mNumMeshes; i++) + { // process all the node's meshes (if any) + aiMesh* pAiMesh = pAiScene->mMeshes[pNode->mMeshes[i]]; + + // MATERIAL - http://assimp.sourceforge.net/lib_html/materials.html + aiMaterial* material = pAiScene->mMaterials[pAiMesh->mMaterialIndex]; + + // get texture paths to load + FMaterialTextureAssignments MatAssignment = {}; + std::vector diffuseMaps = GenerateTextureLoadParams(material, aiTextureType_DIFFUSE, "texture_diffuse", modelDirectory); + std::vector specularMaps = GenerateTextureLoadParams(material, aiTextureType_SPECULAR, "texture_specular", modelDirectory); + std::vector normalMaps = GenerateTextureLoadParams(material, aiTextureType_NORMALS, "texture_normal", modelDirectory); + std::vector heightMaps = GenerateTextureLoadParams(material, aiTextureType_HEIGHT, "texture_height", modelDirectory); + std::vector alphaMaps = GenerateTextureLoadParams(material, aiTextureType_OPACITY, "texture_alpha", modelDirectory); + + // start loading textures + std::array TexLoadParams = { &diffuseMaps, &specularMaps, &normalMaps, &heightMaps, &alphaMaps }; + std::array TexAssignParams = + { + &MatAssignment.DiffuseIDs + , &MatAssignment.SpecularIDs + , &MatAssignment.NormalsIDs + , &MatAssignment.HeightMapIDs + , &MatAssignment.AlphaMapIDs + }; + + int iTexType = 0; + for (const auto* pvLoadParams : TexLoadParams) + { + int iTex = 0; + for (const AssetLoader::FTextureLoadParams& param : *pvLoadParams) + { + pAssetLoader->QueueTextureLoad(param); + ++iTex; + } + + // kick off texture load workers only if we have at least 1 texture + if (iTex > 0) + { + //*TexAssignParams[iTexType] = std::move(pAssetLoader->StartLoadingTextures()); + } + + ++iTexType; + } + + // Every material assumed to have a name : Create material here + MaterialID matID = INVALID_ID; + aiString name; + if (aiReturn_SUCCESS == material->Get(AI_MATKEY_NAME, name)) + { + const std::string ModelFolderName = DirectoryUtil::GetFlattenedFolderHierarchy(modelDirectory).back(); + std::string uniqueMatName = name.C_Str(); + // modelDirectory = "Data/Models/%MODEL_NAME%/" + // Materials use the following unique naming: %MODEL_NAME%/%MATERIAL_NAME% + uniqueMatName = ModelFolderName + "/" + uniqueMatName; + matID = pScene->CreateMaterial(uniqueMatName); + } + + // unflatten the material texture assignments + MatAssignment.matID = matID; + MaterialTextureAssignments.push_back(std::move(MatAssignment)); + + Material& mat = pScene->GetMaterial(matID); + + aiColor3D color(0.f, 0.f, 0.f); + if (aiReturn_SUCCESS == material->Get(AI_MATKEY_COLOR_DIFFUSE, color)) + { + mat.diffuse = XMFLOAT3(color.r, color.g, color.b); + } + + aiColor3D specular(0.f, 0.f, 0.f); + if (aiReturn_SUCCESS == material->Get(AI_MATKEY_COLOR_SPECULAR, specular)) + { + mat.specular = XMFLOAT3(specular.r, specular.g, specular.b); + } + + aiColor3D transparent(0.0f, 0.0f, 0.0f); + if (aiReturn_SUCCESS == material->Get(AI_MATKEY_COLOR_TRANSPARENT, transparent)) + { // Defines the transparent color of the material, this is the color to be multiplied + // with the color of translucent light to construct the final 'destination color' + // for a particular position in the screen buffer. T + // + int a = 5; + } + + float opacity = 0.0f; + if (aiReturn_SUCCESS == material->Get(AI_MATKEY_OPACITY, opacity)) + { + mat.alpha = opacity; + } + + float shininess = 0.0f; + if (aiReturn_SUCCESS == material->Get(AI_MATKEY_SHININESS, shininess)) + { + // Phong Shininess -> Beckmann BRDF Roughness conversion + // + // https://simonstechblog.blogspot.com/2011/12/microfacet-brdf.html + // https://computergraphics.stackexchange.com/questions/1515/what-is-the-accepted-method-of-converting-shininess-to-roughness-and-vice-versa + // + mat.roughness = sqrtf(2.0f / (2.0f + shininess)); + } + + // other material keys to consider + // + // AI_MATKEY_TWOSIDED + // AI_MATKEY_ENABLE_WIREFRAME + // AI_MATKEY_BLEND_FUNC + // AI_MATKEY_BUMPSCALING + + Mesh mesh = ProcessAssimpMesh(pRenderer, pAiMesh, pAiScene); + MeshID id = pScene->AddMesh(std::move(mesh)); + modelData.mOpaueMeshIDs.push_back(id); + + modelData.mOpaqueMaterials[modelData.mOpaueMeshIDs.back()] = matID; + if (mat.IsTransparent()) + { + modelData.mTransparentMeshIDs.push_back(modelData.mOpaueMeshIDs.back()); + } + } // for: NumMeshes + + for (unsigned int i = 0; i < pNode->mNumChildren; i++) + { // then do the same for each of its children + Model::Data childModelData = ProcessAssimpNode(pNode->mChildren[i], pAiScene, modelDirectory, pAssetLoader, pScene, pRenderer, MaterialTextureAssignments); + std::vector& ChildMeshes = childModelData.mOpaueMeshIDs; + std::vector& ChildMeshesTransparent = childModelData.mTransparentMeshIDs; + + std::copy(ChildMeshes.begin(), ChildMeshes.end(), std::back_inserter(modelData.mOpaueMeshIDs)); + std::copy(ChildMeshesTransparent.begin(), ChildMeshesTransparent.end(), std::back_inserter(modelData.mTransparentMeshIDs)); + for (auto& kvp : childModelData.mOpaqueMaterials) + { +#if _DEBUG + assert(modelData.mOpaqueMaterials.find(kvp.first) == modelData.mOpaqueMaterials.end()); +#endif + modelData.mOpaqueMaterials[kvp.first] = kvp.second; + } + } // for: NumChildren + + return modelData; +} diff --git a/Source/Application/AssetLoader.h b/Source/Application/AssetLoader.h index 52d5c963..d90316f5 100644 --- a/Source/Application/AssetLoader.h +++ b/Source/Application/AssetLoader.h @@ -19,46 +19,56 @@ #include "Model.h" -#include +#include +#include +#include +#include class ThreadPool; +class Scene; class AssetLoader { public: - static Model ImportModel_obj (const std::string& objFilePath, std::string ModelName = "NONE"); // TODO: rename to LoadModel_obj() ? - static Model ImportModel_gltf(const std::string& objFilePath, std::string ModelName = "NONE"); // TODO: rename to LoadModel_gltf() ? - -public: - - AssetLoader(ThreadPool& WorkerThreads) - : mWorkers(WorkerThreads) - {} - - void QueueAssetLoad(const std::string& ModelPath); - void StartLoadingAssets(); - -private: struct FModelLoadParams { - using pfnImportModel_t = Model(*)(const std::string& objFilePath, std::string ModelName); + using pfnImportModel_t = ModelID(*)(Scene* pScene, AssetLoader* pAssetLoader, VQRenderer* pRenderer, const std::string& objFilePath, std::string ModelName); std::string ModelPath; + std::string ModelName; pfnImportModel_t pfnImportModel; }; struct FTextureLoadParams { std::string TexturePath; }; + using ModelLoadResults_t = std::vector>; + using TextureLoadResults_t = std::vector>; +public: + AssetLoader(ThreadPool& WorkerThreads, VQRenderer& renderer) + : mWorkers(WorkerThreads) + , mRenderer(renderer) + {} + + void QueueModelLoad(const std::string& ModelPath, const std::string& ModelName); + ModelLoadResults_t StartLoadingModels(Scene* pScene); + void QueueTextureLoad(const FTextureLoadParams& TexLoadParam); + TextureLoadResults_t StartLoadingTextures(); private: - ThreadPool& mWorkers; + static ModelID ImportModel_obj (Scene* pScene, AssetLoader* pAssetLoader, VQRenderer* pRenderer, const std::string& objFilePath, std::string ModelName = "NONE"); // TODO: rename to LoadModel_obj() ? + static ModelID ImportModel_gltf(Scene* pScene, AssetLoader* pAssetLoader, VQRenderer* pRenderer, const std::string& objFilePath, std::string ModelName = "NONE"); // TODO: rename to LoadModel_gltf() ? - std::queue mModelLoadQueue; - std::set mUniqueModelPaths; +private: + std::unordered_map mLoadedModels; - std::queue< FTextureLoadParams> mTextureLoadQueue; + // MT Model loading + ThreadPool& mWorkers; + VQRenderer& mRenderer; + // TODO: use ConcurrentQueue with ProcessElements(pfnProcess); + std::queue mModelLoadQueue; + std::queue mTextureLoadQueue; + std::set mUniqueModelPaths; std::set mUniqueTexturePaths; - std::mutex mMtxQueue_ModelLoad; std::mutex mMtxQueue_TextureLoad; }; \ No newline at end of file diff --git a/Source/Application/Light.h b/Source/Application/Light.h index 616b66f8..8a571c61 100644 --- a/Source/Application/Light.h +++ b/Source/Application/Light.h @@ -71,4 +71,5 @@ struct Light // TODO }; -constexpr size_t SZ_LIGHT_STRUCT = sizeof(Light); + +//constexpr size_t SZ_LIGHT_STRUCT = sizeof(Light); diff --git a/Source/Application/Material.cpp b/Source/Application/Material.cpp new file mode 100644 index 00000000..845325ac --- /dev/null +++ b/Source/Application/Material.cpp @@ -0,0 +1,17 @@ +// VQE +// Copyright(C) 2020 - Volkan Ilbeyli +// +// This program is free software : you can redistribute it and / or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program.If not, see . +// +// Contact: volkanilbeyli@gmail.com \ No newline at end of file diff --git a/Source/Application/Material.h b/Source/Application/Material.h new file mode 100644 index 00000000..42151906 --- /dev/null +++ b/Source/Application/Material.h @@ -0,0 +1,83 @@ +// VQE +// Copyright(C) 2020 - Volkan Ilbeyli +// +// This program is free software : you can redistribute it and / or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program.If not, see . +// +// Contact: volkanilbeyli@gmail.com + +#pragma once +#include + +struct Material // 56 Bytes +{ + //------------------------------------------------------------ + MaterialID ID = INVALID_ID; // 4 Bytes + DirectX::XMFLOAT3 diffuse = {1, 1, 1}; // 12 Bytes + //------------------------------------------------------------ + float alpha = 1.0f; // 4 Bytes + DirectX::XMFLOAT3 specular = { 1, 1, 1 }; // 12 Bytes + //------------------------------------------------------------ + DirectX::XMFLOAT3 emissiveColor = { 1, 1, 1 }; // 12 Bytes + float emissiveIntensity = 0.0f; // 4 Bytes + //------------------------------------------------------------ + DirectX::XMFLOAT2 tiling = { 1, 1 }; // 8 Bytes + DirectX::XMFLOAT2 uv_bias = { 0, 0 }; // 8 Bytes + //------------------------------------------------------------ + // Cook-Torrence BRDF + float metalness = 0.0f; // 4 Bytes + float roughness = 0.8f; // 4 Bytes + float pad0, pad1; // 8 Bytes + //------------------------------------------------------------ + + TextureID diffuseMap = INVALID_ID; + TextureID normalMap = INVALID_ID; + TextureID heightMap = INVALID_ID; + TextureID specularMap = INVALID_ID; // phong? + TextureID roughnessMap = INVALID_ID; + TextureID metallicMap = INVALID_ID; + TextureID mask = INVALID_ID; + TextureID emissiveMap = INVALID_ID; + + //------------------------------------------------------------ + + inline bool IsTransparent() const { return alpha != 1.0f; } +#if 0 + Material(MaterialID _ID); + ~Material(); + + void SetMaterialConstants(Renderer* renderer, EShaders shader, bool bIsDeferredRendering) const; + int GetTextureConfig() const; + inline bool HasTexture() const { return GetTextureConfig() != 0; } + + virtual SurfaceMaterial GetCBufferData() const = 0; + virtual void Clear() = 0; + + static SurfaceMaterial GetDefaultMaterialCBufferData(); +}; + +struct BRDF_Material : public Material +{ // Cook-Torrence BRDF + float metalness; + float roughness; + + BRDF_Material() : Material({ -1 }), metalness(0.0f), roughness(0.0f) {} + + SurfaceMaterial GetCBufferData() const override; + void Clear() override; + +private: + friend class MaterialPool; // only MaterialPool can create Material instances + BRDF_Material(MaterialID _ID) : Material(_ID), metalness(0.1f), roughness(0.6f) {} +#endif +}; \ No newline at end of file diff --git a/Source/Application/Mesh.h b/Source/Application/Mesh.h index 44cd9675..7c154b39 100644 --- a/Source/Application/Mesh.h +++ b/Source/Application/Mesh.h @@ -78,7 +78,7 @@ struct Mesh ); template - Mesh(const MeshLODData& meshLODData); + Mesh(VQRenderer* pRenderer, const MeshLODData& meshLODData); Mesh() = default; // Mesh() = delete; @@ -111,6 +111,7 @@ Mesh::Mesh( const std::string& name ) { + assert(pRenderer); FBufferDesc bufferDesc = {}; const std::string VBName = name + "_LOD[0]_VB"; @@ -136,7 +137,7 @@ Mesh::Mesh( } template -Mesh::Mesh(const MeshLODData& meshLODData) +Mesh::Mesh(VQRenderer* pRenderer, const MeshLODData& meshLODData) { for (size_t LOD = 0; LOD < meshLODData.LODVertices.size(); ++LOD) { @@ -149,13 +150,13 @@ Mesh::Mesh(const MeshLODData& meshLODData) //bufferDesc.mUsage = GPU_READ_WRITE; bufferDesc.mElementCount = static_cast(meshLODData.LODVertices[LOD].size()); bufferDesc.mStride = sizeof(meshLODData.LODVertices[LOD][0]); - BufferID vertexBufferID = spRenderer->CreateBuffer(bufferDesc, meshLODData.LODVertices[LOD].data(), VBName.c_str()); + BufferID vertexBufferID = pRenderer->CreateBuffer(bufferDesc, meshLODData.LODVertices[LOD].data(), VBName.c_str()); bufferDesc.mType = INDEX_BUFFER; //bufferDesc.mUsage = GPU_READ_WRITE; bufferDesc.NumElements = static_cast(meshLODData.LODIndices[LOD].size()); bufferDesc.mStride = sizeof(unsigned); - BufferID indexBufferID = spRenderer->CreateBuffer(bufferDesc, meshLODData.LODIndices[LOD].data(), IBName.c_str()); + BufferID indexBufferID = pRenderer->CreateBuffer(bufferDesc, meshLODData.LODIndices[LOD].data(), IBName.c_str()); mLODBufferPairs.push_back({ vertexBufferID, indexBufferID }); mNumIndicesPerLODLevel.push_back(bufferDesc.NumElements); diff --git a/Source/Application/Model.cpp b/Source/Application/Model.cpp index 5e760bda..ac6a3704 100644 --- a/Source/Application/Model.cpp +++ b/Source/Application/Model.cpp @@ -18,432 +18,10 @@ #include "Model.h" -#if 0 -#include "Utilities/Log.h" -#include "Utilities/PerfTimer.h" - -#include "Renderer/Renderer.h" - -#include "Scene.h" - -#include -#include -#include - -#include "Engine.h" - -#include - - -const char* ModelLoader::sRootFolderModels = "Data/Models/"; - -using namespace Assimp; -using fnTypeProcessNode = std::function&)>; -using fnTypeProcessMesh = std::function; - - +#include bool Model::Data::AddMaterial(MeshID meshID, MaterialID matID, bool bTransparent) { - auto it = mMaterialLookupPerMesh.find(meshID); - if (it == mMaterialLookupPerMesh.end()) - { - mMaterialLookupPerMesh[meshID] = matID; - } - else - { -#if _DEBUG - Log::Warning("Overriding Material"); -#endif - mMaterialLookupPerMesh[meshID] = matID; - - if (bTransparent) - { - mTransparentMeshIDs.push_back(meshID); - } - } - - return true; -} - - -void Model::AddMaterialToMesh(MeshID meshID, MaterialID materialID, bool bTransparent) -{ - mData.AddMaterial(meshID, materialID); -} - -void Model::OverrideMaterials(MaterialID materialID) -{ - for (MeshID mesh : mData.mMeshIDs) - { - mData.AddMaterial(mesh, materialID); - } -} - - -//---------------------------------------------------------------------------------------------------------------- -// ASSIMP HELPER FUNCTIONS -//---------------------------------------------------------------------------------------------------------------- -std::vector LoadMaterialTextures( - aiMaterial* pMaterial, - aiTextureType type, - const std::string& textureName, - VQRenderer* mpRenderer, - const std::string& modelDirectory -) -{ - std::vector textures; - for (unsigned int i = 0; i < pMaterial->GetTextureCount(type); i++) - { - aiString str; - pMaterial->GetTexture(type, i, &str); - std::string path = str.C_Str(); - { - std::unique_lock lock(Engine::mLoadRenderingMutex); - textures.push_back(mpRenderer->CreateTextureFromFile(path, modelDirectory, true)); - } - } - return textures; -} - - -Mesh ProcessMesh(aiMesh * mesh, const aiScene * scene) -{ - std::vector Vertices; - std::vector Indices; - - // Walk through each of the mesh's vertices - for (unsigned int i = 0; i < mesh->mNumVertices; i++) - { - DefaultVertexBufferData Vert; - - // POSITIONS - Vert.position = vec3( - mesh->mVertices[i].x, - mesh->mVertices[i].y, - mesh->mVertices[i].z - ); - - // NORMALS - if (mesh->mNormals) - { - Vert.normal = vec3( - mesh->mNormals[i].x, - mesh->mNormals[i].y, - mesh->mNormals[i].z - ); - } - - // TEXTURE COORDINATES - // a vertex can contain up to 8 different texture coordinates. We thus make the assumption that we won't - // use models where a vertex can have multiple texture coordinates so we always take the first set (0). - Vert.uv = mesh->mTextureCoords[0] - ? vec2(mesh->mTextureCoords[0][i].x, mesh->mTextureCoords[0][i].y) - : vec2(0, 0); - - // TANGENT - if (mesh->mTangents) - { - Vert.tangent = vec3( - mesh->mTangents[i].x, - mesh->mTangents[i].y, - mesh->mTangents[i].z - ); - } - - - // BITANGENT ( NOT USED ) - // Vert.bitangent = vec3( - // mesh->mBitangents[i].x, - // mesh->mBitangents[i].y, - // mesh->mBitangents[i].z - // ); - Vertices.push_back(Vert); - } - - // now walk through each of the mesh's faces (a face is a mesh its triangle) and retrieve the corresponding vertex indices. - for (unsigned int i = 0; i < mesh->mNumFaces; i++) - { - aiFace face = mesh->mFaces[i]; - // retrieve all indices of the face and store them in the indices vector - for (unsigned int j = 0; j < face.mNumIndices; j++) - Indices.push_back(face.mIndices[j]); - } - - // TODO: mesh name - - Mesh newMesh = [&]() - { - std::unique_lock lck(Engine::mLoadRenderingMutex); - return Mesh(Vertices, Indices, "ImportedModelMesh0"); // return a mesh object created from the extracted mesh data - }(); - return newMesh; -} - -Model::Data ProcessNode( - aiNode* const pNode, - const aiScene* pAiScene, - const std::string& modelDirectory, - VQRenderer* mpRenderer, // creates resources - Scene* pScene // write -) -{ - Model::Data modelData; - std::vector& ModelMeshIDs = modelData.mMeshIDs; - - for (unsigned int i = 0; i < pNode->mNumMeshes; i++) - { // process all the node's meshes (if any) - aiMesh* pAiMesh = pAiScene->mMeshes[pNode->mMeshes[i]]; - - // MATERIAL - http://assimp.sourceforge.net/lib_html/materials.html - aiMaterial* material = pAiScene->mMaterials[pAiMesh->mMaterialIndex]; - std::vector diffuseMaps = LoadMaterialTextures(material, aiTextureType_DIFFUSE , "texture_diffuse" , mpRenderer, modelDirectory); - std::vector specularMaps = LoadMaterialTextures(material, aiTextureType_SPECULAR , "texture_specular", mpRenderer, modelDirectory); - std::vector normalMaps = LoadMaterialTextures(material, aiTextureType_NORMALS , "texture_normal" , mpRenderer, modelDirectory); - std::vector heightMaps = LoadMaterialTextures(material, aiTextureType_HEIGHT , "texture_height" , mpRenderer, modelDirectory); - std::vector alphaMaps = LoadMaterialTextures(material, aiTextureType_OPACITY , "texture_alpha" , mpRenderer, modelDirectory); - - BRDF_Material* pBRDF = static_cast(pScene->CreateNewMaterial(GGX_BRDF)); - assert(diffuseMaps.size() <= 1); assert(normalMaps.size() <= 1); - assert(specularMaps.size() <= 1); assert(heightMaps.size() <= 1); - assert(alphaMaps.size() <= 1); - if (!diffuseMaps.empty()) pBRDF->diffuseMap = diffuseMaps[0]; - if (!normalMaps.empty()) pBRDF->normalMap = normalMaps[0]; - if (!specularMaps.empty()) pBRDF->specularMap = specularMaps[0]; - if (!heightMaps.empty()) pBRDF->heightMap = heightMaps[0]; - if (!alphaMaps.empty()) pBRDF->mask = alphaMaps[0]; - - aiString name; - if (aiReturn_SUCCESS == material->Get(AI_MATKEY_NAME, name)) - { - // we don't store names for materials. probably best to store them in a lookup somewhere, - // away from the material data. - // - // pBRDF-> - } - - aiColor3D color(0.f, 0.f, 0.f); - if (aiReturn_SUCCESS == material->Get(AI_MATKEY_COLOR_DIFFUSE, color)) - { - pBRDF->diffuse = vec3(color.r, color.g, color.b); - } - - aiColor3D specular(0.f, 0.f, 0.f); - if (aiReturn_SUCCESS == material->Get(AI_MATKEY_COLOR_SPECULAR, specular)) - { - pBRDF->specular = vec3(specular.r, specular.g, specular.b); - } - - aiColor3D transparent(0.0f, 0.0f, 0.0f); - if (aiReturn_SUCCESS == material->Get(AI_MATKEY_COLOR_TRANSPARENT, transparent)) - { // Defines the transparent color of the material, this is the color to be multiplied - // with the color of translucent light to construct the final 'destination color' - // for a particular position in the screen buffer. T - // - //pBRDF->specular = vec3(specular.r, specular.g, specular.b); - } - - float opacity = 0.0f; - if (aiReturn_SUCCESS == material->Get(AI_MATKEY_OPACITY, opacity)) - { - pBRDF->alpha = opacity; - } - - float shininess = 0.0f; - if (aiReturn_SUCCESS == material->Get(AI_MATKEY_SHININESS, shininess)) - { - // Phong Shininess -> Beckmann BRDF Roughness conversion - // - // https://simonstechblog.blogspot.com/2011/12/microfacet-brdf.html - // https://computergraphics.stackexchange.com/questions/1515/what-is-the-accepted-method-of-converting-shininess-to-roughness-and-vice-versa - // - pBRDF->roughness = sqrtf(2.0f / (2.0f + shininess)); - } - -#if MAKE_IRONMAN_METALLIC || MAKE_ZENBALL_METALLIC - - // --- - // quick hack to assign metallic value to the loaded mesh - // - std::string fileName(pAiScene->mRootNode->mName.C_Str()); - std::transform(RANGE(fileName), fileName.begin(), ::tolower); - auto tokens = StrUtil::split(fileName, '.'); - if (!tokens.empty() && (tokens[0] == "ironman" || tokens[0] == "zen_orb")) - { - pBRDF->metalness = 1.0f; - } - //--- -#endif - - // other material keys to consider - // - // AI_MATKEY_TWOSIDED - // AI_MATKEY_ENABLE_WIREFRAME - // AI_MATKEY_BLEND_FUNC - // AI_MATKEY_BUMPSCALING - - Mesh mesh = ProcessMesh(pAiMesh, pAiScene); - { - MeshID id = pScene->AddMesh_Async(mesh); - ModelMeshIDs.push_back(id); - } - - modelData.mMaterialLookupPerMesh[ModelMeshIDs.back()] = pBRDF->ID; - if (pBRDF->IsTransparent()) - { - modelData.mTransparentMeshIDs.push_back(ModelMeshIDs.back()); - } - } - for (unsigned int i = 0; i < pNode->mNumChildren; i++) - { // then do the same for each of its children - Model::Data childModelData = ProcessNode(pNode->mChildren[i], pAiScene, modelDirectory, mpRenderer, pScene); - std::vector& ChildMeshes = childModelData.mMeshIDs; - std::vector& ChildMeshesTransparent = childModelData.mTransparentMeshIDs; - - std::copy(ChildMeshes.begin(), ChildMeshes.end(), std::back_inserter(ModelMeshIDs)); - std::copy(ChildMeshesTransparent.begin(), ChildMeshesTransparent.end(), std::back_inserter(modelData.mTransparentMeshIDs)); - for (auto& kvp : childModelData.mMaterialLookupPerMesh) - { -#if _DEBUG - assert(modelData.mMaterialLookupPerMesh.find(kvp.first) == modelData.mMaterialLookupPerMesh.end()); -#endif - modelData.mMaterialLookupPerMesh[kvp.first] = kvp.second; - } - } - return modelData; -} - -#endif - -#if 0 -//---------------------------------------------------------------------------------------------------------------- -// MODEL LOADER -//---------------------------------------------------------------------------------------------------------------- -constexpr auto ASSIMP_LOAD_FLAGS -= aiProcess_Triangulate -| aiProcess_CalcTangentSpace -| aiProcess_MakeLeftHanded -| aiProcess_FlipUVs -| aiProcess_FlipWindingOrder -//| aiProcess_TransformUVCoords -//| aiProcess_FixInfacingNormals -| aiProcess_JoinIdenticalVertices -| aiProcess_GenSmoothNormals; - -Model ModelLoader::LoadModel(const std::string & modelPath, Scene* pScene) -{ - assert(mpRenderer); - const std::string fullPath = sRootFolderModels + modelPath; - const std::string modelDirectory = DirectoryUtil::GetFolderPath(fullPath); - const std::string modelName = DirectoryUtil::GetFileNameWithoutExtension(fullPath); - - // CHECK CACHE FIRST - don't load the same model more than once - // - if (mLoadedModels.find(fullPath) != mLoadedModels.end()) - { - return mLoadedModels.at(fullPath); - } - - - PerfTimer t; - t.Start(); - - Log::Info("Loading Model: %s ...", modelName.c_str()); - - // IMPORT SCENE - // - Importer importer; - const aiScene* scene = importer.ReadFile(fullPath, ASSIMP_LOAD_FLAGS); - if (!scene || scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode) - { - Log::Error("Assimp error: %s", importer.GetErrorString()); - return Model(); - } - Model::Data data = ProcessNode(scene->mRootNode, scene, modelDirectory, mpRenderer, pScene); - - // cache the model - const Model model = Model(modelDirectory, modelName, std::move(data)); - mLoadedModels[fullPath] = model; - - // register scene and the model loaded - if (mSceneModels.find(pScene) == mSceneModels.end()) // THIS BEGS FOR TEMPLATE PROGRAMMING - { // first - mSceneModels[pScene] = std::vector { fullPath }; - } - else - { - mSceneModels.at(pScene).push_back(fullPath); - } - t.Stop(); - Log::Info("Loaded Model '%s' in %.2f seconds.", modelName.c_str(), t.DeltaTime()); - return model; -} - - -Model ModelLoader::LoadModel_Async(const std::string& modelPath, Scene* pScene) -{ - assert(mpRenderer); - const std::string fullPath = sRootFolderModels + modelPath; - const std::string modelDirectory = DirectoryUtil::GetFolderPath(fullPath); - const std::string modelName = DirectoryUtil::GetFileNameWithoutExtension(fullPath); - - // CHECK CACHE FIRST - don't load the same model more than once - // - { - std::unique_lock l(mLoadedModelMutex); - if (mLoadedModels.find(fullPath) != mLoadedModels.end()) - { - return mLoadedModels.at(fullPath); - } - } - - PerfTimer t; - t.Start(); - - //Log::Info("Loading Model: %s ...", modelName.c_str()); - - // IMPORT SCENE - // - Importer importer; - const aiScene* scene = importer.ReadFile(fullPath, ASSIMP_LOAD_FLAGS); - if (!scene || scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode) - { - Log::Error("Assimp error: %s", importer.GetErrorString()); - return Model(); - } - Model::Data data = ProcessNode(scene->mRootNode, scene, modelDirectory, mpRenderer, pScene); - - // cache the model - const Model model = Model(modelDirectory, modelName, std::move(data)); - { - std::unique_lock l(mLoadedModelMutex); - mLoadedModels[fullPath] = model; - } - - // register scene and the model loaded - { - std::unique_lock l(mSceneModelsMutex); - if (mSceneModels.find(pScene) == mSceneModels.end()) // THIS BEGS FOR TEMPLATE PROGRAMMING - { // first - mSceneModels[pScene] = std::vector{ fullPath }; - } - else - { - mSceneModels.at(pScene).push_back(fullPath); - } - } - - t.Stop(); - //Log::Info("Loaded Model '%s' in %.2f seconds.", modelName.c_str(), t.DeltaTime()); - return model; -} - -void ModelLoader::UnloadSceneModels(Scene * pScene) -{ - if (mSceneModels.find(pScene) == mSceneModels.end()) return; - for (std::string& modelDirectory : mSceneModels.at(pScene)) - { - mLoadedModels.erase(modelDirectory); - } + assert(false); + return false; } -#endif \ No newline at end of file diff --git a/Source/Application/Model.h b/Source/Application/Model.h index 4f5265aa..97852bfc 100644 --- a/Source/Application/Model.h +++ b/Source/Application/Model.h @@ -17,23 +17,12 @@ // Contact: volkanilbeyli@gmail.com #pragma once -//#include "Material.h" // TODO -#include "Mesh.h" #include "Types.h" -#include #include -#include - -#include +#include -struct aiScene; -struct aiNode; -struct aiMesh; -struct aiMaterial; class VQRenderer; -// class GameObject; // TODO -// class Scene; // TODO struct MeshRenderSettings { @@ -60,7 +49,8 @@ struct Model public: struct Data { - std::vector mMeshIDs; + std::vector mOpaueMeshIDs; + std::vector mTransparentMeshIDs; MeshMaterialLookup_t mOpaqueMaterials; MeshMaterialLookup_t mTransparentMaterials; inline bool HasMaterial() const { return !mOpaqueMaterials.empty() || !mTransparentMaterials.empty(); } diff --git a/Source/Application/Scene.cpp b/Source/Application/Scene.cpp index e63d7e71..b8172e3c 100644 --- a/Source/Application/Scene.cpp +++ b/Source/Application/Scene.cpp @@ -22,9 +22,78 @@ #include "Window.h" #include "VQEngine.h" +#define LOG_CACHED_RESOURCES_ON_LOAD 0 +#define LOG_RESOURCE_CREATE 1 + using namespace DirectX; -Scene::Scene(VQEngine& engine, int NumFrameBuffers, const Input& input, const std::unique_ptr& pWin) +static ModelID LAST_USED_MESH_ID = 0; + +//MeshID Scene::CreateMesh() +//{ +// ModelID id = LAST_USED_MESH_ID++; +// +// mMeshes[id] = Mesh(); +// return id; +//} + +MeshID Scene::AddMesh(Mesh&& mesh) +{ + std::lock_guard lk(mMtx_Meshes); + MeshID id = LAST_USED_MESH_ID++; + mMeshes[id] = mesh; + return id; +} + +ModelID Scene::CreateModel() +{ + std::unique_lock lk(mMtx_Models); + static ModelID LAST_USED_MODEL_ID = 0; + ModelID id = LAST_USED_MODEL_ID++; + mModels[id] = Model(); + return id; +} + +MaterialID Scene::CreateMaterial(const std::string& UniqueMaterialName) +{ + auto it = mLoadedMaterials.find(UniqueMaterialName); + if (it != mLoadedMaterials.end()) + { +#if LOG_CACHED_RESOURCES_ON_LOAD + Log::Info("Material already loaded: %s", UniqueMaterialName.c_str()); +#endif + return it->second; + } + + static MaterialID LAST_USED_MATERIAL_ID = 0; + MaterialID id = INVALID_ID; + // critical section + { + std::unique_lock lk(mMtx_Materials); + id = LAST_USED_MATERIAL_ID++; + } + mMaterials[id] = Material(); + mLoadedMaterials[UniqueMaterialName] = id; +#if LOG_RESOURCE_CREATE + Log::Info("Scene::CreateMaterial(): %s", UniqueMaterialName.c_str()); +#endif + return id; +} + +Material& Scene::GetMaterial(MaterialID ID) +{ + // TODO: err handle + return mMaterials.at(ID); +} + +Model& Scene::GetModel(ModelID id) +{ + // TODO: err handle + return mModels.at(id); +} + + +Scene::Scene(VQEngine& engine, int NumFrameBuffers, const Input& input, const std::unique_ptr& pWin, VQRenderer& renderer) : mInput(input) , mpWindow(pWin) , mEngine(engine) @@ -35,6 +104,7 @@ Scene::Scene(VQEngine& engine, int NumFrameBuffers, const Input& input, const st , mTransformPool(NUM_GAMEOBJECT_POOL_SIZE, GAMEOBJECT_BYTE_ALIGNMENT) , mResourceNames(engine.GetResourceNames()) , mAssetLoader(engine.GetAssetLoader()) + , mRenderer(renderer) {} void Scene::Update(float dt, int FRAME_DATA_INDEX) @@ -72,7 +142,7 @@ void Scene::PostUpdate(int FRAME_DATA_INDEX, int FRAME_DATA_NEXT_INDEX) { const XMMATRIX matWorldTransform = mpTransforms.at(pObj->mTransformID)->WorldTransformationMatrix(); - for (const MeshID id : mEngine.GetModel(pObj->mModelID).mData.mMeshIDs) + for (const MeshID id : mModels.at(pObj->mModelID).mData.mOpaueMeshIDs) { FMeshRenderCommand meshRenderCmd; meshRenderCmd.meshID = id; @@ -102,14 +172,14 @@ void Scene::StartLoading(FSceneRepresentation& scene) const bool bModelIsBuiltinMesh = !ObjRep.BuiltinMeshName.empty(); const bool bModelIsLoadedFromFile = !ObjRep.ModelFilePath.empty(); assert(bModelIsBuiltinMesh != bModelIsLoadedFromFile); - ModelID mID = mEngine.CreateModel(); - Model& model = mEngine.GetModel(mID); + ModelID mID = this->CreateModel(); + Model& model = mModels.at(mID); if (bModelIsBuiltinMesh) { // create/get mesh MeshID meshID = mEngine.GetBuiltInMeshID(ObjRep.BuiltinMeshName); - model.mData.mMeshIDs.push_back(meshID); + model.mData.mOpaueMeshIDs.push_back(meshID); // TODO: material @@ -120,7 +190,7 @@ void Scene::StartLoading(FSceneRepresentation& scene) model.mbLoaded = false; model.mModelName = ObjRep.ModelName; model.mModelPath = ObjRep.ModelFilePath; - mAssetLoader.QueueAssetLoad(model.mModelPath); + mAssetLoader.QueueModelLoad(model.mModelPath, model.mModelName); } @@ -144,7 +214,8 @@ void Scene::StartLoading(FSceneRepresentation& scene) // dispatch workers assert(false); // TODO } - mAssetLoader.StartLoadingAssets(); + + std::vector> vModelLoadResults = mAssetLoader.StartLoadingModels(this); // CAMERAS for (FCameraParameters& param : scene.Cameras) diff --git a/Source/Application/Scene.h b/Source/Application/Scene.h index 48b09456..e089cd2c 100644 --- a/Source/Application/Scene.h +++ b/Source/Application/Scene.h @@ -19,6 +19,7 @@ #include "Camera.h" #include "Mesh.h" +#include "Material.h" #include "Model.h" #include "Light.h" #include "Transform.h" @@ -27,6 +28,7 @@ class Input; class AssetLoader; +struct Material; struct FResourceNames; //------------------------------------------------------ @@ -139,7 +141,13 @@ class Scene // ENGINE INTERFACE //---------------------------------------------------------------------------------------------------------------- public: - Scene(VQEngine& engine, int NumFrameBuffers, const Input& input, const std::unique_ptr& pWin); + Scene( + VQEngine& engine + , int NumFrameBuffers + , const Input& input + , const std::unique_ptr& pWin + , VQRenderer& renderer + ); private: // Derived Scenes shouldn't access these functions void Update(float dt, int FRAME_DATA_INDEX); @@ -157,19 +165,37 @@ class Scene inline const Camera& GetActiveCamera() const { return mCameras[mIndex_SelectedCamera]; } inline Camera& GetActiveCamera() { return mCameras[mIndex_SelectedCamera]; } + // Mesh, Model, GameObj management //TransformID CreateTransform(Transform** ppTransform); //GameObject* CreateObject(TransformID tfID, ModelID modelID); + //MeshID CreateMesh(); + MeshID AddMesh(Mesh&& mesh); + ModelID CreateModel(); + MaterialID CreateMaterial(const std::string& UniqueMaterialName); + + Material& GetMaterial(MaterialID ID); + Model& GetModel(ModelID); //---------------------------------------------------------------------------------------------------------------- // SCENE DATA //---------------------------------------------------------------------------------------------------------------- protected: + using MeshLookup_t = std::unordered_map; + using ModelLookup_t = std::unordered_map; + using MaterialLookup_t = std::unordered_map; + //-------------------------------------------------------------- + + // + // SCENE VIEWS + // std::vector mFrameSceneViews; // // SCENE RESOURCE CONTAINERS // - //std::vector mMeshIDs; + MeshLookup_t mMeshes; + ModelLookup_t mModels; + MaterialLookup_t mMaterials; std::vector mpObjects; std::vector mpTransforms; std::vector mCameras; @@ -204,8 +230,10 @@ class Scene VQEngine& mEngine; const FResourceNames& mResourceNames; AssetLoader& mAssetLoader; + VQRenderer& mRenderer; FSceneRepresentation mSceneRepresentation; + //---------------------------------------------------------------------------------------------------------------- // INTERNAL DATA //---------------------------------------------------------------------------------------------------------------- @@ -213,6 +241,12 @@ class Scene MemoryPool mGameObjectPool; MemoryPool mTransformPool; + std::mutex mMtx_Meshes; + std::mutex mMtx_Models; + std::mutex mMtx_Materials; + + std::unordered_map mLoadedMaterials; + //CPUProfiler* mpCPUProfiler; //ModelLoader mModelLoader; //MaterialPool mMaterials; diff --git a/Source/Application/VQEngine.h b/Source/Application/VQEngine.h index f7f2fbe8..4c94a45a 100644 --- a/Source/Application/VQEngine.h +++ b/Source/Application/VQEngine.h @@ -230,14 +230,9 @@ class VQEngine : public IWindowOwner void UnloadEnvironmentMap(); - // Mesh & Model management - ModelID CreateModel(); - // Getters MeshID GetBuiltInMeshID(const std::string& MeshName) const; - Model& GetModel(ModelID id); - const Model& GetModel(ModelID id) const; inline const FResourceNames& GetResourceNames() const { return mResourceNames; } inline AssetLoader& GetAssetLoader() { return mAssetLoader; } @@ -246,8 +241,6 @@ class VQEngine : public IWindowOwner private: //------------------------------------------------------------------------------------------------- using BuiltinMeshArray_t = std::array; - using MeshLookup_t = std::unordered_map; - using ModelLookup_t = std::unordered_map; using EnvironmentMapDescLookup_t = std::unordered_map; //------------------------------------------------------------------------------------------------- using EventPtr_t = std::shared_ptr; @@ -294,8 +287,6 @@ class VQEngine : public IWindowOwner // data: geometry BuiltinMeshArray_t mBuiltinMeshes; - MeshLookup_t mMeshes; - ModelLookup_t mModels; // contains MeshIDs and MaterialIDs // data: environment maps & HDR profiles std::vector mDisplayHDRProfiles; diff --git a/Source/Application/VQEngine_Main.cpp b/Source/Application/VQEngine_Main.cpp index 3213d956..5e5f90ea 100644 --- a/Source/Application/VQEngine_Main.cpp +++ b/Source/Application/VQEngine_Main.cpp @@ -37,7 +37,7 @@ void ReportSystemInfo(const VQSystemInfo::FSystemInfo& i, bool bDetailed = false } #endif VQEngine::VQEngine() - : mAssetLoader(mWorkers_Load) + : mAssetLoader(mWorkers_Load, mRenderer) {} void VQEngine::MainThread_Tick() @@ -292,11 +292,11 @@ void VQEngine::InitializeThreads() mpSemRender.reset(new Semaphore(0 , NUM_SWAPCHAIN_BACKBUFFERS)); mbStopAllThreads.store(false); - mWorkers_Load.Initialize(NumWorkers); + mWorkers_Load.Initialize(NumWorkers, "LoadWorkers"); mRenderThread = std::thread(&VQEngine::RenderThread_Main, this); mUpdateThread = std::thread(&VQEngine::UpdateThread_Main, this); - mWorkers_Update.Initialize(NumWorkers); - mWorkers_Render.Initialize(NumWorkers); + mWorkers_Update.Initialize(NumWorkers, "UpdateWorkers"); + mWorkers_Render.Initialize(NumWorkers, "RenderWorkers"); } void VQEngine::ExitThreads() diff --git a/Source/Application/VQEngine_Update.cpp b/Source/Application/VQEngine_Update.cpp index 30112c0d..c9652917 100644 --- a/Source/Application/VQEngine_Update.cpp +++ b/Source/Application/VQEngine_Update.cpp @@ -358,18 +358,6 @@ MeshID VQEngine::GetBuiltInMeshID(const std::string& MeshName) const return static_cast(it - mResourceNames.mBuiltinMeshNames.begin()); } -Model& VQEngine::GetModel(ModelID id) -{ - // TODO: err msg - return mModels.at(id); -} - -const Model& VQEngine::GetModel(ModelID id) const -{ - // TODO: err msg - return mModels.at(id); -} - void VQEngine::StartLoadingEnvironmentMap(int IndexEnvMap) { this->WaitUntilRenderingFinishes(); @@ -416,14 +404,6 @@ void VQEngine::WaitUntilRenderingFinishes() while (mNumRenderLoopsExecuted != mNumUpdateLoopsExecuted); } -ModelID VQEngine::CreateModel() -{ - static ModelID LAST_USED_MODEL_ID = 0; - ModelID id = LAST_USED_MODEL_ID++; - mModels[id] = Model(); - return id; -} - const FEnvironmentMapDescriptor& VQEngine::GetEnvironmentMapDesc(const std::string& EnvMapName) const { static const FEnvironmentMapDescriptor DEFAULT_ENV_MAP_DESC = { "ENV_MAP_NOT_FOUND", "", 0.0f }; @@ -476,10 +456,10 @@ void VQEngine::Load_SceneData_Dispatch() auto fnCreateSceneInstance = [&](const std::string& SceneType, std::unique_ptr& pScene) -> void { - if (SceneType == "Default") pScene = std::make_unique(*this, NUM_SWAPCHAIN_BACKBUFFERS, input, mpWinMain); - else if (SceneType == "Sponza") pScene = std::make_unique(*this, NUM_SWAPCHAIN_BACKBUFFERS, input, mpWinMain); - else if (SceneType == "StressTest") pScene = std::make_unique(*this, NUM_SWAPCHAIN_BACKBUFFERS, input, mpWinMain); - else if (SceneType == "GeometryUnitTest") pScene = std::make_unique(*this, NUM_SWAPCHAIN_BACKBUFFERS, input, mpWinMain); + if (SceneType == "Default") pScene = std::make_unique(*this, NUM_SWAPCHAIN_BACKBUFFERS, input, mpWinMain, mRenderer); + else if (SceneType == "Sponza") pScene = std::make_unique(*this, NUM_SWAPCHAIN_BACKBUFFERS, input, mpWinMain, mRenderer); + else if (SceneType == "StressTest") pScene = std::make_unique(*this, NUM_SWAPCHAIN_BACKBUFFERS, input, mpWinMain, mRenderer); + else if (SceneType == "GeometryUnitTest") pScene = std::make_unique(*this, NUM_SWAPCHAIN_BACKBUFFERS, input, mpWinMain, mRenderer); }; if (mpScene) diff --git a/Source/Renderer/Renderer.h b/Source/Renderer/Renderer.h index de92fa28..d4a98d0a 100644 --- a/Source/Renderer/Renderer.h +++ b/Source/Renderer/Renderer.h @@ -177,6 +177,7 @@ class VQRenderer StaticBufferHeap mStaticHeap_IndexBuffer; // resources & views + std::unordered_map mLoadedTexturePaths; std::unordered_map mTextures; std::unordered_map mSamplers; std::unordered_map mVBVs; @@ -197,6 +198,8 @@ class VQRenderer mutable std::mutex mMtxVBVs; mutable std::mutex mMtxIBVs; + mutable std::mutex mMtxUploadHeapCreation; + // root signatures std::vector mpBuiltinRootSignatures; diff --git a/Source/Renderer/Renderer_Resources.cpp b/Source/Renderer/Renderer_Resources.cpp index dada5721..b7d75ebe 100644 --- a/Source/Renderer/Renderer_Resources.cpp +++ b/Source/Renderer/Renderer_Resources.cpp @@ -39,6 +39,8 @@ using namespace VQSystemInfo; #define ENABLE_DEBUG_LAYER 0 #define ENABLE_VALIDATION_LAYER 0 #endif +#define LOG_CACHED_RESOURCES_ON_LOAD 0 +#define LOG_RESOURCE_CREATE 1 // TODO: initialize from functions? static TextureID LAST_USED_TEXTURE_ID = 0; @@ -72,7 +74,16 @@ BufferID VQRenderer::CreateBuffer(const FBufferDesc& desc) TextureID VQRenderer::CreateTextureFromFile(const char* pFilePath) { - // TODO: check if file already loaded + // check if we've already loaded the texture + auto it = mLoadedTexturePaths.find(pFilePath); + if (it != mLoadedTexturePaths.end()) + { +#if LOG_CACHED_RESOURCES_ON_LOAD + Log::Info("Texture already loaded: %s", pFilePath); +#endif + return it->second; + } + Texture tex; @@ -81,8 +92,10 @@ TextureID VQRenderer::CreateTextureFromFile(const char* pFilePath) // It's recommended to create heaps on background threads to avoid glitching the render // thread. In D3D12, multiple threads may safely call create routines concurrently. UploadHeap uploadHeap; - uploadHeap.Create(mDevice.GetDevicePtr(), 1024 * MEGABYTE); // TODO: drive the heapsize through RendererSettings.ini - + { + std::unique_lock lk(mMtxUploadHeapCreation); + uploadHeap.Create(mDevice.GetDevicePtr(), 1024 * MEGABYTE); // TODO: drive the heapsize through RendererSettings.ini + } const std::string FileNameAndExtension = DirectoryUtil::GetFileNameFromPath(pFilePath); TextureCreateDesc tDesc(FileNameAndExtension); tDesc.pAllocator = mpAllocator; @@ -96,6 +109,10 @@ TextureID VQRenderer::CreateTextureFromFile(const char* pFilePath) { uploadHeap.UploadToGPUAndWait(mGFXQueue.pQueue); ID = AddTexture_ThreadSafe(std::move(tex)); + mLoadedTexturePaths[std::string(pFilePath)] = ID; +#if LOG_RESOURCE_CREATE + Log::Info("VQRenderer::CreateTextureFromFile(): %s", pFilePath); +#endif } uploadHeap.Destroy(); return ID; @@ -348,6 +365,7 @@ TextureID VQRenderer::AddTexture_ThreadSafe(Texture&& tex) std::lock_guard lk(mMtxTextures); Id = LAST_USED_TEXTURE_ID++; mTextures[Id] = tex; + return Id; } void VQRenderer::DestroyTexture(TextureID texID) diff --git a/Source/Renderer/SwapChain.cpp b/Source/Renderer/SwapChain.cpp index 7948ea27..4f98d4d7 100644 --- a/Source/Renderer/SwapChain.cpp +++ b/Source/Renderer/SwapChain.cpp @@ -520,7 +520,7 @@ void SwapChain::MoveToNextFrame() Log::Warning("SwapChain : next frame not ready. FenceComplVal=%d < FenceVal[curr]=%d", fenceComplVal, mFenceValues[mICurrentBackBuffer]); #endif ThrowIfFailed(mpFence->SetEventOnCompletion(mFenceValues[mICurrentBackBuffer], mHEvent)); - hr = WaitForSingleObjectEx(mHEvent, 200, FALSE); + hr = WaitForSingleObjectEx(mHEvent, 800, FALSE); } switch (hr) { diff --git a/Source/Scenes/Scenes.h b/Source/Scenes/Scenes.h index 8d4b2e52..75bd579f 100644 --- a/Source/Scenes/Scenes.h +++ b/Source/Scenes/Scenes.h @@ -20,8 +20,9 @@ public:\ , int NumFrameBuffers\ , const Input& input\ , const std::unique_ptr& pWin\ + , VQRenderer& renderer\ )\ - : Scene(engine, NumFrameBuffers, input, pWin)\ + : Scene(engine, NumFrameBuffers, input, pWin, renderer)\ {}\ From 909cf2f0985151d1971c8e5f4f0f339527b7099a Mon Sep 17 00:00:00 2001 From: Volkan Date: Fri, 21 Aug 2020 02:47:40 -0700 Subject: [PATCH 19/67] Asset Loader: sync texture loads and assign material textures properly --- Source/Application/AssetLoader.cpp | 157 ++++++++++++++++--------- Source/Application/AssetLoader.h | 29 ++++- Source/Renderer/Renderer_Resources.cpp | 2 +- 3 files changed, 128 insertions(+), 60 deletions(-) diff --git a/Source/Application/AssetLoader.cpp b/Source/Application/AssetLoader.cpp index deab04d5..a949d149 100644 --- a/Source/Application/AssetLoader.cpp +++ b/Source/Application/AssetLoader.cpp @@ -39,11 +39,11 @@ using namespace DirectX; struct FMaterialTextureAssignments { MaterialID matID; - AssetLoader::TextureLoadResults_t DiffuseIDs; - AssetLoader::TextureLoadResults_t SpecularIDs; - AssetLoader::TextureLoadResults_t NormalsIDs; - AssetLoader::TextureLoadResults_t HeightMapIDs; - AssetLoader::TextureLoadResults_t AlphaMapIDs; + std::vector DiffuseIDs; + std::vector SpecularIDs; + std::vector NormalsIDs; + std::vector HeightMapIDs; + std::vector AlphaMapIDs; }; Model::Data ProcessAssimpNode( @@ -96,38 +96,48 @@ ModelID AssetLoader::ImportModel_obj(Scene* pScene, AssetLoader* pAssetLoader, V std::vector MaterialTextureAssignments; Model::Data data = ProcessAssimpNode(pAiScene->mRootNode, pAiScene, modelDirectory, pAssetLoader, pScene, pRenderer, MaterialTextureAssignments); - std::vector> v = pAssetLoader->StartLoadingTextures(); + TextureLoadResults_t vTexLoadResults = pAssetLoader->StartLoadingTextures(); // cache the imported model in Scene ModelID mID = pScene->CreateModel(); Model& model = pScene->GetModel(mID); model = Model(objFilePath, ModelName, std::move(data)); + // SYNC POINT - wait for textures to load + for (auto it = vTexLoadResults.begin(); it != vTexLoadResults.end(); ++it) + { + const MaterialID& matID = it->first; + const TextureLoadResult_t& result = it->second; + assert(result.texLoadResult.valid()); + result.texLoadResult.wait(); + } + // wait for textures to be loaded and assign TextureIDs; for (FMaterialTextureAssignments& assignment : MaterialTextureAssignments) { Material& mat = pScene->GetMaterial(assignment.matID); - auto fnAssignTextureIDs = [](MaterialID matID, const std::string& strTexType, std::vector>& textures, TextureID& textureMapID) + auto pair_itBeginEnd = vTexLoadResults.equal_range(assignment.matID); + for (auto it = pair_itBeginEnd.first; it != pair_itBeginEnd.second; ++it) { - if (textures.size() > 1) - { - Log::Warning("More than 1 %s in MaterialID=%d, will only use the first texture.", strTexType.c_str(), matID); - } - for (std::future& texIDs : textures) + const MaterialID& matID = it->first; + TextureLoadResult_t& result = it->second; + + switch (result.type) { - assert(texIDs.valid()); - texIDs.wait(); - textureMapID = texIDs.get(); - break; // TODO: currently only 1 diffuse map supported (no texture blending) + case DIFFUSE : mat.diffuseMap = result.texLoadResult.get(); break; + case NORMALS : mat.normalMap = result.texLoadResult.get(); break; + case SPECULAR : mat.specularMap = result.texLoadResult.get(); break; + case ALPHA_MASK: mat.mask = result.texLoadResult.get(); break; + case EMISSIVE : mat.emissiveMap = result.texLoadResult.get(); break; + case HEIGHT : mat.heightMap = result.texLoadResult.get(); break; + case METALNESS : mat.metallicMap = result.texLoadResult.get(); break; + case ROUGHNESS : mat.roughnessMap = result.texLoadResult.get(); break; + default: + Log::Warning("TODO"); + break; } - }; - - fnAssignTextureIDs(assignment.matID, "Diffuse Map" , assignment.DiffuseIDs , mat.diffuseMap); - fnAssignTextureIDs(assignment.matID, "Specular Map" , assignment.SpecularIDs , mat.specularMap); - fnAssignTextureIDs(assignment.matID, "Normal Map" , assignment.NormalsIDs , mat.normalMap); - fnAssignTextureIDs(assignment.matID, "HeightMap Map", assignment.HeightMapIDs, mat.heightMap); - fnAssignTextureIDs(assignment.matID, "Alpha Map" , assignment.AlphaMapIDs , mat.mask); + } } t.Stop(); @@ -203,15 +213,14 @@ void AssetLoader::QueueTextureLoad(const FTextureLoadParams& TexLoadParam) mTextureLoadQueue.push(TexLoadParam); } -std::vector> AssetLoader::StartLoadingTextures() +AssetLoader::TextureLoadResults_t AssetLoader::StartLoadingTextures() { - std::vector> TextureLoadResults; + TextureLoadResults_t TextureLoadResults; if (mTextureLoadQueue.empty()) { Log::Warning("AssetLoader::StartLoadingTextures(): no Textures to load"); return TextureLoadResults; } - // process model load queue std::unique_lock lk(mMtxQueue_ModelLoad); @@ -225,21 +234,60 @@ std::vector> AssetLoader::StartLoadingTextures() { mUniqueTexturePaths.insert(TexLoadParams.TexturePath); - std::future loadResult = mWorkers.AddTask([this, TexLoadParams]() + std::future texLoadResult = std::move(mWorkers.AddTask([this, TexLoadParams]() { return mRenderer.CreateTextureFromFile(TexLoadParams.TexturePath.c_str()); - }); - TextureLoadResults.push_back(std::move(loadResult)); + })); + TextureLoadResults.emplace(std::make_pair(TexLoadParams.MatID, TextureLoadResult_t{ TexLoadParams.TexType, std::move(texLoadResult) })); } } while (!mTextureLoadQueue.empty()); mUniqueTexturePaths.clear(); - return TextureLoadResults; + return std::move(TextureLoadResults); } +static AssetLoader::ETextureType GetTextureType(aiTextureType aiType) +{ + switch (aiType) + { + case aiTextureType_NONE: return AssetLoader::ETextureType::NUM_TEXTURE_TYPES; break; + case aiTextureType_DIFFUSE: return AssetLoader::ETextureType::DIFFUSE; break; + case aiTextureType_SPECULAR: return AssetLoader::ETextureType::SPECULAR; break; + case aiTextureType_EMISSIVE: return AssetLoader::ETextureType::EMISSIVE; break; + case aiTextureType_HEIGHT: return AssetLoader::ETextureType::HEIGHT; break; + case aiTextureType_NORMALS: return AssetLoader::ETextureType::NORMALS; break; + case aiTextureType_OPACITY: return AssetLoader::ETextureType::ALPHA_MASK; break; + case aiTextureType_METALNESS: return AssetLoader::ETextureType::METALNESS; break; + case aiTextureType_AMBIENT: break; + case aiTextureType_SHININESS: break; + case aiTextureType_DISPLACEMENT: + break; + case aiTextureType_LIGHTMAP: + break; + case aiTextureType_REFLECTION: + break; + case aiTextureType_BASE_COLOR: + break; + case aiTextureType_NORMAL_CAMERA: + break; + case aiTextureType_EMISSION_COLOR: + break; + case aiTextureType_DIFFUSE_ROUGHNESS: + break; + case aiTextureType_AMBIENT_OCCLUSION: + break; + case aiTextureType_UNKNOWN: + break; + case _aiTextureType_Force32Bit: + break; + default: + break; + } + return AssetLoader::ETextureType::NUM_TEXTURE_TYPES; +} //---------------------------------------------------------------------------------------------------------------- @@ -247,6 +295,7 @@ std::vector> AssetLoader::StartLoadingTextures() //---------------------------------------------------------------------------------------------------------------- static std::vector GenerateTextureLoadParams( aiMaterial* pMaterial + , MaterialID matID , aiTextureType type , const std::string& textureName , const std::string& modelDirectory @@ -260,6 +309,8 @@ static std::vector GenerateTextureLoadParams( std::string path = str.C_Str(); AssetLoader::FTextureLoadParams params = {}; params.TexturePath = modelDirectory + path; + params.MatID = matID; + params.TexType = GetTextureType(type); TexLoadParams.push_back(params); } return TexLoadParams; @@ -344,17 +395,30 @@ static Model::Data ProcessAssimpNode( // MATERIAL - http://assimp.sourceforge.net/lib_html/materials.html aiMaterial* material = pAiScene->mMaterials[pAiMesh->mMaterialIndex]; + // Every material assumed to have a name : Create material here + MaterialID matID = INVALID_ID; + aiString name; + if (aiReturn_SUCCESS == material->Get(AI_MATKEY_NAME, name)) + { + const std::string ModelFolderName = DirectoryUtil::GetFlattenedFolderHierarchy(modelDirectory).back(); + std::string uniqueMatName = name.C_Str(); + // modelDirectory = "Data/Models/%MODEL_NAME%/" + // Materials use the following unique naming: %MODEL_NAME%/%MATERIAL_NAME% + uniqueMatName = ModelFolderName + "/" + uniqueMatName; + matID = pScene->CreateMaterial(uniqueMatName); + } + // get texture paths to load FMaterialTextureAssignments MatAssignment = {}; - std::vector diffuseMaps = GenerateTextureLoadParams(material, aiTextureType_DIFFUSE, "texture_diffuse", modelDirectory); - std::vector specularMaps = GenerateTextureLoadParams(material, aiTextureType_SPECULAR, "texture_specular", modelDirectory); - std::vector normalMaps = GenerateTextureLoadParams(material, aiTextureType_NORMALS, "texture_normal", modelDirectory); - std::vector heightMaps = GenerateTextureLoadParams(material, aiTextureType_HEIGHT, "texture_height", modelDirectory); - std::vector alphaMaps = GenerateTextureLoadParams(material, aiTextureType_OPACITY, "texture_alpha", modelDirectory); + std::vector diffuseMaps = GenerateTextureLoadParams(material, matID, aiTextureType_DIFFUSE, "texture_diffuse", modelDirectory); + std::vector specularMaps = GenerateTextureLoadParams(material, matID, aiTextureType_SPECULAR, "texture_specular", modelDirectory); + std::vector normalMaps = GenerateTextureLoadParams(material, matID, aiTextureType_NORMALS, "texture_normal", modelDirectory); + std::vector heightMaps = GenerateTextureLoadParams(material, matID, aiTextureType_HEIGHT, "texture_height", modelDirectory); + std::vector alphaMaps = GenerateTextureLoadParams(material, matID, aiTextureType_OPACITY, "texture_alpha", modelDirectory); - // start loading textures + // queue texture load std::array TexLoadParams = { &diffuseMaps, &specularMaps, &normalMaps, &heightMaps, &alphaMaps }; - std::array TexAssignParams = + std::array*, 5> TexAssignParams = { &MatAssignment.DiffuseIDs , &MatAssignment.SpecularIDs @@ -372,28 +436,9 @@ static Model::Data ProcessAssimpNode( pAssetLoader->QueueTextureLoad(param); ++iTex; } - - // kick off texture load workers only if we have at least 1 texture - if (iTex > 0) - { - //*TexAssignParams[iTexType] = std::move(pAssetLoader->StartLoadingTextures()); - } - ++iTexType; } - // Every material assumed to have a name : Create material here - MaterialID matID = INVALID_ID; - aiString name; - if (aiReturn_SUCCESS == material->Get(AI_MATKEY_NAME, name)) - { - const std::string ModelFolderName = DirectoryUtil::GetFlattenedFolderHierarchy(modelDirectory).back(); - std::string uniqueMatName = name.C_Str(); - // modelDirectory = "Data/Models/%MODEL_NAME%/" - // Materials use the following unique naming: %MODEL_NAME%/%MATERIAL_NAME% - uniqueMatName = ModelFolderName + "/" + uniqueMatName; - matID = pScene->CreateMaterial(uniqueMatName); - } // unflatten the material texture assignments MatAssignment.matID = matID; diff --git a/Source/Application/AssetLoader.h b/Source/Application/AssetLoader.h index d90316f5..ae70ae0e 100644 --- a/Source/Application/AssetLoader.h +++ b/Source/Application/AssetLoader.h @@ -30,19 +30,42 @@ class Scene; class AssetLoader { public: + enum ETextureType + { + DIFFUSE = 0, + NORMALS, + SPECULAR, + ALPHA_MASK, + EMISSIVE, + HEIGHT, + METALNESS, + ROUGHNESS, + + NUM_TEXTURE_TYPES + }; struct FModelLoadParams { using pfnImportModel_t = ModelID(*)(Scene* pScene, AssetLoader* pAssetLoader, VQRenderer* pRenderer, const std::string& objFilePath, std::string ModelName); + std::string ModelPath; std::string ModelName; pfnImportModel_t pfnImportModel; }; struct FTextureLoadParams { - std::string TexturePath; + ETextureType TexType; + MaterialID MatID; + std::string TexturePath; + }; + struct FTextureLoadResult + { + ETextureType type; + std::future texLoadResult; }; - using ModelLoadResults_t = std::vector>; - using TextureLoadResults_t = std::vector>; + using ModelLoadResult_t = std::future; + using ModelLoadResults_t = std::vector; + using TextureLoadResult_t = FTextureLoadResult; + using TextureLoadResults_t = std::unordered_multimap; public: AssetLoader(ThreadPool& WorkerThreads, VQRenderer& renderer) : mWorkers(WorkerThreads) diff --git a/Source/Renderer/Renderer_Resources.cpp b/Source/Renderer/Renderer_Resources.cpp index b7d75ebe..6ee2c35b 100644 --- a/Source/Renderer/Renderer_Resources.cpp +++ b/Source/Renderer/Renderer_Resources.cpp @@ -114,7 +114,7 @@ TextureID VQRenderer::CreateTextureFromFile(const char* pFilePath) Log::Info("VQRenderer::CreateTextureFromFile(): %s", pFilePath); #endif } - uploadHeap.Destroy(); + uploadHeap.Destroy(); // this is VERY expensive, TODO: find another solution. return ID; } From 96ab9513602107f9fabc16d47e3e09c720cc42a6 Mon Sep 17 00:00:00 2001 From: Volkan Date: Fri, 21 Aug 2020 03:37:03 -0700 Subject: [PATCH 20/67] Fix thread race issue (update vs render) --- Source/Application/VQEngine_Main.cpp | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/Source/Application/VQEngine_Main.cpp b/Source/Application/VQEngine_Main.cpp index 5e5f90ea..0223b896 100644 --- a/Source/Application/VQEngine_Main.cpp +++ b/Source/Application/VQEngine_Main.cpp @@ -290,7 +290,8 @@ void VQEngine::InitializeThreads() mpSemUpdate.reset(new Semaphore(NUM_SWAPCHAIN_BACKBUFFERS, NUM_SWAPCHAIN_BACKBUFFERS)); mpSemRender.reset(new Semaphore(0 , NUM_SWAPCHAIN_BACKBUFFERS)); - + + mbRenderThreadInitialized.store(false); mbStopAllThreads.store(false); mWorkers_Load.Initialize(NumWorkers, "LoadWorkers"); mRenderThread = std::thread(&VQEngine::RenderThread_Main, this); From e2d8337b2d1e27b220ae92d1469e133e44d0162e Mon Sep 17 00:00:00 2001 From: Volkan Date: Fri, 21 Aug 2020 04:14:57 -0700 Subject: [PATCH 21/67] WIP: Asset Loading: fix std::future issues when get() is called multiple times, ModelID is now properly assigned to gameobject. --- Source/Application/AssetLoader.cpp | 27 +++++++++++-------- Source/Application/AssetLoader.h | 12 +++++---- Source/Application/Scene.cpp | 36 ++++++++++++++++++-------- Source/Application/VQEngine_Render.cpp | 4 ++- 4 files changed, 51 insertions(+), 28 deletions(-) diff --git a/Source/Application/AssetLoader.cpp b/Source/Application/AssetLoader.cpp index a949d149..80430716 100644 --- a/Source/Application/AssetLoader.cpp +++ b/Source/Application/AssetLoader.cpp @@ -104,15 +104,17 @@ ModelID AssetLoader::ImportModel_obj(Scene* pScene, AssetLoader* pAssetLoader, V model = Model(objFilePath, ModelName, std::move(data)); // SYNC POINT - wait for textures to load - for (auto it = vTexLoadResults.begin(); it != vTexLoadResults.end(); ++it) { - const MaterialID& matID = it->first; - const TextureLoadResult_t& result = it->second; - assert(result.texLoadResult.valid()); - result.texLoadResult.wait(); + for (auto it = vTexLoadResults.begin(); it != vTexLoadResults.end(); ++it) + { + const MaterialID& matID = it->first; + const TextureLoadResult_t& result = it->second; + assert(result.texLoadResult.valid()); + result.texLoadResult.wait(); + } } - // wait for textures to be loaded and assign TextureIDs; + // assign TextureIDs to the materials; for (FMaterialTextureAssignments& assignment : MaterialTextureAssignments) { Material& mat = pScene->GetMaterial(assignment.matID); @@ -123,6 +125,7 @@ ModelID AssetLoader::ImportModel_obj(Scene* pScene, AssetLoader* pAssetLoader, V const MaterialID& matID = it->first; TextureLoadResult_t& result = it->second; + assert(result.texLoadResult.valid()); switch (result.type) { case DIFFUSE : mat.diffuseMap = result.texLoadResult.get(); break; @@ -157,7 +160,7 @@ ModelID AssetLoader::ImportModel_gltf(Scene* pScene, AssetLoader* pAssetLoader, // ASSET LOADER //---------------------------------------------------------------------------------------------------------------- -void AssetLoader::QueueModelLoad(const std::string& ModelPath, const std::string& ModelName) +void AssetLoader::QueueModelLoad(GameObject* pObject, const std::string& ModelPath, const std::string& ModelName) { const std::string FileExtension = DirectoryUtil::GetFileExtension(ModelPath); @@ -168,7 +171,7 @@ void AssetLoader::QueueModelLoad(const std::string& ModelPath, const std::string }; std::unique_lock lk(mMtxQueue_ModelLoad); - mModelLoadQueue.push({ModelPath, ModelName, MODEL_IMPORT_FUNCTIONS.at(FileExtension)}); + mModelLoadQueue.push({pObject, ModelPath, ModelName, MODEL_IMPORT_FUNCTIONS.at(FileExtension)}); } AssetLoader::ModelLoadResults_t AssetLoader::StartLoadingModels(Scene* pScene) @@ -195,11 +198,13 @@ AssetLoader::ModelLoadResults_t AssetLoader::StartLoadingModels(Scene* pScene) mUniqueModelPaths.insert(ModelPath); // start loading - std::future modelLoadResult = mWorkers.AddTask([=]() + std::future modelLoadResult = std::move(mWorkers.AddTask([=]() { return ModelLoadParams.pfnImportModel(pScene, this, pRenderer, ModelLoadParams.ModelPath, ModelLoadParams.ModelName); - }); - ModelLoadResults.push_back(std::move(modelLoadResult)); + })); + + ModelLoadResults.emplace(std::make_pair(ModelLoadParams.pObject, std::move(modelLoadResult))); + //ModelLoadResults[ModelLoadParams.pObject] = std::move(modelLoadResult); } } while (!mModelLoadQueue.empty()); diff --git a/Source/Application/AssetLoader.h b/Source/Application/AssetLoader.h index ae70ae0e..df94034a 100644 --- a/Source/Application/AssetLoader.h +++ b/Source/Application/AssetLoader.h @@ -26,6 +26,7 @@ class ThreadPool; class Scene; +class GameObject; class AssetLoader { @@ -47,9 +48,10 @@ class AssetLoader { using pfnImportModel_t = ModelID(*)(Scene* pScene, AssetLoader* pAssetLoader, VQRenderer* pRenderer, const std::string& objFilePath, std::string ModelName); + GameObject* pObject = nullptr; std::string ModelPath; std::string ModelName; - pfnImportModel_t pfnImportModel; + pfnImportModel_t pfnImportModel = nullptr; }; struct FTextureLoadParams { @@ -60,10 +62,10 @@ class AssetLoader struct FTextureLoadResult { ETextureType type; - std::future texLoadResult; + std::shared_future texLoadResult; }; - using ModelLoadResult_t = std::future; - using ModelLoadResults_t = std::vector; + using ModelLoadResult_t = std::shared_future; + using ModelLoadResults_t = std::unordered_map; using TextureLoadResult_t = FTextureLoadResult; using TextureLoadResults_t = std::unordered_multimap; public: @@ -72,7 +74,7 @@ class AssetLoader , mRenderer(renderer) {} - void QueueModelLoad(const std::string& ModelPath, const std::string& ModelName); + void QueueModelLoad(GameObject* pObject, const std::string& ModelPath, const std::string& ModelName); ModelLoadResults_t StartLoadingModels(Scene* pScene); void QueueTextureLoad(const FTextureLoadParams& TexLoadParam); diff --git a/Source/Application/Scene.cpp b/Source/Application/Scene.cpp index b8172e3c..b84d4ed1 100644 --- a/Source/Application/Scene.cpp +++ b/Source/Application/Scene.cpp @@ -161,22 +161,29 @@ void Scene::StartLoading(FSceneRepresentation& scene) auto fnDeserializeGameObject = [&](GameObjectRepresentation& ObjRep) { + // GameObject + GameObject* pObj = mGameObjectPool.Allocate(1); + pObj->mModelID = INVALID_ID; + pObj->mTransformID = INVALID_ID; + // Transform Transform* pTransform = mTransformPool.Allocate(1); *pTransform = std::move(ObjRep.tf); mpTransforms.push_back(pTransform); TransformID tID = static_cast(mpTransforms.size() - 1); + pObj->mTransformID = tID; // Model const bool bModelIsBuiltinMesh = !ObjRep.BuiltinMeshName.empty(); const bool bModelIsLoadedFromFile = !ObjRep.ModelFilePath.empty(); assert(bModelIsBuiltinMesh != bModelIsLoadedFromFile); - ModelID mID = this->CreateModel(); - Model& model = mModels.at(mID); if (bModelIsBuiltinMesh) { + ModelID mID = this->CreateModel(); + Model& model = mModels.at(mID); + // create/get mesh MeshID meshID = mEngine.GetBuiltInMeshID(ObjRep.BuiltinMeshName); model.mData.mOpaueMeshIDs.push_back(meshID); @@ -184,20 +191,14 @@ void Scene::StartLoading(FSceneRepresentation& scene) // TODO: material model.mbLoaded = true; + pObj->mModelID = mID; } else { - model.mbLoaded = false; - model.mModelName = ObjRep.ModelName; - model.mModelPath = ObjRep.ModelFilePath; - mAssetLoader.QueueModelLoad(model.mModelPath, model.mModelName); + mAssetLoader.QueueModelLoad(pObj, ObjRep.ModelFilePath, ObjRep.ModelName); } - // GameObject - GameObject* pObj = mGameObjectPool.Allocate(1); - pObj->mTransformID = tID; - pObj->mModelID = mID; mpObjects.push_back(pObj); }; @@ -215,7 +216,20 @@ void Scene::StartLoading(FSceneRepresentation& scene) assert(false); // TODO } - std::vector> vModelLoadResults = mAssetLoader.StartLoadingModels(this); + AssetLoader::ModelLoadResults_t vModelLoadResults = mAssetLoader.StartLoadingModels(this); + + // TODO: serial model loading for now + { + for (auto it = vModelLoadResults.begin(); it != vModelLoadResults.end(); ++it) + { + GameObject* pObj = it->first; + AssetLoader::ModelLoadResult_t res = std::move(it->second); + + assert(res.valid()); + res.wait(); + pObj->mModelID = res.get(); + } + } // CAMERAS for (FCameraParameters& param : scene.Cameras) diff --git a/Source/Application/VQEngine_Render.cpp b/Source/Application/VQEngine_Render.cpp index 5d3f2bfd..57754b35 100644 --- a/Source/Application/VQEngine_Render.cpp +++ b/Source/Application/VQEngine_Render.cpp @@ -728,7 +728,9 @@ void VQEngine::RenderSceneColor(FWindowRenderContext& ctx, const FSceneView& Sce pCmd->SetGraphicsRootDescriptorTable(0, mRenderer.GetSRV(0).GetGPUDescHandle()); pCmd->SetGraphicsRootConstantBufferView(1, cbAddr); - const Mesh& mesh = mBuiltinMeshes[meshRenderCmd.meshID]; + assert(false); // TODO: not everything is builting mesh + const Mesh& mesh = mBuiltinMeshes[meshRenderCmd.meshID]; + const auto VBIBIDs = mesh.GetIABufferIDs(); const uint32 NumIndices = mesh.GetNumIndices(); const uint32 NumInstances = 1; From 10cbe8dfd2aaf4b4e9003693823326f91e9f75bc Mon Sep 17 00:00:00 2001 From: Volkan Date: Fri, 21 Aug 2020 15:26:38 -0700 Subject: [PATCH 22/67] Model Loader: upload vertex/index buffers (with hardcoded format for now), fix camera controller parameter initialization --- Data/Levels/Sponza.xml | 6 +++--- Source/Application/AssetLoader.cpp | 30 ++++++++++++++++---------- Source/Application/Camera.cpp | 20 +++++++++++------ Source/Application/Camera.h | 11 +++++----- Source/Application/Scene.cpp | 2 +- Source/Application/Scene.h | 2 +- Source/Application/VQEngine.h | 2 +- Source/Application/VQEngine_Main.cpp | 2 +- Source/Application/VQEngine_Render.cpp | 20 ++++++++--------- Source/Application/VQEngine_Update.cpp | 2 +- Source/Renderer/Buffer.cpp | 6 +++--- Source/Renderer/Renderer.cpp | 6 +++++- Source/Renderer/Renderer.h | 1 + Source/Renderer/Renderer_Resources.cpp | 2 +- 14 files changed, 67 insertions(+), 45 deletions(-) diff --git a/Data/Levels/Sponza.xml b/Data/Levels/Sponza.xml index 8b95b173..855009a4 100644 --- a/Data/Levels/Sponza.xml +++ b/Data/Levels/Sponza.xml @@ -36,11 +36,11 @@ 0 Perspective 60.0 - 0.01 - 1000 + 0.1 + 5000 - 1000 + 5800 0.05 9.5 diff --git a/Source/Application/AssetLoader.cpp b/Source/Application/AssetLoader.cpp index 80430716..94cf04f7 100644 --- a/Source/Application/AssetLoader.cpp +++ b/Source/Application/AssetLoader.cpp @@ -96,6 +96,7 @@ ModelID AssetLoader::ImportModel_obj(Scene* pScene, AssetLoader* pAssetLoader, V std::vector MaterialTextureAssignments; Model::Data data = ProcessAssimpNode(pAiScene->mRootNode, pAiScene, modelDirectory, pAssetLoader, pScene, pRenderer, MaterialTextureAssignments); + pRenderer->UploadVertexAndIndexBufferHeaps(); // load VB/IBs TextureLoadResults_t vTexLoadResults = pAssetLoader->StartLoadingTextures(); // cache the imported model in Scene @@ -103,6 +104,7 @@ ModelID AssetLoader::ImportModel_obj(Scene* pScene, AssetLoader* pAssetLoader, V Model& model = pScene->GetModel(mID); model = Model(objFilePath, ModelName, std::move(data)); + // SYNC POINT - wait for textures to load { for (auto it = vTexLoadResults.begin(); it != vTexLoadResults.end(); ++it) @@ -323,19 +325,31 @@ static std::vector GenerateTextureLoadParams( static Mesh ProcessAssimpMesh(VQRenderer* pRenderer, aiMesh* mesh, const aiScene* scene) { - std::vector Vertices; + std::vector Vertices; std::vector Indices; // Walk through each of the mesh's vertices for (unsigned int i = 0; i < mesh->mNumVertices; i++) { - FVertexWithNormalAndTangent Vert; + FVertexWithColorAndAlpha Vert; + Vert.color[0] = 1.0f; + Vert.color[1] = 1.0f; + Vert.color[2] = 1.0f; + Vert.color[3] = 1.0f; + //FVertexWithNormalAndTangent Vert; // POSITIONS Vert.position[0] = mesh->mVertices[i].x; Vert.position[1] = mesh->mVertices[i].y; Vert.position[2] = mesh->mVertices[i].z; + // TEXTURE COORDINATES + // a vertex can contain up to 8 different texture coordinates. We thus make the assumption that we won't + // use models where a vertex can have multiple texture coordinates so we always take the first set (0). + Vert.uv[0] = mesh->mTextureCoords[0] ? mesh->mTextureCoords[0][i].x : 0; + Vert.uv[1] = mesh->mTextureCoords[0] ? mesh->mTextureCoords[0][i].y : 0; + +#if 0 // NORMALS if (mesh->mNormals) { @@ -343,13 +357,7 @@ static Mesh ProcessAssimpMesh(VQRenderer* pRenderer, aiMesh* mesh, const aiScene Vert.normal[1] = mesh->mNormals[i].y; Vert.normal[2] = mesh->mNormals[i].z; } - - // TEXTURE COORDINATES - // a vertex can contain up to 8 different texture coordinates. We thus make the assumption that we won't - // use models where a vertex can have multiple texture coordinates so we always take the first set (0). - Vert.uv[0] = mesh->mTextureCoords[0] ? mesh->mTextureCoords[0][i].x : 0; - Vert.uv[1] = mesh->mTextureCoords[0] ? mesh->mTextureCoords[0][i].y : 0; - + // TANGENT if (mesh->mTangents) { @@ -357,7 +365,7 @@ static Mesh ProcessAssimpMesh(VQRenderer* pRenderer, aiMesh* mesh, const aiScene Vert.tangent[1] = mesh->mTangents[i].y; Vert.tangent[2] = mesh->mTangents[i].z; } - +#endif // BITANGENT ( NOT USED ) // Vert.bitangent = XMFLOAT3( @@ -378,7 +386,7 @@ static Mesh ProcessAssimpMesh(VQRenderer* pRenderer, aiMesh* mesh, const aiScene } // TODO: mesh name - return Mesh(pRenderer, Vertices, Indices, ""); + return Mesh(pRenderer, Vertices, Indices, "TODO");; } static Model::Data ProcessAssimpNode( diff --git a/Source/Application/Camera.cpp b/Source/Application/Camera.cpp index d79d61f1..e0d92075 100644 --- a/Source/Application/Camera.cpp +++ b/Source/Application/Camera.cpp @@ -66,18 +66,20 @@ void Camera::InitializeCamera(const FCameraParameters& data) { this->mProjParams = data.ProjectionParams; this->mProjParams.FieldOfView *= DEG2RAD; // convert FoV to radians - mYaw = mPitch = 0; + this->mYaw = this->mPitch = 0; + + SetProjectionMatrix(this->mProjParams); SetPosition(data.x, data.y, data.z); Rotate(data.Yaw * DEG2RAD, data.Pitch * DEG2RAD); UpdateViewMatrix(); } -void Camera::InitializeController(bool bFirstPersonController) +void Camera::InitializeController(bool bFirstPersonController, const FCameraParameters& data) { if (bFirstPersonController) { - pController = std::make_unique(this); + pController = std::make_unique(this, data.TranslationSpeed, data.AngularSpeed, data.Drag); } else { @@ -203,10 +205,16 @@ CameraController* OrbitController::Clone_impl(Camera* pNewCam) return p; } -FirstPersonController::FirstPersonController(Camera* pCam) +FirstPersonController::FirstPersonController(Camera* pCam + , float moveSpeed /*= 1000.0f*/ + , float angularSpeed /*= 0.05f */ + , float drag /*= 9.5f */ +) : CameraController(pCam) -{ -} + , MoveSpeed(moveSpeed) + , AngularSpeedDeg(angularSpeed) + , Drag(drag) +{} void FirstPersonController::UpdateCamera(const Input& input, float dt) { diff --git a/Source/Application/Camera.h b/Source/Application/Camera.h index 3b404080..32425e0b 100644 --- a/Source/Application/Camera.h +++ b/Source/Application/Camera.h @@ -87,14 +87,15 @@ class CameraController class FirstPersonController : public CameraController { public: - FirstPersonController(Camera* pCam);// : CameraController(pCam) + FirstPersonController() = delete; + FirstPersonController(Camera* pCam, float moveSpeed = 1000.0f, float angularSpeed = 0.05f, float drag = 9.5f); void UpdateCamera(const Input& input, float dt) override; protected: CameraController* Clone_impl(Camera* pNewCam) override; private: - float Drag = 9.5f; - float AngularSpeedDeg = 0.05f; - float MoveSpeed = 1000.0f; + float Drag; + float AngularSpeedDeg; + float MoveSpeed; }; class OrbitController : public CameraController { @@ -124,7 +125,7 @@ class Camera Camera Clone(); void InitializeCamera(const FCameraParameters& data); - void InitializeController(bool bFirstPersonController); + void InitializeController(bool bFirstPersonController, const FCameraParameters& data); void SetProjectionMatrix(const FProjectionMatrixParameters& params); diff --git a/Source/Application/Scene.cpp b/Source/Application/Scene.cpp index b84d4ed1..fed2d9b2 100644 --- a/Source/Application/Scene.cpp +++ b/Source/Application/Scene.cpp @@ -249,7 +249,7 @@ void Scene::StartLoading(FSceneRepresentation& scene) { if (scene.Cameras[i].bInitializeCameraController) { - mCameras[i].InitializeController(scene.Cameras[i].bFirstPerson); + mCameras[i].InitializeController(scene.Cameras[i].bFirstPerson, scene.Cameras[i]); } } diff --git a/Source/Application/Scene.h b/Source/Application/Scene.h index e089cd2c..91d64b61 100644 --- a/Source/Application/Scene.h +++ b/Source/Application/Scene.h @@ -65,7 +65,7 @@ struct FMeshRenderCommand { MeshID meshID = INVALID_ID; MaterialID matID = INVALID_ID; - DirectX::XMMATRIX WorldTransformationMatrix; + DirectX::XMMATRIX WorldTransformationMatrix; // WorldTF ID ? }; struct FSceneView { diff --git a/Source/Application/VQEngine.h b/Source/Application/VQEngine.h index 4c94a45a..75665b6e 100644 --- a/Source/Application/VQEngine.h +++ b/Source/Application/VQEngine.h @@ -405,7 +405,7 @@ class VQEngine : public IWindowOwner bool IsWindowRegistered(HWND hwnd) const; bool ShouldRenderHDR(HWND hwnd) const; - void CalculateEffectiveFrameRate(HWND hwnd); + void CalculateEffectiveFrameRateLimit(HWND hwnd); const FDisplayHDRProfile* GetHDRProfileIfExists(const wchar_t* pwStrLogicalDisplayName); FSetHDRMetaDataParams GatherHDRMetaDataParameters(HWND hwnd); diff --git a/Source/Application/VQEngine_Main.cpp b/Source/Application/VQEngine_Main.cpp index 0223b896..9b2f877d 100644 --- a/Source/Application/VQEngine_Main.cpp +++ b/Source/Application/VQEngine_Main.cpp @@ -70,7 +70,7 @@ bool VQEngine::Initialize(const FStartupParameters& Params) InitializeScenes(); float f2 = t.Tick(); InitializeThreads(); - CalculateEffectiveFrameRate(mpWinMain->GetHWND()); + CalculateEffectiveFrameRateLimit(mpWinMain->GetHWND()); float f4 = t.Tick(); // offload system info acquisition to a thread as it takes a few seconds on Debug build diff --git a/Source/Application/VQEngine_Render.cpp b/Source/Application/VQEngine_Render.cpp index 57754b35..4ae6754d 100644 --- a/Source/Application/VQEngine_Render.cpp +++ b/Source/Application/VQEngine_Render.cpp @@ -678,6 +678,8 @@ void VQEngine::RenderShadowMaps(FWindowRenderContext& ctx) void VQEngine::RenderSceneColor(FWindowRenderContext& ctx, const FSceneView& SceneView) { + using namespace DirectX; + const bool& bMSAA = mSettings.gfx.bAntiAliasing; ID3D12GraphicsCommandList*& pCmd = ctx.pCmdList_GFX; @@ -706,30 +708,28 @@ void VQEngine::RenderSceneColor(FWindowRenderContext& ctx, const FSceneView& Sce pCmd->SetPipelineState(mRenderer.GetPSO(bMSAA ? EBuiltinPSOs::HELLO_WORLD_CUBE_PSO_MSAA_4 : EBuiltinPSOs::HELLO_WORLD_CUBE_PSO)); // Draw Objects ----------------------------------------------- - using namespace DirectX; + ID3D12DescriptorHeap* ppHeaps[] = { mRenderer.GetDescHeap(EResourceHeapType::CBV_SRV_UAV_HEAP) }; + + pCmd->SetGraphicsRootSignature(mRenderer.GetRootSignature(2)); // hardcoded root signature for now until shader reflection and rootsignature management is implemented + pCmd->SetDescriptorHeaps(_countof(ppHeaps), ppHeaps); + pCmd->SetGraphicsRootDescriptorTable(0, mRenderer.GetSRV(0).GetGPUDescHandle()); for (const FMeshRenderCommand& meshRenderCmd : SceneView.meshRenderCommands) { const XMMATRIX mMVP = meshRenderCmd.WorldTransformationMatrix * SceneView.viewProj; - ID3D12DescriptorHeap* ppHeaps[] = { mRenderer.GetDescHeap(EResourceHeapType::CBV_SRV_UAV_HEAP) }; - // set constant buffer data FrameConstantBuffer* pConstBuffer = {}; D3D12_GPU_VIRTUAL_ADDRESS cbAddr = {}; ctx.mDynamicHeap_ConstantBuffer.AllocConstantBuffer(sizeof(FrameConstantBuffer), (void**)(&pConstBuffer), &cbAddr); pConstBuffer->matModelViewProj = mMVP; - // hardcoded root signature for now until shader reflection and rootsignature management is implemented - pCmd->SetGraphicsRootSignature(mRenderer.GetRootSignature(2)); - - pCmd->SetDescriptorHeaps(_countof(ppHeaps), ppHeaps); - pCmd->SetGraphicsRootDescriptorTable(0, mRenderer.GetSRV(0).GetGPUDescHandle()); pCmd->SetGraphicsRootConstantBufferView(1, cbAddr); - assert(false); // TODO: not everything is builting mesh - const Mesh& mesh = mBuiltinMeshes[meshRenderCmd.meshID]; + //assert(false); // TODO: not everything is builting mesh + //const Mesh& mesh = mBuiltinMeshes[meshRenderCmd.meshID]; + const Mesh& mesh = mpScene->mMeshes[meshRenderCmd.meshID]; const auto VBIBIDs = mesh.GetIABufferIDs(); const uint32 NumIndices = mesh.GetNumIndices(); diff --git a/Source/Application/VQEngine_Update.cpp b/Source/Application/VQEngine_Update.cpp index c9652917..6468e462 100644 --- a/Source/Application/VQEngine_Update.cpp +++ b/Source/Application/VQEngine_Update.cpp @@ -264,7 +264,7 @@ bool VQEngine::ShouldRenderHDR(HWND hwnd) const return mSettings.WndMain.bEnableHDR && pWin->GetIsOnHDRCapableDisplay(); } -void VQEngine::CalculateEffectiveFrameRate(HWND hwnd) +void VQEngine::CalculateEffectiveFrameRateLimit(HWND hwnd) { if (mSettings.gfx.MaxFrameRate == -1) { diff --git a/Source/Renderer/Buffer.cpp b/Source/Renderer/Buffer.cpp index 2a785c80..bd5d641d 100644 --- a/Source/Renderer/Buffer.cpp +++ b/Source/Renderer/Buffer.cpp @@ -65,7 +65,7 @@ void StaticBufferHeap::Create(ID3D12Device* pDevice, EBufferType type, uint32 to GetResourceTransitionState(mType), nullptr, IID_PPV_ARGS(&mpVidMemBuffer)); - mpVidMemBuffer->SetName(L"StaticBufferPool::m_pVidMemBuffer"); + SetName(mpVidMemBuffer, name); if (FAILED(hr)) { @@ -88,7 +88,7 @@ void StaticBufferHeap::Create(ID3D12Device* pDevice, EBufferType type, uint32 to // TODO } - mpSysMemBuffer->SetName(L"StaticBufferPool::m_pSysMemBuffer"); + SetName(mpSysMemBuffer, name); mpSysMemBuffer->Map(0, NULL, reinterpret_cast(&mpData)); } @@ -152,7 +152,7 @@ bool StaticBufferHeap::AllocBuffer(uint32 numElements, uint32 strideInBytes, voi std::lock_guard lock(mMtx); uint32 size = AlignOffset(numElements * strideInBytes, (uint32)StaticBufferHeap::MEMORY_ALIGNMENT); - assert(mMemOffset + size < mTotalMemSize); // if this is hit, initialize heap with a larger size. + assert( (mMemOffset + size) < mTotalMemSize); // if this is hit, initialize heap with a larger size. *ppDataOut = (void*)(mpData + mMemOffset); diff --git a/Source/Renderer/Renderer.cpp b/Source/Renderer/Renderer.cpp index ea3f49c2..3b29b45f 100644 --- a/Source/Renderer/Renderer.cpp +++ b/Source/Renderer/Renderer.cpp @@ -126,7 +126,7 @@ void VQRenderer::Load() { LoadPSOs(); LoadDefaultResources(); - mHeapUpload.UploadToGPUAndWait(mGFXQueue.pQueue); + this->UploadVertexAndIndexBufferHeaps(); } void VQRenderer::Unload() @@ -745,8 +745,12 @@ void VQRenderer::LoadDefaultResources() this->CreateAndInitializeSRV(texID); } +} +void VQRenderer::UploadVertexAndIndexBufferHeaps() +{ mStaticHeap_VertexBuffer.UploadData(mHeapUpload.GetCommandList()); mStaticHeap_IndexBuffer.UploadData(mHeapUpload.GetCommandList()); + mHeapUpload.UploadToGPUAndWait(mGFXQueue.pQueue); } diff --git a/Source/Renderer/Renderer.h b/Source/Renderer/Renderer.h index d4a98d0a..667211aa 100644 --- a/Source/Renderer/Renderer.h +++ b/Source/Renderer/Renderer.h @@ -113,6 +113,7 @@ class VQRenderer BufferID CreateBuffer(const FBufferDesc& desc); TextureID CreateTextureFromFile(const char* pFilePath); TextureID CreateTexture(const std::string& name, const D3D12_RESOURCE_DESC& desc, D3D12_RESOURCE_STATES ResourceState, const void* pData = nullptr); + void UploadVertexAndIndexBufferHeaps(); // Allocates a ResourceView from the respective heap and returns a unique identifier. SRV_ID CreateSRV(uint NumDescriptors = 1); diff --git a/Source/Renderer/Renderer_Resources.cpp b/Source/Renderer/Renderer_Resources.cpp index 6ee2c35b..62b5f5e1 100644 --- a/Source/Renderer/Renderer_Resources.cpp +++ b/Source/Renderer/Renderer_Resources.cpp @@ -276,7 +276,7 @@ void VQRenderer::InitializeUAV(UAV_ID uavID, uint heapIndex, TextureID texID) BufferID VQRenderer::CreateVertexBuffer(const FBufferDesc& desc) { BufferID Id = INVALID_ID; - VBV vbv; + VBV vbv = {}; std::lock_guard lk(mMtxStaticVBHeap); From 2e2f897806462242170a54bcfd281b173653698d Mon Sep 17 00:00:00 2001 From: Volkan Date: Mon, 24 Aug 2020 15:20:17 -0700 Subject: [PATCH 23/67] Initialzie scene builtin meshes through loading function --- Data/Levels/Sponza.xml | 4 ++-- Source/Application/Mesh.h | 4 ++++ Source/Application/Scene.cpp | 23 ++++++++++++++++++++--- Source/Application/Scene.h | 7 +++---- Source/Application/Types.h | 2 ++ Source/Application/VQEngine.h | 2 -- Source/Application/VQEngine_Render.cpp | 4 +--- Source/Application/VQEngine_Update.cpp | 2 +- Source/Renderer/Renderer_Resources.cpp | 13 ++++++++++++- 9 files changed, 45 insertions(+), 16 deletions(-) diff --git a/Data/Levels/Sponza.xml b/Data/Levels/Sponza.xml index 855009a4..3bff1c9e 100644 --- a/Data/Levels/Sponza.xml +++ b/Data/Levels/Sponza.xml @@ -61,9 +61,9 @@ - 0 0 0 + 0 100 0 0 0 0 1 - 1 1 1 + 100 100 100 Triangle diff --git a/Source/Application/Mesh.h b/Source/Application/Mesh.h index 7c154b39..83a3abaa 100644 --- a/Source/Application/Mesh.h +++ b/Source/Application/Mesh.h @@ -162,3 +162,7 @@ Mesh::Mesh(VQRenderer* pRenderer, const MeshLODData& meshLODDat mNumIndicesPerLODLevel.push_back(bufferDesc.NumElements); } } + + + +using BuiltinMeshArray_t = std::array; \ No newline at end of file diff --git a/Source/Application/Scene.cpp b/Source/Application/Scene.cpp index fed2d9b2..c7505c8f 100644 --- a/Source/Application/Scene.cpp +++ b/Source/Application/Scene.cpp @@ -27,7 +27,7 @@ using namespace DirectX; -static ModelID LAST_USED_MESH_ID = 0; +static MeshID LAST_USED_MESH_ID = EBuiltInMeshes::NUM_BUILTIN_MESHES; //MeshID Scene::CreateMesh() //{ @@ -45,6 +45,14 @@ MeshID Scene::AddMesh(Mesh&& mesh) return id; } +MeshID Scene::AddMesh(const Mesh& mesh) +{ + std::lock_guard lk(mMtx_Meshes); + MeshID id = LAST_USED_MESH_ID++; + mMeshes[id] = mesh; + return id; +} + ModelID Scene::CreateModel() { std::unique_lock lk(mMtx_Models); @@ -152,10 +160,18 @@ void Scene::PostUpdate(int FRAME_DATA_INDEX, int FRAME_DATA_NEXT_INDEX) } } -void Scene::StartLoading(FSceneRepresentation& scene) +void Scene::StartLoading(const BuiltinMeshArray_t& builtinMeshes, FSceneRepresentation& scene) { constexpr bool B_LOAD_SERIAL = true; + // register builtin meshes to scene mesh lookup + // @mMeshes[0-NUM_BUILTIN_MESHES] are assigned here directly while the rest + // of the meshes used in the scene must use this->AddMesh(Mesh&&) interface; + for (size_t i = 0; i < builtinMeshes.size(); ++i) + { + this->mMeshes[i] = builtinMeshes[i]; + } + // scene-specific load this->LoadScene(scene); @@ -226,6 +242,7 @@ void Scene::StartLoading(FSceneRepresentation& scene) AssetLoader::ModelLoadResult_t res = std::move(it->second); assert(res.valid()); + res.wait(); pObj->mModelID = res.get(); } @@ -275,7 +292,7 @@ void Scene::Unload() mFrameSceneViews.clear(); mFrameSceneViews.resize(sz); - //mMeshIDs.clear(); + //mMeshes.clear(); // TODO for (Transform* pTf : mpTransforms) mTransformPool.Free(pTf); mpTransforms.clear(); diff --git a/Source/Application/Scene.h b/Source/Application/Scene.h index 91d64b61..be65a834 100644 --- a/Source/Application/Scene.h +++ b/Source/Application/Scene.h @@ -141,8 +141,7 @@ class Scene // ENGINE INTERFACE //---------------------------------------------------------------------------------------------------------------- public: - Scene( - VQEngine& engine + Scene(VQEngine& engine , int NumFrameBuffers , const Input& input , const std::unique_ptr& pWin @@ -152,7 +151,7 @@ class Scene private: // Derived Scenes shouldn't access these functions void Update(float dt, int FRAME_DATA_INDEX); void PostUpdate(int FRAME_DATA_INDEX, int FRAME_DATA_NEXT_INDEX); - void StartLoading(FSceneRepresentation& scene); + void StartLoading(const BuiltinMeshArray_t& builtinMeshes, FSceneRepresentation& scene); void OnLoadComplete(); void Unload(); // serial-only for now. maybe MT later. void RenderUI(); @@ -168,8 +167,8 @@ class Scene // Mesh, Model, GameObj management //TransformID CreateTransform(Transform** ppTransform); //GameObject* CreateObject(TransformID tfID, ModelID modelID); - //MeshID CreateMesh(); MeshID AddMesh(Mesh&& mesh); + MeshID AddMesh(const Mesh& mesh); ModelID CreateModel(); MaterialID CreateMaterial(const std::string& UniqueMaterialName); diff --git a/Source/Application/Types.h b/Source/Application/Types.h index 7e2bf04e..65b8da86 100644 --- a/Source/Application/Types.h +++ b/Source/Application/Types.h @@ -46,6 +46,8 @@ using CBV_ID = ID_TYPE; using RTV_ID = ID_TYPE; using DSV_ID = ID_TYPE; +using ShaderID = ID_TYPE; + using EnvironmentMapID = ID_TYPE; using MeshID = ID_TYPE; using MaterialID = ID_TYPE; diff --git a/Source/Application/VQEngine.h b/Source/Application/VQEngine.h index 75665b6e..c83116b1 100644 --- a/Source/Application/VQEngine.h +++ b/Source/Application/VQEngine.h @@ -237,10 +237,8 @@ class VQEngine : public IWindowOwner inline AssetLoader& GetAssetLoader() { return mAssetLoader; } - private: //------------------------------------------------------------------------------------------------- - using BuiltinMeshArray_t = std::array; using EnvironmentMapDescLookup_t = std::unordered_map; //------------------------------------------------------------------------------------------------- using EventPtr_t = std::shared_ptr; diff --git a/Source/Application/VQEngine_Render.cpp b/Source/Application/VQEngine_Render.cpp index 4ae6754d..feb7e5f1 100644 --- a/Source/Application/VQEngine_Render.cpp +++ b/Source/Application/VQEngine_Render.cpp @@ -727,9 +727,7 @@ void VQEngine::RenderSceneColor(FWindowRenderContext& ctx, const FSceneView& Sce pCmd->SetGraphicsRootConstantBufferView(1, cbAddr); - //assert(false); // TODO: not everything is builting mesh - //const Mesh& mesh = mBuiltinMeshes[meshRenderCmd.meshID]; - const Mesh& mesh = mpScene->mMeshes[meshRenderCmd.meshID]; + const Mesh& mesh = mpScene->mMeshes.at(meshRenderCmd.meshID); const auto VBIBIDs = mesh.GetIABufferIDs(); const uint32 NumIndices = mesh.GetNumIndices(); diff --git a/Source/Application/VQEngine_Update.cpp b/Source/Application/VQEngine_Update.cpp index 6468e462..13c7a474 100644 --- a/Source/Application/VQEngine_Update.cpp +++ b/Source/Application/VQEngine_Update.cpp @@ -473,7 +473,7 @@ void VQEngine::Load_SceneData_Dispatch() fnCreateSceneInstance(SceneRep.SceneName, mpScene); // let the custom scene logic edit the scene representation - mpScene->StartLoading(SceneRep); + mpScene->StartLoading(this->mBuiltinMeshes, SceneRep); // start loading; Log::Info("[Scene] Loading: %s", SceneRep.SceneName.c_str()); diff --git a/Source/Renderer/Renderer_Resources.cpp b/Source/Renderer/Renderer_Resources.cpp index 62b5f5e1..ac58f072 100644 --- a/Source/Renderer/Renderer_Resources.cpp +++ b/Source/Renderer/Renderer_Resources.cpp @@ -152,7 +152,7 @@ SRV_ID VQRenderer::CreateAndInitializeSRV(TextureID texID) std::lock_guard lk(mMtxSRVs_CBVs_UAVs); mHeapCBV_SRV_UAV.AllocDescriptor(1, &SRV); - mTextures[texID].InitializeSRV(0, &SRV); + mTextures.at(texID).InitializeSRV(0, &SRV); Id = LAST_USED_SRV_ID++; mSRVs[Id] = SRV; } @@ -373,6 +373,17 @@ void VQRenderer::DestroyTexture(TextureID texID) std::lock_guard lk(mMtxTextures); mTextures.at(texID).Destroy(); mTextures.erase(texID); + + std::string texPath = ""; + for (const auto& path_id_pair : mLoadedTexturePaths) + { + if (path_id_pair.second == texID) + { + texPath = path_id_pair.first; + break; + } + } + mLoadedTexturePaths.erase(texPath); } void VQRenderer::DestroySRV(SRV_ID srvID) { From 67673acd120540f2254a944eb14e8fb1bb9d1239 Mon Sep 17 00:00:00 2001 From: Volkan Date: Tue, 25 Aug 2020 16:52:13 -0700 Subject: [PATCH 24/67] Async model loading --- Data/Levels/Sponza.xml | 35 +++++++++++++++++++++++++++++- Source/Application/AssetLoader.cpp | 23 +++++++++++++------- Source/Application/AssetLoader.h | 2 +- Source/Application/Scene.cpp | 31 +++++++++++++------------- Source/Application/Scene.h | 7 ++++-- 5 files changed, 70 insertions(+), 28 deletions(-) diff --git a/Data/Levels/Sponza.xml b/Data/Levels/Sponza.xml index 3bff1c9e..85a28928 100644 --- a/Data/Levels/Sponza.xml +++ b/Data/Levels/Sponza.xml @@ -73,7 +73,40 @@ - + + + 0 0 0 + 0 0 0 1 + 0.01 0.01 0.01 + + + Data/Models/sponza/sponza.obj + Sponza + + + + + -130 0 0 + 0 0 0 1 + 0.01 0.01 0.01 + + + Data/Models/sponza/sponza.obj + Sponza + + + + + 130 0 0 + 0 0 0 1 + 0.01 0.01 0.01 + + + Data/Models/sponza/sponza.obj + Sponza + + + diff --git a/Source/Application/AssetLoader.cpp b/Source/Application/AssetLoader.cpp index 94cf04f7..068e770c 100644 --- a/Source/Application/AssetLoader.cpp +++ b/Source/Application/AssetLoader.cpp @@ -35,10 +35,9 @@ using namespace Assimp; using namespace DirectX; - struct FMaterialTextureAssignments { - MaterialID matID; + MaterialID matID = INVALID_ID; std::vector DiffuseIDs; std::vector SpecularIDs; std::vector NormalsIDs; @@ -178,7 +177,9 @@ void AssetLoader::QueueModelLoad(GameObject* pObject, const std::string& ModelPa AssetLoader::ModelLoadResults_t AssetLoader::StartLoadingModels(Scene* pScene) { + VQRenderer* pRenderer = &mRenderer; ModelLoadResults_t ModelLoadResults; + if (mModelLoadQueue.empty()) { Log::Warning("AssetLoader::StartLoadingModels(): no models to load"); @@ -186,7 +187,7 @@ AssetLoader::ModelLoadResults_t AssetLoader::StartLoadingModels(Scene* pScene) } // process model load queue - VQRenderer* pRenderer = &mRenderer; + std::unordered_map> ModelLoadResultMap; std::unique_lock lk(mMtxQueue_ModelLoad); do { @@ -194,20 +195,26 @@ AssetLoader::ModelLoadResults_t AssetLoader::StartLoadingModels(Scene* pScene) const std::string& ModelPath = ModelLoadParams.ModelPath; mModelLoadQueue.pop(); - // eliminate duplicates + // queue unique model paths for loading + std::shared_future modelLoadResult; if (mUniqueModelPaths.find(ModelPath) == mUniqueModelPaths.end()) { mUniqueModelPaths.insert(ModelPath); // start loading - std::future modelLoadResult = std::move(mWorkers.AddTask([=]() + modelLoadResult = std::move(mWorkers.AddTask([=]() { return ModelLoadParams.pfnImportModel(pScene, this, pRenderer, ModelLoadParams.ModelPath, ModelLoadParams.ModelName); })); - - ModelLoadResults.emplace(std::make_pair(ModelLoadParams.pObject, std::move(modelLoadResult))); - //ModelLoadResults[ModelLoadParams.pObject] = std::move(modelLoadResult); + ModelLoadResultMap[ModelLoadParams.ModelPath] = modelLoadResult; + } + else + { + modelLoadResult = ModelLoadResultMap.at(ModelLoadParams.ModelPath); } + + ModelLoadResults.emplace(std::make_pair(ModelLoadParams.pObject, modelLoadResult)); + } while (!mModelLoadQueue.empty()); mUniqueModelPaths.clear(); diff --git a/Source/Application/AssetLoader.h b/Source/Application/AssetLoader.h index df94034a..4cd4af79 100644 --- a/Source/Application/AssetLoader.h +++ b/Source/Application/AssetLoader.h @@ -61,7 +61,7 @@ class AssetLoader }; struct FTextureLoadResult { - ETextureType type; + ETextureType type; // material textures: diffuse/normal/alpha_mask/... std::shared_future texLoadResult; }; using ModelLoadResult_t = std::shared_future; diff --git a/Source/Application/Scene.cpp b/Source/Application/Scene.cpp index c7505c8f..6152a871 100644 --- a/Source/Application/Scene.cpp +++ b/Source/Application/Scene.cpp @@ -149,7 +149,8 @@ void Scene::PostUpdate(int FRAME_DATA_INDEX, int FRAME_DATA_NEXT_INDEX) for (const GameObject* pObj : mpObjects) { const XMMATRIX matWorldTransform = mpTransforms.at(pObj->mTransformID)->WorldTransformationMatrix(); - + + assert(pObj->mModelID != INVALID_ID); for (const MeshID id : mModels.at(pObj->mModelID).mData.mOpaueMeshIDs) { FMeshRenderCommand meshRenderCmd; @@ -232,21 +233,7 @@ void Scene::StartLoading(const BuiltinMeshArray_t& builtinMeshes, FSceneRepresen assert(false); // TODO } - AssetLoader::ModelLoadResults_t vModelLoadResults = mAssetLoader.StartLoadingModels(this); - - // TODO: serial model loading for now - { - for (auto it = vModelLoadResults.begin(); it != vModelLoadResults.end(); ++it) - { - GameObject* pObj = it->first; - AssetLoader::ModelLoadResult_t res = std::move(it->second); - - assert(res.valid()); - - res.wait(); - pObj->mModelID = res.get(); - } - } + mModelLoadResults = mAssetLoader.StartLoadingModels(this); // CAMERAS for (FCameraParameters& param : scene.Cameras) @@ -277,6 +264,18 @@ void Scene::StartLoading(const BuiltinMeshArray_t& builtinMeshes, FSceneRepresen void Scene::OnLoadComplete() { + + for (auto it = mModelLoadResults.begin(); it != mModelLoadResults.end(); ++it) + { + GameObject* pObj = it->first; + AssetLoader::ModelLoadResult_t res = std::move(it->second); + + assert(res.valid()); + ///res.wait(); // we should already have the results ready in OnLoadComplete() + + pObj->mModelID = res.get(); + } + Log::Info("[Scene] %s loaded.", mSceneRepresentation.SceneName.c_str()); mSceneRepresentation.loadSuccess = 1; this->InitializeScene(); diff --git a/Source/Application/Scene.h b/Source/Application/Scene.h index be65a834..22de41c1 100644 --- a/Source/Application/Scene.h +++ b/Source/Application/Scene.h @@ -25,9 +25,9 @@ #include "Transform.h" #include "GameObject.h" #include "Memory.h" +#include "AssetLoader.h" class Input; -class AssetLoader; struct Material; struct FResourceNames; @@ -244,8 +244,11 @@ class Scene std::mutex mMtx_Models; std::mutex mMtx_Materials; + AssetLoader::ModelLoadResults_t mModelLoadResults; + + // cache std::unordered_map mLoadedMaterials; - + //CPUProfiler* mpCPUProfiler; //ModelLoader mModelLoader; //MaterialPool mMaterials; From 8e03ad5cf20f4aad23578cbc1e155f3f2004f231 Mon Sep 17 00:00:00 2001 From: Volkan Date: Wed, 26 Aug 2020 00:23:18 -0700 Subject: [PATCH 25/67] WIP PBR material skeleton: objects rendered w/ diffuse map colors --- CMakeLists.txt | 1 + Data/Levels/Sponza.xml | 16 ++-- Shaders/Object.hlsl | 93 +++++++++++++++++++++ Source/Application/AssetLoader.cpp | 39 +++++---- Source/Application/Material.h | 31 +++++-- Source/Application/Scene.cpp | 16 +++- Source/Application/VQEngine.h | 3 +- Source/Application/VQEngine_Render.cpp | 22 +++-- Source/Application/VQEngine_Update.cpp | 1 + Source/Renderer/Renderer.cpp | 108 ++++++++++++++++++++++++- Source/Renderer/Renderer.h | 2 + Source/Renderer/Renderer_Resources.cpp | 34 ++++++-- 12 files changed, 313 insertions(+), 53 deletions(-) create mode 100644 Shaders/Object.hlsl diff --git a/CMakeLists.txt b/CMakeLists.txt index eaaf9c43..fa7d75ed 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -43,6 +43,7 @@ set (Shaders "Shaders/FullscreenTriangle.hlsl" "Shaders/Tonemapper.hlsl" "Shaders/Skydome.hlsl" + "Shaders/Object.hlsl" ) set (HeaderVQE diff --git a/Data/Levels/Sponza.xml b/Data/Levels/Sponza.xml index 85a28928..3b1ae548 100644 --- a/Data/Levels/Sponza.xml +++ b/Data/Levels/Sponza.xml @@ -31,9 +31,9 @@ --> - 0.0 3.0 -5 + 700.0 170.0 -50 15 - 0 + -90 Perspective 60.0 0.1 @@ -61,7 +61,7 @@ - 0 100 0 + 0 100 190 0 0 0 1 100 100 100 @@ -77,7 +77,7 @@ 0 0 0 0 0 0 1 - 0.01 0.01 0.01 + 0.05 0.05 0.05 Data/Models/sponza/sponza.obj @@ -86,9 +86,9 @@ - -130 0 0 + -230 0 0 0 0 0 1 - 0.01 0.01 0.01 + 0.06 0.06 0.06 Data/Models/sponza/sponza.obj @@ -97,9 +97,9 @@ - 130 0 0 + 330 0 0 0 0 0 1 - 0.01 0.01 0.01 + 0.07 0.07 0.07 Data/Models/sponza/sponza.obj diff --git a/Shaders/Object.hlsl b/Shaders/Object.hlsl new file mode 100644 index 00000000..51046945 --- /dev/null +++ b/Shaders/Object.hlsl @@ -0,0 +1,93 @@ +// VQE +// Copyright(C) 2020 - Volkan Ilbeyli +// +// This program is free software : you can redistribute it and / or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program.If not, see . +// +// Contact: volkanilbeyli@gmail.com + +struct VSInput +{ + float4 position : POSITION; + float3 normal : NORMAL; + float3 tangent : TANGENT; + float2 uv : TEXCOORD0; +}; + +struct PSInput +{ + float4 position : SV_POSITION; + float3 vertNormal : COLOR0; + float3 vertTangent : COLOR1; + float2 uv : TEXCOORD0; +}; + +struct PerFrame{}; // TODO +struct PerView {}; // TODO +struct PerObject{}; // TODO + +cbuffer CBuffer : register(b0) +{ + float4x4 matModelViewProj; + int iTextureConfig; + int iTextureOut; +} + + +Texture2D texDiffuse : register(t0); +Texture2D texNormals : register(t1); +Texture2D texEmissive : register(t2); +Texture2D texAlphaMask : register(t3); +Texture2D texMetalness : register(t4); +Texture2D texRoughness : register(t5); + +SamplerState LinearSampler : register(s0); +SamplerState PointSampler : register(s1); + +PSInput VSMain(VSInput vertex) +{ + PSInput result; + + result.position = mul(matModelViewProj, vertex.position); + result.uv = vertex.uv; + result.vertNormal = vertex.normal; + result.vertTangent = vertex.tangent; + + return result; +} + +float4 PSMain(PSInput input) : SV_TARGET +{ + const float2 uv = input.uv; + + float3 Albedo = texDiffuse.SampleLevel(LinearSampler, uv, 0).rgb; + float3 Normal = texNormals.SampleLevel(PointSampler, uv, 0).rgb; + float3 Emissive = texEmissive.SampleLevel(LinearSampler, uv, 0).rgb; + float3 AlphaMask = texAlphaMask.SampleLevel(LinearSampler, uv, 0).rgb; + float3 Metalness = texMetalness.SampleLevel(LinearSampler, uv, 0).rgb; + float3 Roughness = texRoughness.SampleLevel(LinearSampler, uv, 0).rgb; + + float3 OutColor = 0.0.xxx; + switch (iTextureOut) + { + case 0: OutColor = Albedo; break; + case 1: OutColor = Normal; break; + case 2: OutColor = Emissive; break; + case 3: OutColor = AlphaMask; break; + case 4: OutColor = Metalness; break; + case 5: OutColor = Roughness; break; + default: OutColor = float3(0.8, 0, 0.8); break; + } + + return float4(OutColor, 1); +} diff --git a/Source/Application/AssetLoader.cpp b/Source/Application/AssetLoader.cpp index 068e770c..ae7c5e17 100644 --- a/Source/Application/AssetLoader.cpp +++ b/Source/Application/AssetLoader.cpp @@ -129,19 +129,26 @@ ModelID AssetLoader::ImportModel_obj(Scene* pScene, AssetLoader* pAssetLoader, V assert(result.texLoadResult.valid()); switch (result.type) { - case DIFFUSE : mat.diffuseMap = result.texLoadResult.get(); break; - case NORMALS : mat.normalMap = result.texLoadResult.get(); break; - case SPECULAR : mat.specularMap = result.texLoadResult.get(); break; - case ALPHA_MASK: mat.mask = result.texLoadResult.get(); break; - case EMISSIVE : mat.emissiveMap = result.texLoadResult.get(); break; - case HEIGHT : mat.heightMap = result.texLoadResult.get(); break; - case METALNESS : mat.metallicMap = result.texLoadResult.get(); break; - case ROUGHNESS : mat.roughnessMap = result.texLoadResult.get(); break; + case DIFFUSE : mat.TexDiffuseMap = result.texLoadResult.get(); break; + case NORMALS : mat.TexNormalMap = result.texLoadResult.get(); break; + case ALPHA_MASK: mat.TexAlphaMaskMap = result.texLoadResult.get(); break; + case EMISSIVE : mat.TexEmissiveMap = result.texLoadResult.get(); break; + case METALNESS : mat.TexMetallicMap = result.texLoadResult.get(); break; + case ROUGHNESS : mat.TexRoughnessMap = result.texLoadResult.get(); break; + case SPECULAR : mat.TexSpecularMap = result.texLoadResult.get(); /*pRenderer->InitializeSRV(mat.SRVMaterialMaps, 0, mat.TexSpecularMap);*/ break; + case HEIGHT : mat.TexHeightMap = result.texLoadResult.get(); /*pRenderer->InitializeSRV(mat.SRVMaterialMaps, 0, mat.TexHeightMap) ;*/ break; default: Log::Warning("TODO"); break; } } + + pRenderer->InitializeSRV(mat.SRVMaterialMaps, EMaterialTextureMapBindings::ALBEDO, mat.TexDiffuseMap); + pRenderer->InitializeSRV(mat.SRVMaterialMaps, EMaterialTextureMapBindings::NORMALS, mat.TexNormalMap); + pRenderer->InitializeSRV(mat.SRVMaterialMaps, EMaterialTextureMapBindings::ALPHA_MASK, mat.TexAlphaMaskMap); + pRenderer->InitializeSRV(mat.SRVMaterialMaps, EMaterialTextureMapBindings::EMISSIVE, mat.TexEmissiveMap); + pRenderer->InitializeSRV(mat.SRVMaterialMaps, EMaterialTextureMapBindings::METALLIC, mat.TexMetallicMap); + pRenderer->InitializeSRV(mat.SRVMaterialMaps, EMaterialTextureMapBindings::ROUGHNESS, mat.TexRoughnessMap); } t.Stop(); @@ -332,18 +339,13 @@ static std::vector GenerateTextureLoadParams( static Mesh ProcessAssimpMesh(VQRenderer* pRenderer, aiMesh* mesh, const aiScene* scene) { - std::vector Vertices; + std::vector Vertices; std::vector Indices; // Walk through each of the mesh's vertices for (unsigned int i = 0; i < mesh->mNumVertices; i++) { - FVertexWithColorAndAlpha Vert; - Vert.color[0] = 1.0f; - Vert.color[1] = 1.0f; - Vert.color[2] = 1.0f; - Vert.color[3] = 1.0f; - //FVertexWithNormalAndTangent Vert; + FVertexWithNormalAndTangent Vert; // POSITIONS Vert.position[0] = mesh->mVertices[i].x; @@ -356,7 +358,6 @@ static Mesh ProcessAssimpMesh(VQRenderer* pRenderer, aiMesh* mesh, const aiScene Vert.uv[0] = mesh->mTextureCoords[0] ? mesh->mTextureCoords[0][i].x : 0; Vert.uv[1] = mesh->mTextureCoords[0] ? mesh->mTextureCoords[0][i].y : 0; -#if 0 // NORMALS if (mesh->mNormals) { @@ -372,7 +373,6 @@ static Mesh ProcessAssimpMesh(VQRenderer* pRenderer, aiMesh* mesh, const aiScene Vert.tangent[1] = mesh->mTangents[i].y; Vert.tangent[2] = mesh->mTangents[i].z; } -#endif // BITANGENT ( NOT USED ) // Vert.bitangent = XMFLOAT3( @@ -426,6 +426,11 @@ static Model::Data ProcessAssimpNode( // Materials use the following unique naming: %MODEL_NAME%/%MATERIAL_NAME% uniqueMatName = ModelFolderName + "/" + uniqueMatName; matID = pScene->CreateMaterial(uniqueMatName); + Material& mat = pScene->GetMaterial(matID); + if (mat.SRVMaterialMaps == INVALID_ID) + { + mat.SRVMaterialMaps = pRenderer->CreateSRV(NUM_MATERIAL_TEXTURE_MAP_BINDINGS); + } } // get texture paths to load diff --git a/Source/Application/Material.h b/Source/Application/Material.h index 42151906..6a1d5436 100644 --- a/Source/Application/Material.h +++ b/Source/Application/Material.h @@ -19,6 +19,20 @@ #pragma once #include +enum EMaterialTextureMapBindings +{ + ALBEDO = 0, + NORMALS, + EMISSIVE, + // HEIGHT, + // SPECULAR, + ALPHA_MASK, + METALLIC, + ROUGHNESS, + + NUM_MATERIAL_TEXTURE_MAP_BINDINGS +}; + struct Material // 56 Bytes { //------------------------------------------------------------ @@ -40,15 +54,16 @@ struct Material // 56 Bytes float pad0, pad1; // 8 Bytes //------------------------------------------------------------ - TextureID diffuseMap = INVALID_ID; - TextureID normalMap = INVALID_ID; - TextureID heightMap = INVALID_ID; - TextureID specularMap = INVALID_ID; // phong? - TextureID roughnessMap = INVALID_ID; - TextureID metallicMap = INVALID_ID; - TextureID mask = INVALID_ID; - TextureID emissiveMap = INVALID_ID; + TextureID TexDiffuseMap = INVALID_ID; + TextureID TexNormalMap = INVALID_ID; + TextureID TexEmissiveMap = INVALID_ID; + TextureID TexHeightMap = INVALID_ID; + TextureID TexSpecularMap = INVALID_ID; // phong? + TextureID TexAlphaMaskMap = INVALID_ID; + TextureID TexMetallicMap = INVALID_ID; + TextureID TexRoughnessMap = INVALID_ID; + SRV_ID SRVMaterialMaps = INVALID_ID; //------------------------------------------------------------ inline bool IsTransparent() const { return alpha != 1.0f; } diff --git a/Source/Application/Scene.cpp b/Source/Application/Scene.cpp index 6152a871..9c911fa1 100644 --- a/Source/Application/Scene.cpp +++ b/Source/Application/Scene.cpp @@ -149,13 +149,16 @@ void Scene::PostUpdate(int FRAME_DATA_INDEX, int FRAME_DATA_NEXT_INDEX) for (const GameObject* pObj : mpObjects) { const XMMATRIX matWorldTransform = mpTransforms.at(pObj->mTransformID)->WorldTransformationMatrix(); + const Model& model = mModels.at(pObj->mModelID); assert(pObj->mModelID != INVALID_ID); - for (const MeshID id : mModels.at(pObj->mModelID).mData.mOpaueMeshIDs) + for (const MeshID id : model.mData.mOpaueMeshIDs) { FMeshRenderCommand meshRenderCmd; meshRenderCmd.meshID = id; meshRenderCmd.WorldTransformationMatrix = matWorldTransform; + meshRenderCmd.matID = model.mData.mOpaqueMaterials.at(id); + SceneView.meshRenderCommands.push_back(meshRenderCmd); } } @@ -170,13 +173,13 @@ void Scene::StartLoading(const BuiltinMeshArray_t& builtinMeshes, FSceneRepresen // of the meshes used in the scene must use this->AddMesh(Mesh&&) interface; for (size_t i = 0; i < builtinMeshes.size(); ++i) { - this->mMeshes[i] = builtinMeshes[i]; + this->mMeshes[(int)i] = builtinMeshes[i]; } // scene-specific load this->LoadScene(scene); - auto fnDeserializeGameObject = [&](GameObjectRepresentation& ObjRep) + auto fnDeserializeGameObject = [&](GameObjectRepresentation& ObjRep, int i) { // GameObject GameObject* pObj = mGameObjectPool.Allocate(1); @@ -206,6 +209,10 @@ void Scene::StartLoading(const BuiltinMeshArray_t& builtinMeshes, FSceneRepresen model.mData.mOpaueMeshIDs.push_back(meshID); // TODO: material + std::string matName = "ObjMat"; + matName += std::to_string(i); + MaterialID matID = this->CreateMaterial(matName); + model.mData.mOpaqueMaterials[meshID] = matID; model.mbLoaded = true; pObj->mModelID = mID; @@ -222,9 +229,10 @@ void Scene::StartLoading(const BuiltinMeshArray_t& builtinMeshes, FSceneRepresen if constexpr (B_LOAD_SERIAL) { // GAME OBJECTS + int i = 0; for (GameObjectRepresentation& ObjRep : scene.Objects) { - fnDeserializeGameObject(ObjRep); + fnDeserializeGameObject(ObjRep, i++); } } else // THREADED LOAD diff --git a/Source/Application/VQEngine.h b/Source/Application/VQEngine.h index c83116b1..8566d816 100644 --- a/Source/Application/VQEngine.h +++ b/Source/Application/VQEngine.h @@ -381,7 +381,8 @@ class VQEngine : public IWindowOwner HRESULT PresentFrame(FWindowRenderContext& ctx); // temp - struct FrameConstantBuffer { DirectX::XMMATRIX matModelViewProj; }; + struct FFrameConstantBuffer { DirectX::XMMATRIX matModelViewProj; }; + struct FFrameConstantBuffer2 { DirectX::XMMATRIX matModelViewProj; int iTextureConfig; int iTextureOutput; }; void DrawMesh(ID3D12GraphicsCommandList* pCmd, const Mesh& mesh); diff --git a/Source/Application/VQEngine_Render.cpp b/Source/Application/VQEngine_Render.cpp index feb7e5f1..79feaa4c 100644 --- a/Source/Application/VQEngine_Render.cpp +++ b/Source/Application/VQEngine_Render.cpp @@ -705,25 +705,31 @@ void VQEngine::RenderSceneColor(FWindowRenderContext& ctx, const FSceneView& Sce pCmd->RSSetViewports(1, &viewport); pCmd->RSSetScissorRects(1, &scissorsRect); - pCmd->SetPipelineState(mRenderer.GetPSO(bMSAA ? EBuiltinPSOs::HELLO_WORLD_CUBE_PSO_MSAA_4 : EBuiltinPSOs::HELLO_WORLD_CUBE_PSO)); + pCmd->SetPipelineState(mRenderer.GetPSO(bMSAA ? EBuiltinPSOs::OBJECT_PSO_MSAA_4 : EBuiltinPSOs::OBJECT_PSO)); // Draw Objects ----------------------------------------------- ID3D12DescriptorHeap* ppHeaps[] = { mRenderer.GetDescHeap(EResourceHeapType::CBV_SRV_UAV_HEAP) }; - pCmd->SetGraphicsRootSignature(mRenderer.GetRootSignature(2)); // hardcoded root signature for now until shader reflection and rootsignature management is implemented + pCmd->SetGraphicsRootSignature(mRenderer.GetRootSignature(4)); // hardcoded root signature for now until shader reflection and rootsignature management is implemented pCmd->SetDescriptorHeaps(_countof(ppHeaps), ppHeaps); - pCmd->SetGraphicsRootDescriptorTable(0, mRenderer.GetSRV(0).GetGPUDescHandle()); for (const FMeshRenderCommand& meshRenderCmd : SceneView.meshRenderCommands) { + // set constant buffer data const XMMATRIX mMVP = meshRenderCmd.WorldTransformationMatrix * SceneView.viewProj; - // set constant buffer data - FrameConstantBuffer* pConstBuffer = {}; + FFrameConstantBuffer2* pConstBuffer = {}; D3D12_GPU_VIRTUAL_ADDRESS cbAddr = {}; - ctx.mDynamicHeap_ConstantBuffer.AllocConstantBuffer(sizeof(FrameConstantBuffer), (void**)(&pConstBuffer), &cbAddr); + ctx.mDynamicHeap_ConstantBuffer.AllocConstantBuffer(sizeof(FFrameConstantBuffer2), (void**)(&pConstBuffer), &cbAddr); pConstBuffer->matModelViewProj = mMVP; + pConstBuffer->iTextureConfig = 0; // TODO + pConstBuffer->iTextureOutput = EMaterialTextureMapBindings::ALBEDO; // TODO: drive thru material + + // set material data + const Material& mat = mpScene->GetMaterial(meshRenderCmd.matID); + if(mat.SRVMaterialMaps!=INVALID_ID) + pCmd->SetGraphicsRootDescriptorTable(0, mRenderer.GetSRV(mat.SRVMaterialMaps).GetGPUDescHandle(0)); pCmd->SetGraphicsRootConstantBufferView(1, cbAddr); @@ -758,8 +764,8 @@ void VQEngine::RenderSceneColor(FWindowRenderContext& ctx, const FSceneView& Sce skyCam.UpdateViewMatrix(); D3D12_GPU_VIRTUAL_ADDRESS cbAddr = {}; - FrameConstantBuffer* pConstBuffer = {}; - ctx.mDynamicHeap_ConstantBuffer.AllocConstantBuffer(sizeof(FrameConstantBuffer), (void**)(&pConstBuffer), &cbAddr); + FFrameConstantBuffer * pConstBuffer = {}; + ctx.mDynamicHeap_ConstantBuffer.AllocConstantBuffer(sizeof(FFrameConstantBuffer ), (void**)(&pConstBuffer), &cbAddr); pConstBuffer->matModelViewProj = skyCam.GetViewMatrix() * skyCam.GetProjectionMatrix(); pCmd->SetPipelineState(mRenderer.GetPSO(bMSAA ? EBuiltinPSOs::SKYDOME_PSO_MSAA_4 : EBuiltinPSOs::SKYDOME_PSO)); diff --git a/Source/Application/VQEngine_Update.cpp b/Source/Application/VQEngine_Update.cpp index 13c7a474..2eb2f4ab 100644 --- a/Source/Application/VQEngine_Update.cpp +++ b/Source/Application/VQEngine_Update.cpp @@ -127,6 +127,7 @@ void VQEngine::UpdateThread_UpdateAppState(const float dt) if (bLoadDone) { mpScene->OnLoadComplete(); + WaitUntilRenderingFinishes(); Log::Info("Update Thread loaded, starting simulation..."); mAppState = EAppState::SIMULATING; mbLoadingLevel.store(false); diff --git a/Source/Renderer/Renderer.cpp b/Source/Renderer/Renderer.cpp index 3b29b45f..982e258c 100644 --- a/Source/Renderer/Renderer.cpp +++ b/Source/Renderer/Renderer.cpp @@ -343,7 +343,7 @@ void VQRenderer::InitializeHeaps() mHeapUpload.Create(pDevice, UPLOAD_HEAP_SIZE); constexpr uint32 NumDescsCBV = 10; - constexpr uint32 NumDescsSRV = 10; + constexpr uint32 NumDescsSRV = 150; constexpr uint32 NumDescsUAV = 10; constexpr bool bCPUVisible = false; mHeapCBV_SRV_UAV.Create(pDevice, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV, NumDescsCBV + NumDescsSRV + NumDescsUAV, bCPUVisible); @@ -403,6 +403,7 @@ void VQRenderer::LoadPSOs() ID3D12RootSignature* pRS = nullptr; ThrowIfFailed(pDevice->CreateRootSignature(0, signature->GetBufferPointer(), signature->GetBufferSize(), IID_PPV_ARGS(&pRS))); mpBuiltinRootSignatures.push_back(pRS); + SetName(pRS, "RootSignature_HelloWorldTriangle"); } // Fullscreen-Triangle Root Signature : [1] @@ -446,6 +447,7 @@ void VQRenderer::LoadPSOs() ID3D12RootSignature* pRS = nullptr; ThrowIfFailed(pDevice->CreateRootSignature(0, signature->GetBufferPointer(), signature->GetBufferSize(), IID_PPV_ARGS(&pRS))); mpBuiltinRootSignatures.push_back(pRS); + SetName(pRS, "RootSignature_FSTriangle"); } // Hello-World-Cube Root Signature : [2] @@ -492,6 +494,7 @@ void VQRenderer::LoadPSOs() ID3D12RootSignature* pRS = nullptr; ThrowIfFailed(pDevice->CreateRootSignature(0, signature->GetBufferPointer(), signature->GetBufferSize(), IID_PPV_ARGS(&pRS))); mpBuiltinRootSignatures.push_back(pRS); + SetName(pRS, "RootSignature_HelloWorldCube"); } // Tonemapper Root Signature : [3] @@ -525,6 +528,59 @@ void VQRenderer::LoadPSOs() ID3D12RootSignature* pRS = nullptr; ThrowIfFailed(pDevice->CreateRootSignature(0, signature->GetBufferPointer(), signature->GetBufferSize(), IID_PPV_ARGS(&pRS))); mpBuiltinRootSignatures.push_back(pRS); + SetName(pRS, "RootSignature_Tonemapper"); + } + + // Object Root Signature : [4] + { + D3D12_FEATURE_DATA_ROOT_SIGNATURE featureData = {}; + + // This is the highest version the sample supports. If CheckFeatureSupport succeeds, the HighestVersion returned will not be greater than this. + featureData.HighestVersion = D3D_ROOT_SIGNATURE_VERSION_1_1; + if (FAILED(pDevice->CheckFeatureSupport(D3D12_FEATURE_ROOT_SIGNATURE, &featureData, sizeof(featureData)))) + { + featureData.HighestVersion = D3D_ROOT_SIGNATURE_VERSION_1_0; + } + + CD3DX12_DESCRIPTOR_RANGE1 ranges[2]; + ranges[0].Init(D3D12_DESCRIPTOR_RANGE_TYPE_SRV, 6, 0, 0, D3D12_DESCRIPTOR_RANGE_FLAG_DATA_VOLATILE/*D3D12_DESCRIPTOR_RANGE_FLAG_DATA_STATIC*/); + ranges[1].Init(D3D12_DESCRIPTOR_RANGE_TYPE_CBV, 1, 0, 0, D3D12_DESCRIPTOR_RANGE_FLAG_DATA_STATIC); + + CD3DX12_ROOT_PARAMETER1 rootParameters[2]; + rootParameters[0].InitAsDescriptorTable(1, &ranges[0], D3D12_SHADER_VISIBILITY_PIXEL); + rootParameters[1].InitAsConstantBufferView(0, 0, D3D12_ROOT_DESCRIPTOR_FLAG_DATA_VOLATILE, D3D12_SHADER_VISIBILITY_ALL); + + D3D12_STATIC_SAMPLER_DESC samplers[2] = {}; + D3D12_STATIC_SAMPLER_DESC sampler = {}; + sampler.Filter = D3D12_FILTER_MIN_MAG_MIP_LINEAR; + sampler.AddressU = D3D12_TEXTURE_ADDRESS_MODE_WRAP; + sampler.AddressV = D3D12_TEXTURE_ADDRESS_MODE_WRAP; + sampler.AddressW = D3D12_TEXTURE_ADDRESS_MODE_WRAP; + sampler.MipLODBias = 0; + sampler.MaxAnisotropy = 0; + sampler.ComparisonFunc = D3D12_COMPARISON_FUNC_NEVER; + sampler.BorderColor = D3D12_STATIC_BORDER_COLOR_TRANSPARENT_BLACK; + sampler.MinLOD = 0.0f; + sampler.MaxLOD = D3D12_FLOAT32_MAX; + sampler.ShaderRegister = 0; + sampler.RegisterSpace = 0; + sampler.ShaderVisibility = D3D12_SHADER_VISIBILITY_PIXEL; + samplers[0] = sampler; + + sampler.ShaderRegister = 1; + sampler.Filter = D3D12_FILTER_MIN_MAG_MIP_POINT; + samplers[1] = sampler; + + CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC rootSignatureDesc; + rootSignatureDesc.Init_1_1(_countof(rootParameters), rootParameters, _countof(samplers), &samplers[0], D3D12_ROOT_SIGNATURE_FLAG_ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT); + + ComPtr signature; + ComPtr error; + ThrowIfFailed(D3DX12SerializeVersionedRootSignature(&rootSignatureDesc, featureData.HighestVersion, &signature, &error)); + ID3D12RootSignature* pRS = nullptr; + ThrowIfFailed(pDevice->CreateRootSignature(0, signature->GetBufferPointer(), signature->GetBufferSize(), IID_PPV_ARGS(&pRS))); + mpBuiltinRootSignatures.push_back(pRS); + SetName(pRS, "RootSignature_Object"); } } @@ -612,6 +668,10 @@ void VQRenderer::LoadPSOs() if (FAILED(hr)) { ReportErrorAndReleaseBlob(errBlob); } ThrowIfFailed(D3DCompileFromFile(GetAssetFullPath(L"hello-cube.hlsl").c_str(), nullptr, nullptr, "PSMain", "ps_5_0", compileFlags, 0, &pixelShader, &errBlob)); + // TEST REFLECTION + //D3DReflect(vertexShader->GetBufferPointer(), vertexShader->GetBufferSize(), IID_ID3D12ShaderReflection, ppBuffer); + //vertexShader + // Define the vertex input layout. D3D12_INPUT_ELEMENT_DESC inputElementDescs[] = { @@ -713,6 +773,52 @@ void VQRenderer::LoadPSOs() ThrowIfFailed(pDevice->CreateComputePipelineState(&psoDesc, IID_PPV_ARGS(&mpBuiltinPSOs[EBuiltinPSOs::TONEMAPPER_PSO]))); SetName(mpBuiltinPSOs[EBuiltinPSOs::HELLO_WORLD_CUBE_PSO], "PSO_TonemapperCS"); } + + // OBJECT PSO + { + ComPtr vertexShader; + ComPtr pixelShader; + ComPtr errBlob; + + hr = D3DCompileFromFile(GetAssetFullPath(L"Object.hlsl").c_str(), nullptr, nullptr, "VSMain", "vs_5_1", compileFlags, 0, &vertexShader, &errBlob); + if (FAILED(hr)) { ReportErrorAndReleaseBlob(errBlob); } + ThrowIfFailed(D3DCompileFromFile(GetAssetFullPath(L"Object.hlsl").c_str(), nullptr, nullptr, "PSMain", "ps_5_1", compileFlags, 0, &pixelShader, &errBlob)); + + // Define the vertex input layout. + D3D12_INPUT_ELEMENT_DESC inputElementDescs[] = + { + { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT , 0, 0 , D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 }, + { "NORMAL" , 0, DXGI_FORMAT_R32G32B32_FLOAT , 0, 12, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 }, + { "TANGENT" , 0, DXGI_FORMAT_R32G32B32_FLOAT , 0, 24, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 }, + { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT , 0, 36, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 }, + }; + + // Describe and create the graphics pipeline state object (PSO). + D3D12_GRAPHICS_PIPELINE_STATE_DESC psoDesc = {}; + psoDesc.InputLayout = { inputElementDescs, _countof(inputElementDescs) }; + psoDesc.pRootSignature = mpBuiltinRootSignatures[4]; + psoDesc.VS = CD3DX12_SHADER_BYTECODE(vertexShader.Get()); + psoDesc.PS = CD3DX12_SHADER_BYTECODE(pixelShader.Get()); + psoDesc.RasterizerState = CD3DX12_RASTERIZER_DESC(D3D12_DEFAULT); + psoDesc.RasterizerState.CullMode = D3D12_CULL_MODE_NONE; + psoDesc.BlendState = CD3DX12_BLEND_DESC(D3D12_DEFAULT); + psoDesc.DepthStencilState.DepthEnable = TRUE; + psoDesc.DepthStencilState.DepthFunc = D3D12_COMPARISON_FUNC_LESS; + psoDesc.DepthStencilState.DepthWriteMask = D3D12_DEPTH_WRITE_MASK_ALL; + psoDesc.DepthStencilState.StencilEnable = FALSE; + psoDesc.DSVFormat = DXGI_FORMAT_D32_FLOAT; + psoDesc.SampleMask = UINT_MAX; + psoDesc.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE; + psoDesc.NumRenderTargets = 1; + psoDesc.RTVFormats[0] = DXGI_FORMAT_R16G16B16A16_FLOAT; + psoDesc.SampleDesc.Count = 1; + ThrowIfFailed(pDevice->CreateGraphicsPipelineState(&psoDesc, IID_PPV_ARGS(&mpBuiltinPSOs[EBuiltinPSOs::OBJECT_PSO]))); + SetName(mpBuiltinPSOs[EBuiltinPSOs::OBJECT_PSO], "PSO_Object"); + + psoDesc.SampleDesc.Count = 4; + ThrowIfFailed(pDevice->CreateGraphicsPipelineState(&psoDesc, IID_PPV_ARGS(&mpBuiltinPSOs[EBuiltinPSOs::OBJECT_PSO_MSAA_4]))); + SetName(mpBuiltinPSOs[EBuiltinPSOs::OBJECT_PSO_MSAA_4], "PSO_Object_MSAA4"); + } } void VQRenderer::LoadDefaultResources() diff --git a/Source/Renderer/Renderer.h b/Source/Renderer/Renderer.h index 667211aa..877af15e 100644 --- a/Source/Renderer/Renderer.h +++ b/Source/Renderer/Renderer.h @@ -83,6 +83,8 @@ enum EBuiltinPSOs // TODO: hardcoded PSOs until a generic Shader solution is int HDR_FP16_SWAPCHAIN_PSO, SKYDOME_PSO, SKYDOME_PSO_MSAA_4, + OBJECT_PSO, + OBJECT_PSO_MSAA_4, NUM_BUILTIN_PSOs }; diff --git a/Source/Renderer/Renderer_Resources.cpp b/Source/Renderer/Renderer_Resources.cpp index ac58f072..c5b6b7a4 100644 --- a/Source/Renderer/Renderer_Resources.cpp +++ b/Source/Renderer/Renderer_Resources.cpp @@ -24,6 +24,7 @@ #include "../../Libs/VQUtils/Source/Log.h" #include "../../Libs/VQUtils/Source/utils.h" +#include "../../Libs/VQUtils/Source/Timer.h" #include "../../Libs/D3D12MA/src/Common.h" #include @@ -84,7 +85,7 @@ TextureID VQRenderer::CreateTextureFromFile(const char* pFilePath) return it->second; } - + Timer t; t.Start(); Texture tex; // https://docs.microsoft.com/en-us/windows/win32/direct3d12/residency#heap-resources @@ -111,7 +112,7 @@ TextureID VQRenderer::CreateTextureFromFile(const char* pFilePath) ID = AddTexture_ThreadSafe(std::move(tex)); mLoadedTexturePaths[std::string(pFilePath)] = ID; #if LOG_RESOURCE_CREATE - Log::Info("VQRenderer::CreateTextureFromFile(): %s", pFilePath); + Log::Info("VQRenderer::CreateTextureFromFile(): [%.2fs] %s", t.StopGetDeltaTimeAndReset(), pFilePath); #endif } uploadHeap.Destroy(); // this is VERY expensive, TODO: find another solution. @@ -255,9 +256,25 @@ void VQRenderer::InitializeDSV(DSV_ID dsvID, uint32 heapIndex, TextureID texID) } void VQRenderer::InitializeSRV(SRV_ID srvID, uint heapIndex, TextureID texID) { - CHECK_TEXTURE(mTextures, texID); - CHECK_RESOURCE_VIEW(SRV, srvID); - mTextures.at(texID).InitializeSRV(heapIndex, &mSRVs.at(srvID)); + if (texID != INVALID_ID) + { + CHECK_TEXTURE(mTextures, texID); + CHECK_RESOURCE_VIEW(SRV, srvID); + mTextures.at(texID).InitializeSRV(heapIndex, &mSRVs.at(srvID)); + } + else // init NULL SRV + { + // Describe and create 2 null SRVs. Null descriptors are needed in order + // to achieve the effect of an "unbound" resource. + D3D12_SHADER_RESOURCE_VIEW_DESC nullSrvDesc = {}; + nullSrvDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2D; + nullSrvDesc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING; + nullSrvDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; + nullSrvDesc.Texture2D.MipLevels = 1; + nullSrvDesc.Texture2D.MostDetailedMip = 0; + nullSrvDesc.Texture2D.ResourceMinLODClamp = 0.0f; + mDevice.GetDevicePtr()->CreateShaderResourceView(nullptr, &nullSrvDesc, mSRVs.at(srvID).GetCPUDescHandle(heapIndex)); + } } void VQRenderer::InitializeRTV(RTV_ID rtvID, uint heapIndex, TextureID texID) { @@ -370,20 +387,25 @@ TextureID VQRenderer::AddTexture_ThreadSafe(Texture&& tex) } void VQRenderer::DestroyTexture(TextureID texID) { + // Remove texID std::lock_guard lk(mMtxTextures); mTextures.at(texID).Destroy(); mTextures.erase(texID); + // Remove texture path from cache std::string texPath = ""; + bool bTexturePathRegistered = false; for (const auto& path_id_pair : mLoadedTexturePaths) { if (path_id_pair.second == texID) { texPath = path_id_pair.first; + bTexturePathRegistered = true; break; } } - mLoadedTexturePaths.erase(texPath); + if (bTexturePathRegistered) + mLoadedTexturePaths.erase(texPath); } void VQRenderer::DestroySRV(SRV_ID srvID) { From b73e20f157464eb04b0f6f33343877c633b07525 Mon Sep 17 00:00:00 2001 From: Volkan Date: Wed, 26 Aug 2020 19:28:54 -0700 Subject: [PATCH 26/67] Material deserialization for gameobjects --- Data/Levels/Default.xml | 48 ++-- Data/Levels/GeometryUnitTest.xml | 44 +++- Data/Levels/Sponza.xml | 54 +---- Source/Application/AssetLoader.cpp | 311 +++++++++++++------------ Source/Application/AssetLoader.h | 18 ++ Source/Application/FileParser.cpp | 62 ++++- Source/Application/Material.cpp | 5 +- Source/Application/Material.h | 3 + Source/Application/Scene.cpp | 117 ++++++++-- Source/Application/Scene.h | 33 ++- Source/Application/VQEngine_Render.cpp | 5 +- Source/Renderer/Renderer.cpp | 20 +- Source/Renderer/Renderer.h | 15 +- Source/Renderer/Texture.cpp | 14 +- Source/Renderer/Texture.h | 2 +- Source/Scenes/StressTestScene.cpp | 37 ++- 16 files changed, 510 insertions(+), 278 deletions(-) diff --git a/Data/Levels/Default.xml b/Data/Levels/Default.xml index e14c9734..ae94d3a1 100644 --- a/Data/Levels/Default.xml +++ b/Data/Levels/Default.xml @@ -13,6 +13,7 @@ Stadium01 + 0.0 3.0 -5 15 @@ -29,27 +30,11 @@ 9.5 - - - - 0 0 4 - 0 0 0 1 - 3 3 3 - - - Cube - - - - - - - 6.0 3.0 -5 65 6 - + Orthographic 90.0 0.01 @@ -61,7 +46,30 @@ 9.5 + + + + Checkerboard + Procedural/Checkerboard + + + Checkerboard_Grayscale + Procedural/Checkerboard_Grayscale + + + + + 0 0 4 + 0 0 0 1 + 3 3 3 + + + Cube + Checkerboard + + + 0.0 3.0 -14 @@ -70,11 +78,7 @@ Cube - - - + Checkerboard_Grayscale - - \ No newline at end of file diff --git a/Data/Levels/GeometryUnitTest.xml b/Data/Levels/GeometryUnitTest.xml index 35e9681f..6af3971b 100644 --- a/Data/Levels/GeometryUnitTest.xml +++ b/Data/Levels/GeometryUnitTest.xml @@ -30,6 +30,30 @@ Stadium01 --> + + + + GreenMat + 0 0.5 0 + 0.5 + Data/Textures/PBR/cgbookcase/black-herringbone-tiles-01/Black_herringbone_tiles_01_2K_Base_Color.png + + + RedMat + 0.8 0.0 0 + 1 + + + Checkerboard + Procedural/Checkerboard + + + Checkerboard_Grayscale + Procedural/Checkerboard_Grayscale + + 0.0 3.0 -5 15 @@ -55,9 +79,7 @@ Cube - - - + GreenMat @@ -69,13 +91,23 @@ Triangle - - - + Checkerboard + + + -5 0 0 + 0 0 0 1 + 1 1 1 + + + Triangle + Checkerboard_Grayscale + + + diff --git a/Data/Levels/Sponza.xml b/Data/Levels/Sponza.xml index 3b1ae548..be5e31da 100644 --- a/Data/Levels/Sponza.xml +++ b/Data/Levels/Sponza.xml @@ -1,34 +1,7 @@ - - - - - - - 700.0 170.0 -50 @@ -46,7 +19,10 @@ - + + 0 0 0 @@ -58,21 +34,8 @@ Sponza - - - - 0 100 190 - 0 0 0 1 - 100 100 100 - - - Triangle - - - - - + 0 0 0 @@ -106,7 +69,10 @@ Sponza - + + diff --git a/Source/Application/AssetLoader.cpp b/Source/Application/AssetLoader.cpp index ae7c5e17..3ea22b08 100644 --- a/Source/Application/AssetLoader.cpp +++ b/Source/Application/AssetLoader.cpp @@ -35,139 +35,9 @@ using namespace Assimp; using namespace DirectX; -struct FMaterialTextureAssignments -{ - MaterialID matID = INVALID_ID; - std::vector DiffuseIDs; - std::vector SpecularIDs; - std::vector NormalsIDs; - std::vector HeightMapIDs; - std::vector AlphaMapIDs; -}; - -Model::Data ProcessAssimpNode( - aiNode* const pNode - , const aiScene* pAiScene - , const std::string& modelDirectory - , AssetLoader* pAssetLoader - , Scene* pScene - , VQRenderer* pRenderer - , std::vector& MaterialTextureAssignments -); - - -//---------------------------------------------------------------------------------------------------------------- -// IMPORTERS -//---------------------------------------------------------------------------------------------------------------- - -ModelID AssetLoader::ImportModel_obj(Scene* pScene, AssetLoader* pAssetLoader, VQRenderer* pRenderer, const std::string& objFilePath, std::string ModelName) -{ - constexpr auto ASSIMP_LOAD_FLAGS - = aiProcess_Triangulate - | aiProcess_CalcTangentSpace - | aiProcess_MakeLeftHanded - | aiProcess_FlipUVs - | aiProcess_FlipWindingOrder - //| aiProcess_TransformUVCoords - //| aiProcess_FixInfacingNormals - | aiProcess_JoinIdenticalVertices - | aiProcess_GenSmoothNormals; - - - const std::string modelDirectory = DirectoryUtil::GetFolderPath(objFilePath); - - Log::Info("ImportModel_obj: %s - %s", ModelName.c_str(), objFilePath.c_str()); - Timer t; - t.Start(); - - // Import Assimp Scene - Importer importer; - const aiScene* pAiScene = importer.ReadFile(objFilePath, ASSIMP_LOAD_FLAGS); - if (!pAiScene || pAiScene->mFlags & AI_SCENE_FLAGS_INCOMPLETE || !pAiScene->mRootNode) - { - Log::Error("Assimp error: %s", importer.GetErrorString()); - return INVALID_ID; - } - t.Tick(); float fTimeReadFile = t.DeltaTime(); - Log::Info(" ReadFile(): %.3fs", fTimeReadFile); - - // parse scene and initialize model data - std::vector MaterialTextureAssignments; - Model::Data data = ProcessAssimpNode(pAiScene->mRootNode, pAiScene, modelDirectory, pAssetLoader, pScene, pRenderer, MaterialTextureAssignments); - - pRenderer->UploadVertexAndIndexBufferHeaps(); // load VB/IBs - TextureLoadResults_t vTexLoadResults = pAssetLoader->StartLoadingTextures(); - - // cache the imported model in Scene - ModelID mID = pScene->CreateModel(); - Model& model = pScene->GetModel(mID); - model = Model(objFilePath, ModelName, std::move(data)); - - - // SYNC POINT - wait for textures to load - { - for (auto it = vTexLoadResults.begin(); it != vTexLoadResults.end(); ++it) - { - const MaterialID& matID = it->first; - const TextureLoadResult_t& result = it->second; - assert(result.texLoadResult.valid()); - result.texLoadResult.wait(); - } - } - - // assign TextureIDs to the materials; - for (FMaterialTextureAssignments& assignment : MaterialTextureAssignments) - { - Material& mat = pScene->GetMaterial(assignment.matID); - - auto pair_itBeginEnd = vTexLoadResults.equal_range(assignment.matID); - for (auto it = pair_itBeginEnd.first; it != pair_itBeginEnd.second; ++it) - { - const MaterialID& matID = it->first; - TextureLoadResult_t& result = it->second; - - assert(result.texLoadResult.valid()); - switch (result.type) - { - case DIFFUSE : mat.TexDiffuseMap = result.texLoadResult.get(); break; - case NORMALS : mat.TexNormalMap = result.texLoadResult.get(); break; - case ALPHA_MASK: mat.TexAlphaMaskMap = result.texLoadResult.get(); break; - case EMISSIVE : mat.TexEmissiveMap = result.texLoadResult.get(); break; - case METALNESS : mat.TexMetallicMap = result.texLoadResult.get(); break; - case ROUGHNESS : mat.TexRoughnessMap = result.texLoadResult.get(); break; - case SPECULAR : mat.TexSpecularMap = result.texLoadResult.get(); /*pRenderer->InitializeSRV(mat.SRVMaterialMaps, 0, mat.TexSpecularMap);*/ break; - case HEIGHT : mat.TexHeightMap = result.texLoadResult.get(); /*pRenderer->InitializeSRV(mat.SRVMaterialMaps, 0, mat.TexHeightMap) ;*/ break; - default: - Log::Warning("TODO"); - break; - } - } - - pRenderer->InitializeSRV(mat.SRVMaterialMaps, EMaterialTextureMapBindings::ALBEDO, mat.TexDiffuseMap); - pRenderer->InitializeSRV(mat.SRVMaterialMaps, EMaterialTextureMapBindings::NORMALS, mat.TexNormalMap); - pRenderer->InitializeSRV(mat.SRVMaterialMaps, EMaterialTextureMapBindings::ALPHA_MASK, mat.TexAlphaMaskMap); - pRenderer->InitializeSRV(mat.SRVMaterialMaps, EMaterialTextureMapBindings::EMISSIVE, mat.TexEmissiveMap); - pRenderer->InitializeSRV(mat.SRVMaterialMaps, EMaterialTextureMapBindings::METALLIC, mat.TexMetallicMap); - pRenderer->InitializeSRV(mat.SRVMaterialMaps, EMaterialTextureMapBindings::ROUGHNESS, mat.TexRoughnessMap); - } - - t.Stop(); - Log::Info("Loaded Model '%s' in %.2f seconds.", ModelName.c_str(), t.DeltaTime()); - return mID; -} - -ModelID AssetLoader::ImportModel_gltf(Scene* pScene, AssetLoader* pAssetLoader, VQRenderer* pRenderer, const std::string& objFilePath, std::string ModelName) -{ - assert(false); // TODO - return INVALID_ID; -} - - - //---------------------------------------------------------------------------------------------------------------- // ASSET LOADER //---------------------------------------------------------------------------------------------------------------- - void AssetLoader::QueueModelLoad(GameObject* pObject, const std::string& ModelPath, const std::string& ModelName) { const std::string FileExtension = DirectoryUtil::GetFileExtension(ModelPath); @@ -255,9 +125,21 @@ AssetLoader::TextureLoadResults_t AssetLoader::StartLoadingTextures() { mUniqueTexturePaths.insert(TexLoadParams.TexturePath); - std::future texLoadResult = std::move(mWorkers.AddTask([this, TexLoadParams]() + // determine whether we'll load file OR use a procedurally generated texture + auto vPathTokens = StrUtil::split(TexLoadParams.TexturePath, '/'); + assert(!vPathTokens.empty()); + const bool bProceduralTexture = vPathTokens[0] == "Procedural"; + + EProceduralTextures ProcTex = bProceduralTexture + ? VQRenderer::GetProceduralTextureEnumFromName(vPathTokens[1]) + : EProceduralTextures::NUM_PROCEDURAL_TEXTURES; + + std::future texLoadResult = std::move(mWorkers.AddTask([this, TexLoadParams, ProcTex]() { - return mRenderer.CreateTextureFromFile(TexLoadParams.TexturePath.c_str()); + const bool IS_PROCEDURAL = ProcTex != EProceduralTextures::NUM_PROCEDURAL_TEXTURES; + return IS_PROCEDURAL + ? mRenderer.GetProceduralTextureSRV_ID(ProcTex) + : mRenderer.CreateTextureFromFile(TexLoadParams.TexturePath.c_str()); })); TextureLoadResults.emplace(std::make_pair(TexLoadParams.MatID, TextureLoadResult_t{ TexLoadParams.TexType, std::move(texLoadResult) })); } @@ -310,6 +192,148 @@ static AssetLoader::ETextureType GetTextureType(aiTextureType aiType) return AssetLoader::ETextureType::NUM_TEXTURE_TYPES; } +void AssetLoader::FMaterialTextureAssignments::DoAssignments(Scene* pScene, VQRenderer* pRenderer) +{ + for (FMaterialTextureAssignment& assignment : mAssignments) + { + Material& mat = pScene->GetMaterial(assignment.matID); + + auto pair_itBeginEnd = mTextureLoadResults.equal_range(assignment.matID); + for (auto it = pair_itBeginEnd.first; it != pair_itBeginEnd.second; ++it) + { + const MaterialID& matID = it->first; + TextureLoadResult_t& result = it->second; + + assert(result.texLoadResult.valid()); + switch (result.type) + { + case DIFFUSE : mat.TexDiffuseMap = result.texLoadResult.get(); break; + case NORMALS : mat.TexNormalMap = result.texLoadResult.get(); break; + case ALPHA_MASK : mat.TexAlphaMaskMap = result.texLoadResult.get(); break; + case EMISSIVE : mat.TexEmissiveMap = result.texLoadResult.get(); break; + case METALNESS : mat.TexMetallicMap = result.texLoadResult.get(); break; + case ROUGHNESS : mat.TexRoughnessMap = result.texLoadResult.get(); break; + case SPECULAR : mat.TexSpecularMap = result.texLoadResult.get(); /*pRenderer->InitializeSRV(mat.SRVMaterialMaps, 0, mat.TexSpecularMap);*/ break; + case HEIGHT : mat.TexHeightMap = result.texLoadResult.get(); /*pRenderer->InitializeSRV(mat.SRVMaterialMaps, 0, mat.TexHeightMap) ;*/ break; + default: + Log::Warning("TODO"); + break; + } + } + + pRenderer->InitializeSRV(mat.SRVMaterialMaps, EMaterialTextureMapBindings::ALBEDO, mat.TexDiffuseMap); + pRenderer->InitializeSRV(mat.SRVMaterialMaps, EMaterialTextureMapBindings::NORMALS, mat.TexNormalMap); + pRenderer->InitializeSRV(mat.SRVMaterialMaps, EMaterialTextureMapBindings::ALPHA_MASK, mat.TexAlphaMaskMap); + pRenderer->InitializeSRV(mat.SRVMaterialMaps, EMaterialTextureMapBindings::EMISSIVE, mat.TexEmissiveMap); + pRenderer->InitializeSRV(mat.SRVMaterialMaps, EMaterialTextureMapBindings::METALLIC, mat.TexMetallicMap); + pRenderer->InitializeSRV(mat.SRVMaterialMaps, EMaterialTextureMapBindings::ROUGHNESS, mat.TexRoughnessMap); + } +} + +void AssetLoader::FMaterialTextureAssignments::WaitForTextureLoads() +{ + for (auto it = mTextureLoadResults.begin(); it != mTextureLoadResults.end(); ++it) + { + const MaterialID& matID = it->first; + const TextureLoadResult_t& result = it->second; + assert(result.texLoadResult.valid()); + result.texLoadResult.wait(); + } +} + +std::vector& AssetLoader::FMaterialTextureAssignment::GetTextureMapCollection(ETextureType type) +{ + switch (type) + { + case AssetLoader::DIFFUSE : return DiffuseIDs; + case AssetLoader::NORMALS : return NormalsIDs; + case AssetLoader::SPECULAR : assert(false); return DiffuseIDs; // currently not supported + case AssetLoader::ALPHA_MASK : return AlphaMapIDs; + case AssetLoader::EMISSIVE : assert(false); return DiffuseIDs; // TODO + case AssetLoader::HEIGHT : return HeightMapIDs; + case AssetLoader::METALNESS : assert(false); return DiffuseIDs; // TODO + case AssetLoader::ROUGHNESS : assert(false); return DiffuseIDs; // TODO + } + assert(false); return DiffuseIDs; +} + + +//---------------------------------------------------------------------------------------------------------------- +// IMPORTERS +//---------------------------------------------------------------------------------------------------------------- +Model::Data ProcessAssimpNode( + aiNode* const pNode + , const aiScene* pAiScene + , const std::string& modelDirectory + , AssetLoader* pAssetLoader + , Scene* pScene + , VQRenderer* pRenderer + , AssetLoader::FMaterialTextureAssignments& MaterialTextureAssignments +); + +ModelID AssetLoader::ImportModel_obj(Scene* pScene, AssetLoader* pAssetLoader, VQRenderer* pRenderer, const std::string& objFilePath, std::string ModelName) +{ + constexpr auto ASSIMP_LOAD_FLAGS + = aiProcess_Triangulate + | aiProcess_CalcTangentSpace + | aiProcess_MakeLeftHanded + | aiProcess_FlipUVs + | aiProcess_FlipWindingOrder + //| aiProcess_TransformUVCoords + //| aiProcess_FixInfacingNormals + | aiProcess_JoinIdenticalVertices + | aiProcess_GenSmoothNormals; + + + const std::string modelDirectory = DirectoryUtil::GetFolderPath(objFilePath); + + Log::Info("ImportModel_obj: %s - %s", ModelName.c_str(), objFilePath.c_str()); + Timer t; + t.Start(); + + // Import Assimp Scene + Importer importer; + const aiScene* pAiScene = importer.ReadFile(objFilePath, ASSIMP_LOAD_FLAGS); + if (!pAiScene || pAiScene->mFlags & AI_SCENE_FLAGS_INCOMPLETE || !pAiScene->mRootNode) + { + Log::Error("Assimp error: %s", importer.GetErrorString()); + return INVALID_ID; + } + t.Tick(); float fTimeReadFile = t.DeltaTime(); + Log::Info(" ReadFile(): %.3fs", fTimeReadFile); + + // parse scene and initialize model data + FMaterialTextureAssignments MaterialTextureAssignments; + Model::Data data = ProcessAssimpNode(pAiScene->mRootNode, pAiScene, modelDirectory, pAssetLoader, pScene, pRenderer, MaterialTextureAssignments); + + pRenderer->UploadVertexAndIndexBufferHeaps(); // load VB/IBs + MaterialTextureAssignments.mTextureLoadResults = pAssetLoader->StartLoadingTextures(); + + // cache the imported model in Scene + ModelID mID = pScene->CreateModel(); + Model& model = pScene->GetModel(mID); + model = Model(objFilePath, ModelName, std::move(data)); + + // SYNC POINT : wait for textures to load + { + MaterialTextureAssignments.WaitForTextureLoads(); + } + + // assign TextureIDs to the materials; + MaterialTextureAssignments.DoAssignments(pScene, pRenderer); + + t.Stop(); + Log::Info("Loaded Model '%s' in %.2f seconds.", ModelName.c_str(), t.DeltaTime()); + return mID; +} + +ModelID AssetLoader::ImportModel_gltf(Scene* pScene, AssetLoader* pAssetLoader, VQRenderer* pRenderer, const std::string& objFilePath, std::string ModelName) +{ + assert(false); // TODO + return INVALID_ID; +} + + //---------------------------------------------------------------------------------------------------------------- // ASSIMP HELPER FUNCTIONS @@ -403,7 +427,7 @@ static Model::Data ProcessAssimpNode( AssetLoader* pAssetLoader, Scene* pScene, VQRenderer* pRenderer, - std::vector& MaterialTextureAssignments + AssetLoader::FMaterialTextureAssignments& MaterialTextureAssignments ) { Model::Data modelData; @@ -427,14 +451,10 @@ static Model::Data ProcessAssimpNode( uniqueMatName = ModelFolderName + "/" + uniqueMatName; matID = pScene->CreateMaterial(uniqueMatName); Material& mat = pScene->GetMaterial(matID); - if (mat.SRVMaterialMaps == INVALID_ID) - { - mat.SRVMaterialMaps = pRenderer->CreateSRV(NUM_MATERIAL_TEXTURE_MAP_BINDINGS); - } } // get texture paths to load - FMaterialTextureAssignments MatAssignment = {}; + AssetLoader::FMaterialTextureAssignment MatTexAssignment = {}; std::vector diffuseMaps = GenerateTextureLoadParams(material, matID, aiTextureType_DIFFUSE, "texture_diffuse", modelDirectory); std::vector specularMaps = GenerateTextureLoadParams(material, matID, aiTextureType_SPECULAR, "texture_specular", modelDirectory); std::vector normalMaps = GenerateTextureLoadParams(material, matID, aiTextureType_NORMALS, "texture_normal", modelDirectory); @@ -442,16 +462,7 @@ static Model::Data ProcessAssimpNode( std::vector alphaMaps = GenerateTextureLoadParams(material, matID, aiTextureType_OPACITY, "texture_alpha", modelDirectory); // queue texture load - std::array TexLoadParams = { &diffuseMaps, &specularMaps, &normalMaps, &heightMaps, &alphaMaps }; - std::array*, 5> TexAssignParams = - { - &MatAssignment.DiffuseIDs - , &MatAssignment.SpecularIDs - , &MatAssignment.NormalsIDs - , &MatAssignment.HeightMapIDs - , &MatAssignment.AlphaMapIDs - }; - + std::array TexLoadParams = { &diffuseMaps, &specularMaps, &normalMaps, &heightMaps, &alphaMaps }; int iTexType = 0; for (const auto* pvLoadParams : TexLoadParams) { @@ -466,8 +477,8 @@ static Model::Data ProcessAssimpNode( // unflatten the material texture assignments - MatAssignment.matID = matID; - MaterialTextureAssignments.push_back(std::move(MatAssignment)); + MatTexAssignment.matID = matID; + MaterialTextureAssignments.mAssignments.push_back(std::move(MatTexAssignment)); Material& mat = pScene->GetMaterial(matID); diff --git a/Source/Application/AssetLoader.h b/Source/Application/AssetLoader.h index 4cd4af79..e47e2151 100644 --- a/Source/Application/AssetLoader.h +++ b/Source/Application/AssetLoader.h @@ -68,6 +68,24 @@ class AssetLoader using ModelLoadResults_t = std::unordered_map; using TextureLoadResult_t = FTextureLoadResult; using TextureLoadResults_t = std::unordered_multimap; + struct FMaterialTextureAssignment + { + MaterialID matID = INVALID_ID; + std::vector DiffuseIDs; + std::vector SpecularIDs; + std::vector NormalsIDs; + std::vector HeightMapIDs; + std::vector AlphaMapIDs; + std::vector& GetTextureMapCollection(ETextureType type); + }; + struct FMaterialTextureAssignments + { + std::vector mAssignments; + TextureLoadResults_t mTextureLoadResults; + + void DoAssignments(Scene* pScene, VQRenderer* pRenderer); + void WaitForTextureLoads(); + }; public: AssetLoader(ThreadPool& WorkerThreads, VQRenderer& renderer) : mWorkers(WorkerThreads) diff --git a/Source/Application/FileParser.cpp b/Source/Application/FileParser.cpp index f63fd617..da9a69f7 100644 --- a/Source/Application/FileParser.cpp +++ b/Source/Application/FileParser.cpp @@ -388,6 +388,7 @@ FSceneRepresentation VQEngine::ParseSceneFile(const std::string& SceneFile) constexpr char* XML_TAG__ENVIRONMENT_MAP_PRESET = "Preset"; constexpr char* XML_TAG__CAMERA = "Camera"; constexpr char* XML_TAG__GAMEOBJECT = "GameObject"; + constexpr char* XML_TAG__MATERIAL = "Material"; //----------------------------------------------------------------- constexpr char* SCENE_FILES_DIRECTORY = "Data/Levels/"; //----------------------------------------------------------------- @@ -476,7 +477,42 @@ FSceneRepresentation VQEngine::ParseSceneFile(const std::string& SceneFile) } return tf; }; - + auto fnParseMaterial = [&](XMLElement* pMat) -> FMaterialRepresentation + { + FMaterialRepresentation mat; + + XMLElement* pName = pMat->FirstChildElement("Name"); + XMLElement* pDiff = pMat->FirstChildElement("Diffuse"); + XMLElement* pAlph = pMat->FirstChildElement("Alpha"); + XMLElement* pEmsv = pMat->FirstChildElement("Emissive"); + XMLElement* pEmsI = pMat->FirstChildElement("EmissiveIntensity"); + XMLElement* pRgh = pMat->FirstChildElement("Roughness"); + XMLElement* pMtl = pMat->FirstChildElement("Metalness"); + //------------------------------------------------------------------ + XMLElement* pDiffMap = pMat->FirstChildElement("DiffuseMap"); + XMLElement* pNrmlMap = pMat->FirstChildElement("NormalMap"); + XMLElement* pEmsvMap = pMat->FirstChildElement("EmissiveMap"); + XMLElement* pAlphMap = pMat->FirstChildElement("AlphaMaskMap"); + XMLElement* pMtlMap = pMat->FirstChildElement("MetallicMap"); + XMLElement* pRghMap = pMat->FirstChildElement("RoughnessMap"); + + if (pName) fnParseXMLStringVal(pName, mat.Name); + if (pDiff) fnParseXMLFloat3Val(pDiff, mat.DiffuseColor); + if (pAlph) fnParseXMLFloatVal(pAlph, mat.Alpha); + if (pEmsv) fnParseXMLFloat3Val(pEmsI, mat.EmissiveColor); + if (pEmsI) fnParseXMLFloatVal(pEmsI, mat.EmissiveIntensity); + if (pRgh ) fnParseXMLFloatVal(pRgh , mat.Roughness); + if (pMtl ) fnParseXMLFloatVal(pMtl , mat.Metalness); + //------------------------------------------------------------------- + if (pDiffMap) fnParseXMLStringVal(pDiffMap, mat.DiffuseMapFilePath ); + if (pNrmlMap) fnParseXMLStringVal(pNrmlMap, mat.NormalMapFilePath ); + if (pEmsvMap) fnParseXMLStringVal(pEmsvMap, mat.EmissiveMapFilePath ); + if (pAlphMap) fnParseXMLStringVal(pAlphMap, mat.AlphaMaskMapFilePath); + if (pMtlMap ) fnParseXMLStringVal(pMtlMap , mat.MetallicMapFilePath ); + if (pRghMap ) fnParseXMLStringVal(pRghMap , mat.RoughnessMapFilePath); + + return mat; + }; //----------------------------------------------------------------- // Start reading scene XML file @@ -579,11 +615,17 @@ FSceneRepresentation VQEngine::ParseSceneFile(const std::string& SceneFile) SceneRep.Cameras.push_back(cam); } + // Materials + else if (XML_TAG__MATERIAL == CurrEle) + { + FMaterialRepresentation mat = fnParseMaterial(pCurrentSceneElement); + SceneRep.Materials.push_back(mat); + } // Game Objects else if (XML_TAG__GAMEOBJECT == CurrEle) { - GameObjectRepresentation obj; + FGameObjectRepresentation obj; XMLElement*& pObj = pCurrentSceneElement; XMLElement* pTransform = pObj->FirstChildElement("Transform"); @@ -595,31 +637,27 @@ FSceneRepresentation VQEngine::ParseSceneFile(const std::string& SceneFile) obj.tf = fnParseTransform(pTransform); } - // Model (WIP) + // Model if (pModel) { XMLElement* pMesh = pModel->FirstChildElement("Mesh"); - XMLElement* pMaterial = pModel->FirstChildElement("Material"); + XMLElement* pMaterial = pModel->FirstChildElement("MaterialName"); XMLElement* pModelPath = pModel->FirstChildElement("Path"); XMLElement* pModelName = pModel->FirstChildElement("Name"); - - + if (pMesh) fnParseXMLStringVal(pMesh, obj.BuiltinMeshName); - if (pMaterial) - { - // TODO - } + if (pMaterial) fnParseXMLStringVal(pMaterial, obj.MaterialName); if (pModelPath) fnParseXMLStringVal(pModelPath, obj.ModelFilePath); if (pModelName) fnParseXMLStringVal(pModelName, obj.ModelName); } - SceneRep.Objects.push_back(obj); } + pCurrentSceneElement = pCurrentSceneElement->NextSiblingElement(); } while (pCurrentSceneElement); - } + } // if (pScene) return SceneRep; } diff --git a/Source/Application/Material.cpp b/Source/Application/Material.cpp index 845325ac..ebc22cb9 100644 --- a/Source/Application/Material.cpp +++ b/Source/Application/Material.cpp @@ -14,4 +14,7 @@ // You should have received a copy of the GNU General Public License // along with this program.If not, see . // -// Contact: volkanilbeyli@gmail.com \ No newline at end of file +// Contact: volkanilbeyli@gmail.com + +#include "Material.h" +#include "Scene.h" diff --git a/Source/Application/Material.h b/Source/Application/Material.h index 6a1d5436..0bbe54d0 100644 --- a/Source/Application/Material.h +++ b/Source/Application/Material.h @@ -19,6 +19,8 @@ #pragma once #include +#include "Types.h" + enum EMaterialTextureMapBindings { ALBEDO = 0, @@ -67,6 +69,7 @@ struct Material // 56 Bytes //------------------------------------------------------------ inline bool IsTransparent() const { return alpha != 1.0f; } + #if 0 Material(MaterialID _ID); ~Material(); diff --git a/Source/Application/Scene.cpp b/Source/Application/Scene.cpp index 9c911fa1..5614e8b5 100644 --- a/Source/Application/Scene.cpp +++ b/Source/Application/Scene.cpp @@ -22,6 +22,8 @@ #include "Window.h" #include "VQEngine.h" +#include "Libs/VQUtils/Source/utils.h" + #define LOG_CACHED_RESOURCES_ON_LOAD 0 #define LOG_RESOURCE_CREATE 1 @@ -85,6 +87,18 @@ MaterialID Scene::CreateMaterial(const std::string& UniqueMaterialName) #if LOG_RESOURCE_CREATE Log::Info("Scene::CreateMaterial(): %s", UniqueMaterialName.c_str()); #endif + + Material& mat = mMaterials.at(id); + if (mat.SRVMaterialMaps == INVALID_ID) + { + mat.SRVMaterialMaps = mRenderer.CreateSRV(NUM_MATERIAL_TEXTURE_MAP_BINDINGS); + mRenderer.InitializeSRV(mat.SRVMaterialMaps, 0, INVALID_ID); + mRenderer.InitializeSRV(mat.SRVMaterialMaps, 1, INVALID_ID); + mRenderer.InitializeSRV(mat.SRVMaterialMaps, 2, INVALID_ID); + mRenderer.InitializeSRV(mat.SRVMaterialMaps, 3, INVALID_ID); + mRenderer.InitializeSRV(mat.SRVMaterialMaps, 4, INVALID_ID); + mRenderer.InitializeSRV(mat.SRVMaterialMaps, 5, INVALID_ID); + } return id; } @@ -167,19 +181,7 @@ void Scene::PostUpdate(int FRAME_DATA_INDEX, int FRAME_DATA_NEXT_INDEX) void Scene::StartLoading(const BuiltinMeshArray_t& builtinMeshes, FSceneRepresentation& scene) { constexpr bool B_LOAD_SERIAL = true; - - // register builtin meshes to scene mesh lookup - // @mMeshes[0-NUM_BUILTIN_MESHES] are assigned here directly while the rest - // of the meshes used in the scene must use this->AddMesh(Mesh&&) interface; - for (size_t i = 0; i < builtinMeshes.size(); ++i) - { - this->mMeshes[(int)i] = builtinMeshes[i]; - } - - // scene-specific load - this->LoadScene(scene); - - auto fnDeserializeGameObject = [&](GameObjectRepresentation& ObjRep, int i) + auto fnDeserializeGameObject = [&](FGameObjectRepresentation& ObjRep) { // GameObject GameObject* pObj = mGameObjectPool.Allocate(1); @@ -208,11 +210,15 @@ void Scene::StartLoading(const BuiltinMeshArray_t& builtinMeshes, FSceneRepresen MeshID meshID = mEngine.GetBuiltInMeshID(ObjRep.BuiltinMeshName); model.mData.mOpaueMeshIDs.push_back(meshID); - // TODO: material - std::string matName = "ObjMat"; - matName += std::to_string(i); - MaterialID matID = this->CreateMaterial(matName); - model.mData.mOpaqueMaterials[meshID] = matID; + // material + MaterialID matID = this->mDefaultMaterialID; + if (!ObjRep.MaterialName.empty()) + { + matID = this->CreateMaterial(ObjRep.MaterialName); + } + Material& mat = this->GetMaterial(matID); + const bool bTransparentMesh = mat.IsTransparent(); + model.mData.mOpaqueMaterials[meshID] = matID; // todo: handle transparency model.mbLoaded = true; pObj->mModelID = mID; @@ -221,18 +227,76 @@ void Scene::StartLoading(const BuiltinMeshArray_t& builtinMeshes, FSceneRepresen { mAssetLoader.QueueModelLoad(pObj, ObjRep.ModelFilePath, ObjRep.ModelName); } - + mpObjects.push_back(pObj); }; + // register builtin meshes to scene mesh lookup + // @mMeshes[0-NUM_BUILTIN_MESHES] are assigned here directly while the rest + // of the meshes used in the scene must use this->AddMesh(Mesh&&) interface; + for (size_t i = 0; i < builtinMeshes.size(); ++i) + { + this->mMeshes[(int)i] = builtinMeshes[i]; + } + + // register builtin materials + { + this->mDefaultMaterialID = this->CreateMaterial("DefaultMaterial"); + Material& mat = this->GetMaterial(this->mDefaultMaterialID); + } + + // scene-specific load + this->LoadScene(scene); + + // Create scene materials before deserializing gameobjects + for (const FMaterialRepresentation& matRep : scene.Materials) + { + MaterialID id = this->CreateMaterial(matRep.Name); + Material& mat = this->GetMaterial(id); + + auto fnAssignF = [](float& dest, const float& src) { if (src != MATERIAL_UNINITIALIZED_VALUE) dest = src; }; + auto fnAssignF3 = [](XMFLOAT3& dest, const XMFLOAT3& src) { if (src.x != MATERIAL_UNINITIALIZED_VALUE) dest = src; }; + auto fnEnqueueTexLoad = [&](MaterialID matID, const std::string& path, AssetLoader::ETextureType type) + { + if (path.empty()) return; + AssetLoader::FTextureLoadParams p = {}; + p.MatID = matID; + p.TexturePath = path; + p.TexType = type; + mAssetLoader.QueueTextureLoad(p); + }; + + // immediate values + fnAssignF(mat.alpha, matRep.Alpha); + fnAssignF(mat.metalness, matRep.Metalness); + fnAssignF(mat.roughness, matRep.Roughness); + fnAssignF(mat.emissiveIntensity, matRep.EmissiveIntensity); + fnAssignF3(mat.emissiveColor, matRep.EmissiveColor); + fnAssignF3(mat.diffuse, matRep.DiffuseColor); + + // async data (textures) + fnEnqueueTexLoad(id, matRep.DiffuseMapFilePath , AssetLoader::ETextureType::DIFFUSE); + fnEnqueueTexLoad(id, matRep.NormalMapFilePath , AssetLoader::ETextureType::NORMALS); + fnEnqueueTexLoad(id, matRep.EmissiveMapFilePath , AssetLoader::ETextureType::EMISSIVE); + fnEnqueueTexLoad(id, matRep.AlphaMaskMapFilePath, AssetLoader::ETextureType::ALPHA_MASK); + fnEnqueueTexLoad(id, matRep.MetallicMapFilePath , AssetLoader::ETextureType::METALNESS); + fnEnqueueTexLoad(id, matRep.RoughnessMapFilePath, AssetLoader::ETextureType::ROUGHNESS); + + AssetLoader::FMaterialTextureAssignment MatTexAssignment = {}; + MatTexAssignment.matID = id; + mMaterialAssignments.mAssignments.push_back(MatTexAssignment); + } + + // start loading material textures + mMaterialAssignments.mTextureLoadResults = mAssetLoader.StartLoadingTextures(); + if constexpr (B_LOAD_SERIAL) { // GAME OBJECTS - int i = 0; - for (GameObjectRepresentation& ObjRep : scene.Objects) + for (FGameObjectRepresentation& ObjRep : scene.Objects) { - fnDeserializeGameObject(ObjRep, i++); + fnDeserializeGameObject(ObjRep); } } else // THREADED LOAD @@ -272,7 +336,7 @@ void Scene::StartLoading(const BuiltinMeshArray_t& builtinMeshes, FSceneRepresen void Scene::OnLoadComplete() { - + // Assign model data for (auto it = mModelLoadResults.begin(); it != mModelLoadResults.end(); ++it) { GameObject* pObj = it->first; @@ -284,6 +348,8 @@ void Scene::OnLoadComplete() pObj->mModelID = res.get(); } + mMaterialAssignments.DoAssignments(this, &mRenderer); + Log::Info("[Scene] %s loaded.", mSceneRepresentation.SceneName.c_str()); mSceneRepresentation.loadSuccess = 1; this->InitializeScene(); @@ -351,3 +417,8 @@ void Scene::HandleInput() mEngine.StartLoadingEnvironmentMap(mIndex_ActiveEnvironmentMapPreset); } } + +FMaterialRepresentation::FMaterialRepresentation() + : DiffuseColor(MATERIAL_UNINITIALIZED_VALUE, MATERIAL_UNINITIALIZED_VALUE, MATERIAL_UNINITIALIZED_VALUE) + , EmissiveColor(MATERIAL_UNINITIALIZED_VALUE, MATERIAL_UNINITIALIZED_VALUE, MATERIAL_UNINITIALIZED_VALUE) +{} diff --git a/Source/Application/Scene.h b/Source/Application/Scene.h index 22de41c1..d4a4d248 100644 --- a/Source/Application/Scene.h +++ b/Source/Application/Scene.h @@ -32,7 +32,26 @@ struct Material; struct FResourceNames; //------------------------------------------------------ -struct GameObjectRepresentation +#define MATERIAL_UNINITIALIZED_VALUE -1.0f +struct FMaterialRepresentation +{ + std::string Name; + DirectX::XMFLOAT3 DiffuseColor; + float Alpha = MATERIAL_UNINITIALIZED_VALUE; + DirectX::XMFLOAT3 EmissiveColor; + float EmissiveIntensity = MATERIAL_UNINITIALIZED_VALUE; + float Metalness = MATERIAL_UNINITIALIZED_VALUE; + float Roughness = MATERIAL_UNINITIALIZED_VALUE; + std::string DiffuseMapFilePath ; + std::string NormalMapFilePath ; + std::string EmissiveMapFilePath ; + std::string AlphaMaskMapFilePath; + std::string MetallicMapFilePath ; + std::string RoughnessMapFilePath; + + FMaterialRepresentation(); +}; +struct FGameObjectRepresentation { Transform tf; @@ -40,15 +59,16 @@ struct GameObjectRepresentation std::string ModelFilePath; std::string BuiltinMeshName; - struct Material { float data[16]; }; + std::string MaterialName; }; struct FSceneRepresentation { std::string SceneName; std::string EnvironmentMapPreset; - std::vector Cameras; - std::vector Objects; + std::vector Materials; + std::vector Cameras; + std::vector Objects; //std::vector Lights; char loadSuccess = 0; @@ -211,6 +231,8 @@ class Scene BoundingBox mSceneBoundingBox; std::vector mMeshBoundingBoxes; std::vector mGameObjectBoundingBoxes; + MaterialID mDefaultMaterialID; + // // SCENE STATE @@ -244,7 +266,8 @@ class Scene std::mutex mMtx_Models; std::mutex mMtx_Materials; - AssetLoader::ModelLoadResults_t mModelLoadResults; + AssetLoader::ModelLoadResults_t mModelLoadResults; + AssetLoader::FMaterialTextureAssignments mMaterialAssignments; // cache std::unordered_map mLoadedMaterials; diff --git a/Source/Application/VQEngine_Render.cpp b/Source/Application/VQEngine_Render.cpp index 79feaa4c..41fbd329 100644 --- a/Source/Application/VQEngine_Render.cpp +++ b/Source/Application/VQEngine_Render.cpp @@ -177,13 +177,14 @@ void VQEngine::RenderThread_Exit() void VQEngine::InitializeBuiltinMeshes() { + using VertexType = FVertexWithNormalAndTangent; { - GeometryGenerator::GeometryData data = GeometryGenerator::Triangle(1.0f); + GeometryGenerator::GeometryData data = GeometryGenerator::Triangle(1.0f); mResourceNames.mBuiltinMeshNames[EBuiltInMeshes::TRIANGLE] = "Triangle"; mBuiltinMeshes[EBuiltInMeshes::TRIANGLE] = Mesh(&mRenderer, data.Vertices, data.Indices, mResourceNames.mBuiltinMeshNames[EBuiltInMeshes::TRIANGLE]); } { - GeometryGenerator::GeometryData data = GeometryGenerator::Cube(); + GeometryGenerator::GeometryData data = GeometryGenerator::Cube(); mResourceNames.mBuiltinMeshNames[EBuiltInMeshes::CUBE] = "Cube"; mBuiltinMeshes[EBuiltInMeshes::CUBE] = Mesh(&mRenderer, data.Vertices, data.Indices, mResourceNames.mBuiltinMeshNames[EBuiltInMeshes::CUBE]); } diff --git a/Source/Renderer/Renderer.cpp b/Source/Renderer/Renderer.cpp index 982e258c..b9d4ebc3 100644 --- a/Source/Renderer/Renderer.cpp +++ b/Source/Renderer/Renderer.cpp @@ -56,6 +56,16 @@ const std::string_view& VQRenderer::DXGIFormatAsString(DXGI_FORMAT format) return DXGI_FORMAT_STRING_TRANSLATION.at(format); } +EProceduralTextures VQRenderer::GetProceduralTextureEnumFromName(const std::string& ProceduralTextureName) +{ + static std::unordered_map MAP = + { + { "Checkerboard", EProceduralTextures::CHECKERBOARD } + , { "Checkerboard_Grayscale", EProceduralTextures::CHECKERBOARD_GRAYSCALE } + }; + return MAP.at(ProceduralTextureName); +} + // --------------------------------------------------------------------------------------- @@ -343,7 +353,7 @@ void VQRenderer::InitializeHeaps() mHeapUpload.Create(pDevice, UPLOAD_HEAP_SIZE); constexpr uint32 NumDescsCBV = 10; - constexpr uint32 NumDescsSRV = 150; + constexpr uint32 NumDescsSRV = 300; constexpr uint32 NumDescsUAV = 10; constexpr bool bCPUVisible = false; mHeapCBV_SRV_UAV.Create(pDevice, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV, NumDescsCBV + NumDescsSRV + NumDescsUAV, bCPUVisible); @@ -848,9 +858,13 @@ void VQRenderer::LoadDefaultResources() { std::vector texture = Texture::GenerateTexture_Checkerboard(sizeX); TextureID texID = this->CreateTexture("Checkerboard", textureDesc, D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE, texture.data()); - this->CreateAndInitializeSRV(texID); + mLookup_ProceduralTextureSRVs[EProceduralTextures::CHECKERBOARD] = this->CreateAndInitializeSRV(texID); + } + { + std::vector texture = Texture::GenerateTexture_Checkerboard(sizeX, true); + TextureID texID = this->CreateTexture("Checkerboard_Gray", textureDesc, D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE, texture.data()); + mLookup_ProceduralTextureSRVs[EProceduralTextures::CHECKERBOARD_GRAYSCALE] = this->CreateAndInitializeSRV(texID); } - } void VQRenderer::UploadVertexAndIndexBufferHeaps() { diff --git a/Source/Renderer/Renderer.h b/Source/Renderer/Renderer.h index 877af15e..397cca1e 100644 --- a/Source/Renderer/Renderer.h +++ b/Source/Renderer/Renderer.h @@ -89,6 +89,14 @@ enum EBuiltinPSOs // TODO: hardcoded PSOs until a generic Shader solution is int NUM_BUILTIN_PSOs }; +enum EProceduralTextures +{ + CHECKERBOARD = 0 + , CHECKERBOARD_GRAYSCALE + + , NUM_PROCEDURAL_TEXTURES +}; + // // RENDERER @@ -160,6 +168,9 @@ class VQRenderer inline const RTV& GetRTV(RTV_ID Id) const { return GetRenderTargetView(Id); } inline const DSV& GetDSV(DSV_ID Id) const { return GetDepthStencilView(Id); } + inline const SRV& GetProceduralTextureSRV(EProceduralTextures tex) const { return GetSRV(GetProceduralTextureSRV_ID(tex)); } + inline const SRV_ID GetProceduralTextureSRV_ID(EProceduralTextures tex) const { return mLookup_ProceduralTextureSRVs.at(tex); } + private: using PSOArray_t = std::array; @@ -213,7 +224,8 @@ class VQRenderer std::unordered_map mRenderContextLookup; // bookkeeping - std::unordered_map mLookup_TextureDiskLocations; + std::unordered_map mLookup_TextureDiskLocations; + std::unordered_map mLookup_ProceduralTextureSRVs; @@ -238,4 +250,5 @@ class VQRenderer public: static std::vector< VQSystemInfo::FGPUInfo > EnumerateDX12Adapters(bool bEnableDebugLayer, bool bEnumerateSoftwareAdapters = false, IDXGIFactory6* pFactory = nullptr); static const std::string_view& DXGIFormatAsString(DXGI_FORMAT format); + static EProceduralTextures GetProceduralTextureEnumFromName(const std::string& ProceduralTextureName); }; \ No newline at end of file diff --git a/Source/Renderer/Texture.cpp b/Source/Renderer/Texture.cpp index 0e52fcd8..f47d7414 100644 --- a/Source/Renderer/Texture.cpp +++ b/Source/Renderer/Texture.cpp @@ -328,7 +328,7 @@ void Texture::CreateRTV(uint32_t index, RTV* pRV, int mipLevel, int arraySize, i // // from Microsoft's D3D12HelloTexture -std::vector Texture::GenerateTexture_Checkerboard(uint Dimension) +std::vector Texture::GenerateTexture_Checkerboard(uint Dimension, bool bUseMidtones /*= false*/) { constexpr UINT TexturePixelSizeInBytes = 4; // byte/px const UINT& TextureWidth = Dimension; @@ -351,16 +351,16 @@ std::vector Texture::GenerateTexture_Checkerboard(uint Dimension) if (i % 2 == j % 2) { - pData[n + 0] = 0x00; // R - pData[n + 1] = 0x00; // G - pData[n + 2] = 0x00; // B + pData[n + 0] = bUseMidtones ? 0x03 : 0x00; // R + pData[n + 1] = bUseMidtones ? 0x03 : 0x00; // G + pData[n + 2] = bUseMidtones ? 0x03 : 0x00; // B pData[n + 3] = 0xff; // A } else { - pData[n + 0] = 0xff; // R - pData[n + 1] = 0xff; // G - pData[n + 2] = 0xff; // B + pData[n + 0] = bUseMidtones ? 0x1F : 0xff; // R + pData[n + 1] = bUseMidtones ? 0x1F : 0xff; // G + pData[n + 2] = bUseMidtones ? 0x1F : 0xff; // B pData[n + 3] = 0xff; // A } } diff --git a/Source/Renderer/Texture.h b/Source/Renderer/Texture.h index f48791a7..8ba6c33c 100644 --- a/Source/Renderer/Texture.h +++ b/Source/Renderer/Texture.h @@ -73,7 +73,7 @@ class Texture inline static DirectX::XMMATRIX CalculateViewMatrix(int face, const vec3& position = vec3::Zero) { return CalculateViewMatrix(static_cast(face), position); } #endif }; - static std::vector GenerateTexture_Checkerboard(uint Dimension); + static std::vector GenerateTexture_Checkerboard(uint Dimension, bool bUseMidtones = false); Texture() = default; ~Texture() = default; diff --git a/Source/Scenes/StressTestScene.cpp b/Source/Scenes/StressTestScene.cpp index 2f3922dd..8e9aa87e 100644 --- a/Source/Scenes/StressTestScene.cpp +++ b/Source/Scenes/StressTestScene.cpp @@ -21,6 +21,25 @@ void StressTestScene::InitializeScene() void StressTestScene::LoadScene(FSceneRepresentation& scene) { + // + // MATERIALS + // + FMaterialRepresentation matRep = {}; + matRep.Alpha = 1.0f; + matRep.DiffuseColor = { 1, 1, 1 }; + matRep.DiffuseMapFilePath = "Procedural/Checkerboard"; + matRep.Name = "Checkerboard"; + scene.Materials.push_back(matRep); + + matRep.DiffuseMapFilePath = "Procedural/Checkerboard_Grayscale"; + matRep.Name = "Checkerboard_Grayscale"; + scene.Materials.push_back(matRep); + + // + // OBJECTS + // + + // small cubes constexpr int NUM_OBJECTS = 1024; constexpr int DIMENSION_X = 16; @@ -29,6 +48,7 @@ void StressTestScene::LoadScene(FSceneRepresentation& scene) #if 0 for (int i = 0; i < NUM_OBJECTS; ++i) #else + int NumObjects = 0; constexpr float distance = 5.0f; for(int x=-DIMENSION_X/2; x Date: Wed, 26 Aug 2020 20:44:54 -0700 Subject: [PATCH 27/67] Fix flickering gamma --- Source/Application/Scene.cpp | 6 +++++- Source/Application/VQEngine_Update.cpp | 1 + 2 files changed, 6 insertions(+), 1 deletion(-) diff --git a/Source/Application/Scene.cpp b/Source/Application/Scene.cpp index 5614e8b5..049fe8fb 100644 --- a/Source/Application/Scene.cpp +++ b/Source/Application/Scene.cpp @@ -143,7 +143,8 @@ void Scene::Update(float dt, int FRAME_DATA_INDEX) void Scene::PostUpdate(int FRAME_DATA_INDEX, int FRAME_DATA_NEXT_INDEX) { assert(FRAME_DATA_INDEX < mFrameSceneViews.size()); - FSceneView& SceneView = mFrameSceneViews[FRAME_DATA_INDEX]; + FSceneView& SceneView = mFrameSceneViews[FRAME_DATA_INDEX]; + FSceneView& SceneViewNext = mFrameSceneViews[FRAME_DATA_NEXT_INDEX]; const Camera& cam = mCameras[mIndex_SelectedCamera]; const XMFLOAT3 camPos = cam.GetPositionF(); @@ -176,6 +177,9 @@ void Scene::PostUpdate(int FRAME_DATA_INDEX, int FRAME_DATA_NEXT_INDEX) SceneView.meshRenderCommands.push_back(meshRenderCmd); } } + + // update post process settings for next frame + SceneViewNext.postProcess = SceneView.postProcess; } void Scene::StartLoading(const BuiltinMeshArray_t& builtinMeshes, FSceneRepresentation& scene) diff --git a/Source/Application/VQEngine_Update.cpp b/Source/Application/VQEngine_Update.cpp index 2eb2f4ab..a87e7311 100644 --- a/Source/Application/VQEngine_Update.cpp +++ b/Source/Application/VQEngine_Update.cpp @@ -244,6 +244,7 @@ void VQEngine::HandleEngineInput() const int NumScenes = static_cast(mResourceNames.mSceneNames.size()); if (input.IsKeyTriggered("PageUp") && !mbLoadingLevel) { mIndex_SelectedScene = CircularIncrement(mIndex_SelectedScene, NumScenes); this->StartLoadingScene(mIndex_SelectedScene); } if (input.IsKeyTriggered("PageDown") && !mbLoadingLevel){ mIndex_SelectedScene = CircularDecrement(mIndex_SelectedScene, NumScenes - 1); this->StartLoadingScene(mIndex_SelectedScene); } + if (input.IsKeyTriggered("R") && !mbLoadingLevel) { this->StartLoadingScene(mIndex_SelectedScene); } // reload scene } if (input.IsKeyTriggered("1") && !mbLoadingLevel) { mIndex_SelectedScene = 0; this->StartLoadingScene(mIndex_SelectedScene); } if (input.IsKeyTriggered("2") && !mbLoadingLevel) { mIndex_SelectedScene = 1; this->StartLoadingScene(mIndex_SelectedScene); } From 2eea07ba87ca96a10a076eb2a84d4984061904a8 Mon Sep 17 00:00:00 2001 From: Volkan Date: Wed, 26 Aug 2020 21:18:48 -0700 Subject: [PATCH 28/67] Fix build script --- Build/PackageEngine.bat | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Build/PackageEngine.bat b/Build/PackageEngine.bat index 3178f1c8..737bb400 100644 --- a/Build/PackageEngine.bat +++ b/Build/PackageEngine.bat @@ -124,7 +124,7 @@ if !NO_BUILD! equ 0 ( :: Package the engine call :ExecBuildTask_Build - if %ERRORLEVEL% neq 0 exit /b %ERRORLEVEL% + if !ERRORLEVEL! neq 0 exit /b !ERRORLEVEL! ) :: move build artifacts into destination folder From c54b6ae323c4181abbae50e917540e70ec8a7440 Mon Sep 17 00:00:00 2001 From: Volkan Date: Wed, 26 Aug 2020 21:26:21 -0700 Subject: [PATCH 29/67] Fix build script: fail early when debug build fails --- Build/PackageEngine.bat | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Build/PackageEngine.bat b/Build/PackageEngine.bat index 737bb400..a5f3943b 100644 --- a/Build/PackageEngine.bat +++ b/Build/PackageEngine.bat @@ -85,7 +85,7 @@ for %%i IN (%*) DO ( ::echo SkipMSBuildFind=!MSBUILD_FIND! if !MSBUILD_FIND! equ 1 ( call :FindMSBuild - if %ERRORLEVEL% neq 0 ( + if !ERRORLEVEL! neq 0 ( echo [VQPackage] Error: Couldn't find MSBuild exit /b -1 ) @@ -191,7 +191,7 @@ if not exist !SOLUTION_FILE_PATH! ( echo ********************************************************************** echo. call %~dp0GenerateProjectFiles.bat -noVS - if %ERRORLEVEL% neq 0 ( + if !ERRORLEVEL! neq 0 ( echo [VQPackage] Error: Couldn't generate project files. exit /b -1 ) @@ -228,7 +228,7 @@ if !BUILD_CONFIG_DEBUG! neq 0 ( call :PrintBuildStage Debug call !ENGINE_BUILD_COMMAND! /p:Configuration=Debug set /A BUILD_NUM_CURR_TASK=!BUILD_NUM_CURR_TASK!+1 - if %ERRORLEVEL% neq 0 ( + if !ERRORLEVEL! neq 0 ( echo ERROR: BUILD ERROR exit /b -1 ) From 656d47b31662a77c0e87af499c260f85c6466d49 Mon Sep 17 00:00:00 2001 From: Volkan Date: Wed, 26 Aug 2020 21:43:29 -0700 Subject: [PATCH 30/67] Fix math library name collision --- Source/Application/Math.h | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/Source/Application/Math.h b/Source/Application/Math.h index f55b850c..a7bbd9bf 100644 --- a/Source/Application/Math.h +++ b/Source/Application/Math.h @@ -20,10 +20,11 @@ #include + #define DEG2RAD (DirectX::XM_PI / 180.0f) #define RAD2DEG (180.0f / DirectX::XM_PI) -#define PI DirectX::XM_PI -#define PI_DIV2 DirectX::XM_PIDIV2 +constexpr float PI_DIV2 = DirectX::XM_PIDIV2; +constexpr float PI = DirectX::XM_PI; constexpr DirectX::XMFLOAT3 UpVector = DirectX::XMFLOAT3( 0, 1, 0); constexpr DirectX::XMFLOAT3 RightVector = DirectX::XMFLOAT3( 1, 0, 0); From 959d8cd51ca21fe284916366c4af4c5611ebff14 Mon Sep 17 00:00:00 2001 From: Volkan Date: Thu, 27 Aug 2020 19:56:38 -0700 Subject: [PATCH 31/67] Fix packaging script building Release when -DebugOnly is specified --- Build/PackageEngine.bat | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/Build/PackageEngine.bat b/Build/PackageEngine.bat index a5f3943b..a92b7cba 100644 --- a/Build/PackageEngine.bat +++ b/Build/PackageEngine.bat @@ -218,20 +218,25 @@ exit /b 0 :ExecBuildTask_Build ::echo [VQPackage] ENGINE_BUILD_COMMAND = !ENGINE_BUILD_COMMAND! :: ---------------------- Build Release ---------------------- -call :PrintBuildStage Release -call !ENGINE_BUILD_COMMAND! /p:Configuration=Release -set /A ERR_REL=!ERRORLEVEL! -set /A BUILD_NUM_CURR_TASK=!BUILD_NUM_CURR_TASK!+1 +if !BUILD_CONFIG_RELEASE! neq 0 ( + call :PrintBuildStage Release + call !ENGINE_BUILD_COMMAND! /p:Configuration=Release + if !ERRORLEVEL! neq 0 ( + echo ERROR: BUILD ERROR + exit /b -1 + ) + set /A BUILD_NUM_CURR_TASK=!BUILD_NUM_CURR_TASK!+1 +) :: ---------------------- Build Release ---------------------- :: ---------------------- Build Debug ---------------------- if !BUILD_CONFIG_DEBUG! neq 0 ( call :PrintBuildStage Debug call !ENGINE_BUILD_COMMAND! /p:Configuration=Debug - set /A BUILD_NUM_CURR_TASK=!BUILD_NUM_CURR_TASK!+1 if !ERRORLEVEL! neq 0 ( echo ERROR: BUILD ERROR exit /b -1 ) + set /A BUILD_NUM_CURR_TASK=!BUILD_NUM_CURR_TASK!+1 ) :: ---------------------- Build Debug ---------------------- :: ---------------------- Build RelWithDebInfo---------------- From b14569e1ce8d6f1748974fc8955d16591363bfa7 Mon Sep 17 00:00:00 2001 From: Volkan Date: Wed, 2 Sep 2020 18:27:47 -0700 Subject: [PATCH 32/67] Add GPU markers using PIX event runtime --- CMakeLists.txt | 18 +- Libs/WinPixEventRuntime/.signature.p7s | Bin 0 -> 18690 bytes .../Include/WinPixEventRuntime/PIXEvents.h | 531 ++++++++++++++++ .../WinPixEventRuntime/PIXEventsCommon.h | 587 ++++++++++++++++++ .../Include/WinPixEventRuntime/pix3.h | 144 +++++ .../Include/WinPixEventRuntime/pix3_win.h | 48 ++ Libs/WinPixEventRuntime/ThirdPartyNotices.txt | 149 +++++ .../WinPixEventRuntime.nuspec | 18 + Libs/WinPixEventRuntime/[Content_Types].xml | 1 + Libs/WinPixEventRuntime/_rels/.rels | 1 + .../build/WinPixEventRuntime.targets | 68 ++ .../75b52844aad44082a4e6ddea0ac86508.psmdcp | 1 + Source/Application/GPUMarker.cpp | 37 ++ Source/Application/GPUMarker.h | 44 ++ Source/Application/VQEngine_Render.cpp | 103 +-- 15 files changed, 1704 insertions(+), 46 deletions(-) create mode 100644 Libs/WinPixEventRuntime/.signature.p7s create mode 100644 Libs/WinPixEventRuntime/Include/WinPixEventRuntime/PIXEvents.h create mode 100644 Libs/WinPixEventRuntime/Include/WinPixEventRuntime/PIXEventsCommon.h create mode 100644 Libs/WinPixEventRuntime/Include/WinPixEventRuntime/pix3.h create mode 100644 Libs/WinPixEventRuntime/Include/WinPixEventRuntime/pix3_win.h create mode 100644 Libs/WinPixEventRuntime/ThirdPartyNotices.txt create mode 100644 Libs/WinPixEventRuntime/WinPixEventRuntime.nuspec create mode 100644 Libs/WinPixEventRuntime/[Content_Types].xml create mode 100644 Libs/WinPixEventRuntime/_rels/.rels create mode 100644 Libs/WinPixEventRuntime/build/WinPixEventRuntime.targets create mode 100644 Libs/WinPixEventRuntime/package/services/metadata/core-properties/75b52844aad44082a4e6ddea0ac86508.psmdcp create mode 100644 Source/Application/GPUMarker.cpp create mode 100644 Source/Application/GPUMarker.h diff --git a/CMakeLists.txt b/CMakeLists.txt index fa7d75ed..a44f0596 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -67,6 +67,7 @@ set (HeaderVQE "Source/Application/Light.h" "Source/Application/GameObject.h" "Source/Application/Memory.h" + "Source/Application/GPUMarker.h" ) set (SourceVQE @@ -94,6 +95,11 @@ set (SourceVQE "Source/Application/Light.cpp" "Source/Application/GameObject.cpp" "Source/Application/Memory.cpp" + "Source/Application/GPUMarker.cpp" +) + +set (PIXIncl + "Libs/WinPixEventRuntime/Include" ) # ouput exe to bin directory @@ -118,7 +124,6 @@ add_subdirectory(Source/Renderer) #) add_subdirectory(Libs/assimp) - source_group("Config" FILES ${Config}) source_group("Resource" FILES ${Resource}) source_group("Icons" FILES ${Icons}) @@ -132,12 +137,14 @@ set_source_files_properties(Data/Resources/VQE.rc PROPERTIES VS_TOOL_OVERRIDE "R set_source_files_properties(Data/Icons/VQE32.ico PROPERTIES VS_TOOL_OVERRIDE "Image") link_directories(${CMAKE_CURRENT_SOURCE_DIR}/Libs/VQUtils/Bin/) +link_directories(${CMAKE_CURRENT_SOURCE_DIR}/Libs/WinPixEventRuntime/bin/x64) # Create a library with the project name that is build with the Headers and Source files add_executable( ${PROJECT_NAME} ${HeaderVQE} ${SourceVQE} ${Config} ${Scenes} ${Resource} ${Shaders} ) set_target_properties(${PROJECT_NAME} PROPERTIES VS_DEBUGGER_WORKING_DIRECTORY ${CMAKE_HOME_DIRECTORY} ) + # set target executable name for debug/releasewithdebug builds, release is VQE.exe foreach( OUTPUTCONFIG ${CMAKE_CONFIGURATION_TYPES} ) string( TOUPPER ${OUTPUTCONFIG} OUTPUTCONFIG ) @@ -162,6 +169,13 @@ set_target_properties(D3D12MA PROPERTIES FOLDER Libs) # Make sure the compiler can find include files for the libraries target_include_directories(${PROJECT_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR} ${Includes}) +target_include_directories(${PROJECT_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR} ${PIXIncl}) + +target_link_libraries(${PROJECT_NAME} PRIVATE VQUtils VQRenderer assimp WinPixEventRuntime) -target_link_libraries(${PROJECT_NAME} PRIVATE VQUtils VQRenderer assimp) +add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD + COMMAND ${CMAKE_COMMAND} -E copy_if_different + "${CMAKE_CURRENT_SOURCE_DIR}/Libs/WinPixEventRuntime/bin/x64/WinPixEventRuntime.dll" + $ +) diff --git a/Libs/WinPixEventRuntime/.signature.p7s b/Libs/WinPixEventRuntime/.signature.p7s new file mode 100644 index 0000000000000000000000000000000000000000..ee5fe84831ddd537a2ffda606d798cf749d59e31 GIT binary patch literal 18690 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 literal 0 HcmV?d00001 diff --git a/Libs/WinPixEventRuntime/Include/WinPixEventRuntime/PIXEvents.h b/Libs/WinPixEventRuntime/Include/WinPixEventRuntime/PIXEvents.h new file mode 100644 index 00000000..fc854f9a --- /dev/null +++ b/Libs/WinPixEventRuntime/Include/WinPixEventRuntime/PIXEvents.h @@ -0,0 +1,531 @@ +/*==========================================================================; + * + * Copyright (C) Microsoft Corporation. All Rights Reserved. + * + * File: PIXEvents.h + * Content: PIX include file + * Don't include this file directly - use pix3.h + * + ****************************************************************************/ +#pragma once + +#ifndef _PixEvents_H_ +#define _PixEvents_H_ + +#ifndef _PIX3_H_ +# error Do not include this file directly - use pix3.h +#endif + +#include "PIXEventsCommon.h" + +#if defined(XBOX) || defined(_XBOX_ONE) || defined(_DURANGO) +# define PIX_XBOX +#endif + +#if _MSC_VER < 1800 +# error This version of pix3.h is only supported on Visual Studio 2013 or higher +#elif _MSC_VER < 1900 +# ifndef constexpr // Visual Studio 2013 doesn't support constexpr +# define constexpr +# define PIX3__DEFINED_CONSTEXPR +# endif +#endif + +namespace PIXEventsDetail +{ + template + struct PIXEventTypeInferer + { + static constexpr PIXEventType Begin() { return PIXEvent_BeginEvent_VarArgs; } + static constexpr PIXEventType SetMarker() { return PIXEvent_SetMarker_VarArgs; } + static constexpr PIXEventType BeginOnContext() { return PIXEvent_BeginEvent_OnContext_VarArgs; } + static constexpr PIXEventType SetMarkerOnContext() { return PIXEvent_SetMarker_OnContext_VarArgs; } + + // Xbox and Windows store different types of events for context events. + // On Xbox these include a context argument, while on Windows they do + // not. It is important not to change the event types used on the + // Windows version as there are OS components (eg debug layer & DRED) + // that decode event structs. +#ifdef PIX_XBOX + static constexpr PIXEventType GpuBeginOnContext() { return PIXEvent_BeginEvent_OnContext_VarArgs; } + static constexpr PIXEventType GpuSetMarkerOnContext() { return PIXEvent_SetMarker_OnContext_VarArgs; } +#else + static constexpr PIXEventType GpuBeginOnContext() { return PIXEvent_BeginEvent_VarArgs; } + static constexpr PIXEventType GpuSetMarkerOnContext() { return PIXEvent_SetMarker_VarArgs; } +#endif + }; + + template<> + struct PIXEventTypeInferer + { + static constexpr PIXEventType Begin() { return PIXEvent_BeginEvent_NoArgs; } + static constexpr PIXEventType SetMarker() { return PIXEvent_SetMarker_NoArgs; } + static constexpr PIXEventType BeginOnContext() { return PIXEvent_BeginEvent_OnContext_NoArgs; } + static constexpr PIXEventType SetMarkerOnContext() { return PIXEvent_SetMarker_OnContext_NoArgs; } + +#ifdef PIX_XBOX + static constexpr PIXEventType GpuBeginOnContext() { return PIXEvent_BeginEvent_OnContext_NoArgs; } + static constexpr PIXEventType GpuSetMarkerOnContext() { return PIXEvent_SetMarker_OnContext_NoArgs; } +#else + static constexpr PIXEventType GpuBeginOnContext() { return PIXEvent_BeginEvent_NoArgs; } + static constexpr PIXEventType GpuSetMarkerOnContext() { return PIXEvent_SetMarker_NoArgs; } +#endif + }; + + inline void PIXCopyEventArguments(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit) + { + // nothing + } + + template + void PIXCopyEventArguments(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, ARG const& arg, ARGS const&... args) + { + PIXCopyEventArgument(destination, limit, arg); + PIXCopyEventArguments(destination, limit, args...); + } + + template + __declspec(noinline) void PIXBeginEventAllocate(PIXEventsThreadInfo* threadInfo, UINT64 color, STR formatString, ARGS... args) + { + UINT64 time = PIXEventsReplaceBlock(threadInfo, false); + if (!time) + return; + + UINT64* destination = threadInfo->destination; + UINT64* limit = threadInfo->biasedLimit; + if (destination >= limit) + return; + + limit += PIXEventsSafeFastCopySpaceQwords; + *destination++ = PIXEncodeEventInfo(time, PIXEventTypeInferer::Begin()); + *destination++ = color; + + PIXCopyEventArguments(destination, limit, formatString, args...); + + *destination = PIXEventsBlockEndMarker; + threadInfo->destination = destination; + } + + template + void PIXBeginEvent(UINT64 color, STR formatString, ARGS... args) + { + PIXEventsThreadInfo* threadInfo = PIXGetThreadInfo(); + UINT64* destination = threadInfo->destination; + UINT64* limit = threadInfo->biasedLimit; + + if (destination < limit) + { + limit += PIXEventsSafeFastCopySpaceQwords; + UINT64 time = PIXGetTimestampCounter(); + *destination++ = PIXEncodeEventInfo(time, PIXEventTypeInferer::Begin()); + *destination++ = color; + + PIXCopyEventArguments(destination, limit, formatString, args...); + + *destination = PIXEventsBlockEndMarker; + threadInfo->destination = destination; + } + else if (limit != nullptr) + { + PIXBeginEventAllocate(threadInfo, color, formatString); + } + } + + template + __declspec(noinline) void PIXSetMarkerAllocate(PIXEventsThreadInfo* threadInfo, UINT64 color, STR formatString, ARGS... args) + { + UINT64 time = PIXEventsReplaceBlock(threadInfo, false); + if (!time) + return; + + UINT64* destination = threadInfo->destination; + UINT64* limit = threadInfo->biasedLimit; + + if (destination >= limit) + return; + + limit += PIXEventsSafeFastCopySpaceQwords; + *destination++ = PIXEncodeEventInfo(time, PIXEventTypeInferer::SetMarker()); + *destination++ = color; + + PIXCopyEventArguments(destination, limit, formatString, args...); + + *destination = PIXEventsBlockEndMarker; + threadInfo->destination = destination; + } + + template + void PIXSetMarker(UINT64 color, STR formatString, ARGS... args) + { + PIXEventsThreadInfo* threadInfo = PIXGetThreadInfo(); + UINT64* destination = threadInfo->destination; + UINT64* limit = threadInfo->biasedLimit; + if (destination < limit) + { + limit += PIXEventsSafeFastCopySpaceQwords; + UINT64 time = PIXGetTimestampCounter(); + *destination++ = PIXEncodeEventInfo(time, PIXEventTypeInferer::SetMarker()); + *destination++ = color; + + PIXCopyEventArguments(destination, limit, formatString, args...); + + *destination = PIXEventsBlockEndMarker; + threadInfo->destination = destination; + } + else if (limit != nullptr) + { + PIXSetMarkerAllocate(threadInfo, color, formatString, args...); + } + } + +#if !PIX_XBOX + template + __declspec(noinline) void PIXBeginEventOnContextCpuAllocate(PIXEventsThreadInfo* threadInfo, void* context, UINT64 color, STR formatString, ARGS... args) + { + UINT64 time = PIXEventsReplaceBlock(threadInfo, false); + if (!time) + return; + + UINT64* destination = threadInfo->destination; + UINT64* limit = threadInfo->biasedLimit; + + if (destination >= limit) + return; + + limit += PIXEventsSafeFastCopySpaceQwords; + *destination++ = PIXEncodeEventInfo(time, PIXEventTypeInferer::BeginOnContext()); + *destination++ = color; + + PIXCopyEventArguments(destination, limit, context, formatString, args...); + + *destination = PIXEventsBlockEndMarker; + threadInfo->destination = destination; + } + + template + void PIXBeginEventOnContextCpu(void* context, UINT64 color, STR formatString, ARGS... args) + { + PIXEventsThreadInfo* threadInfo = PIXGetThreadInfo(); + UINT64* destination = threadInfo->destination; + UINT64* limit = threadInfo->biasedLimit; + if (destination < limit) + { + limit += PIXEventsSafeFastCopySpaceQwords; + UINT64 time = PIXGetTimestampCounter(); + *destination++ = PIXEncodeEventInfo(time, PIXEventTypeInferer::BeginOnContext()); + *destination++ = color; + + PIXCopyEventArguments(destination, limit, context, formatString, args...); + + *destination = PIXEventsBlockEndMarker; + threadInfo->destination = destination; + } + else if (limit != nullptr) + { + PIXBeginEventOnContextCpuAllocate(threadInfo, context, color, formatString, args...); + } + } +#endif + + template + void PIXBeginEvent(CONTEXT* context, UINT64 color, STR formatString, ARGS... args) + { +#if PIX_XBOX + PIXBeginEvent(color, formatString, args...); +#else + PIXBeginEventOnContextCpu(context, color, formatString, args...); +#endif + + // TODO: we've already encoded this once for the CPU event - figure out way to avoid doing it again + UINT64 buffer[PIXEventsGraphicsRecordSpaceQwords]; + UINT64* destination = buffer; + UINT64* limit = buffer + PIXEventsGraphicsRecordSpaceQwords - PIXEventsReservedTailSpaceQwords; + + *destination++ = PIXEncodeEventInfo(0, PIXEventTypeInferer::GpuBeginOnContext()); + *destination++ = color; + + PIXCopyEventArguments(destination, limit, formatString, args...); + *destination = 0ull; + + PIXBeginGPUEventOnContext(context, static_cast(buffer), static_cast(reinterpret_cast(destination) - reinterpret_cast(buffer))); + } + +#if !PIX_XBOX + template + __declspec(noinline) void PIXSetMarkerOnContextCpuAllocate(PIXEventsThreadInfo* threadInfo, void* context, UINT64 color, STR formatString, ARGS... args) + { + UINT64 time = PIXEventsReplaceBlock(threadInfo, false); + if (!time) + return; + + UINT64* destination = threadInfo->destination; + UINT64* limit = threadInfo->biasedLimit; + + if (destination >= limit) + return; + + limit += PIXEventsSafeFastCopySpaceQwords; + *destination++ = PIXEncodeEventInfo(time, PIXEventTypeInferer::SetMarkerOnContext()); + *destination++ = color; + + PIXCopyEventArguments(destination, limit, context, formatString, args...); + + *destination = PIXEventsBlockEndMarker; + threadInfo->destination = destination; + } + + template + void PIXSetMarkerOnContextCpu(void* context, UINT64 color, STR formatString, ARGS... args) + { + PIXEventsThreadInfo* threadInfo = PIXGetThreadInfo(); + UINT64* destination = threadInfo->destination; + UINT64* limit = threadInfo->biasedLimit; + if (destination < limit) + { + limit += PIXEventsSafeFastCopySpaceQwords; + UINT64 time = PIXGetTimestampCounter(); + *destination++ = PIXEncodeEventInfo(time, PIXEventTypeInferer::SetMarkerOnContext()); + *destination++ = color; + + PIXCopyEventArguments(destination, limit, context, formatString, args...); + + *destination = PIXEventsBlockEndMarker; + threadInfo->destination = destination; + } + else if (limit != nullptr) + { + PIXSetMarkerOnContextCpuAllocate(threadInfo, context, color, formatString, args...); + } + } +#endif + + template + void PIXSetMarker(CONTEXT* context, UINT64 color, STR formatString, ARGS... args) + { +#if PIX_XBOX + PIXSetMarker(color, formatString, args...); +#else + PIXSetMarkerOnContextCpu(context, color, formatString, args...); +#endif + + UINT64 buffer[PIXEventsGraphicsRecordSpaceQwords]; + UINT64* destination = buffer; + UINT64* limit = buffer + PIXEventsGraphicsRecordSpaceQwords - PIXEventsReservedTailSpaceQwords; + + *destination++ = PIXEncodeEventInfo(0, PIXEventTypeInferer::GpuSetMarkerOnContext()); + *destination++ = color; + + PIXCopyEventArguments(destination, limit, formatString, args...); + *destination = 0ull; + + PIXSetGPUMarkerOnContext(context, static_cast(buffer), static_cast(reinterpret_cast(destination) - reinterpret_cast(buffer))); + } + + __declspec(noinline) inline void PIXEndEventAllocate(PIXEventsThreadInfo* threadInfo) + { + UINT64 time = PIXEventsReplaceBlock(threadInfo, true); + if (!time) + return; + + UINT64* destination = threadInfo->destination; + UINT64* limit = threadInfo->biasedLimit; + + if (destination >= limit) + return; + + limit += PIXEventsSafeFastCopySpaceQwords; + *destination++ = PIXEncodeEventInfo(time, PIXEvent_EndEvent); + *destination = PIXEventsBlockEndMarker; + threadInfo->destination = destination; + } + + inline void PIXEndEvent() + { + PIXEventsThreadInfo* threadInfo = PIXGetThreadInfo(); + UINT64* destination = threadInfo->destination; + UINT64* limit = threadInfo->biasedLimit; + if (destination < limit) + { + limit += PIXEventsSafeFastCopySpaceQwords; + UINT64 time = PIXGetTimestampCounter(); + *destination++ = PIXEncodeEventInfo(time, PIXEvent_EndEvent); + *destination = PIXEventsBlockEndMarker; + threadInfo->destination = destination; + } + else if (limit != nullptr) + { + PIXEndEventAllocate(threadInfo); + } + } + +#if !PIX_XBOX + __declspec(noinline) inline void PIXEndEventOnContextCpuAllocate(PIXEventsThreadInfo* threadInfo, void* context) + { + UINT64 time = PIXEventsReplaceBlock(threadInfo, true); + if (!time) + return; + + UINT64* destination = threadInfo->destination; + UINT64* limit = threadInfo->biasedLimit; + + if (destination >= limit) + return; + + limit += PIXEventsSafeFastCopySpaceQwords; + *destination++ = PIXEncodeEventInfo(time, PIXEvent_EndEvent_OnContext); + PIXCopyEventArgument(destination, limit, context); + *destination = PIXEventsBlockEndMarker; + threadInfo->destination = destination; + } + + inline void PIXEndEventOnContextCpu(void* context) + { + PIXEventsThreadInfo* threadInfo = PIXGetThreadInfo(); + UINT64* destination = threadInfo->destination; + UINT64* limit = threadInfo->biasedLimit; + if (destination < limit) + { + limit += PIXEventsSafeFastCopySpaceQwords; + UINT64 time = PIXGetTimestampCounter(); + *destination++ = PIXEncodeEventInfo(time, PIXEvent_EndEvent_OnContext); + PIXCopyEventArgument(destination, limit, context); + *destination = PIXEventsBlockEndMarker; + threadInfo->destination = destination; + } + else if (limit != nullptr) + { + PIXEndEventOnContextCpuAllocate(threadInfo, context); + } + } +#endif + + template + void PIXEndEvent(CONTEXT* context) + { +#if PIX_XBOX + PIXEndEvent(); +#else + PIXEndEventOnContextCpu(context); +#endif + PIXEndGPUEventOnContext(context); + } + +} + +template +void PIXBeginEvent(UINT64 color, PCWSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXBeginEvent(color, formatString, args...); +} + +template +void PIXBeginEvent(UINT64 color, PCSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXBeginEvent(color, formatString, args...); +} + +template +void PIXSetMarker(UINT64 color, PCWSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXSetMarker(color, formatString, args...); +} + +template +void PIXSetMarker(UINT64 color, PCSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXSetMarker(color, formatString, args...); +} + +template +void PIXBeginEvent(CONTEXT* context, UINT64 color, PCWSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXBeginEvent(context, color, formatString, args...); +} + +template +void PIXBeginEvent(CONTEXT* context, UINT64 color, PCSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXBeginEvent(context, color, formatString, args...); +} + +template +void PIXSetMarker(CONTEXT* context, UINT64 color, PCWSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXSetMarker(context, color, formatString, args...); +} + +template +void PIXSetMarker(CONTEXT* context, UINT64 color, PCSTR formatString, ARGS... args) +{ + PIXEventsDetail::PIXSetMarker(context, color, formatString, args...); +} + +inline void PIXEndEvent() +{ + PIXEventsDetail::PIXEndEvent(); +} + +template +void PIXEndEvent(CONTEXT* context) +{ + PIXEventsDetail::PIXEndEvent(context); +} + +template +class PIXScopedEventObject +{ + CONTEXT* m_context; + +public: + template + PIXScopedEventObject(CONTEXT* context, UINT64 color, PCWSTR formatString, ARGS... args) + : m_context(context) + { + PIXBeginEvent(context, color, formatString, args...); + } + + template + PIXScopedEventObject(CONTEXT* context, UINT64 color, PCSTR formatString, ARGS... args) + : m_context(context) + { + PIXBeginEvent(context, color, formatString, args...); + } + + ~PIXScopedEventObject() + { + PIXEndEvent(m_context); + } +}; + +template<> +class PIXScopedEventObject +{ +public: + template + PIXScopedEventObject(UINT64 color, PCWSTR formatString, ARGS... args) + { + PIXBeginEvent(color, formatString, args...); + } + + template + PIXScopedEventObject(UINT64 color, PCSTR formatString, ARGS... args) + { + PIXBeginEvent(color, formatString, args...); + } + + ~PIXScopedEventObject() + { + PIXEndEvent(); + } +}; + +#define PIXConcatenate(a, b) a ## b +#define PIXGetScopedEventVariableName(a, b) PIXConcatenate(a, b) +#define PIXScopedEvent(context, ...) PIXScopedEventObject::Type> PIXGetScopedEventVariableName(pixEvent, __LINE__)(context, __VA_ARGS__) + +#ifdef PIX3__DEFINED_CONSTEXPR +#undef constexpr +#undef PIX3__DEFINED_CONSTEXPR +#endif + +#endif // _PIXEvents_H__ diff --git a/Libs/WinPixEventRuntime/Include/WinPixEventRuntime/PIXEventsCommon.h b/Libs/WinPixEventRuntime/Include/WinPixEventRuntime/PIXEventsCommon.h new file mode 100644 index 00000000..a2fac07d --- /dev/null +++ b/Libs/WinPixEventRuntime/Include/WinPixEventRuntime/PIXEventsCommon.h @@ -0,0 +1,587 @@ +/*==========================================================================; +* +* Copyright (C) Microsoft Corporation. All Rights Reserved. +* +* File: PIXEventsCommon.h +* Content: PIX include file +* Don't include this file directly - use pix3.h +* +****************************************************************************/ +#pragma once + +#ifndef _PIXEventsCommon_H_ +#define _PIXEventsCommon_H_ + +#include + +#if defined(_M_X64) || defined(_M_IX86) +#include +#endif + +// +// The PIXBeginEvent and PIXSetMarker functions have an optimized path for +// copying strings that work by copying 128-bit or 64-bits at a time. In some +// circumstances this may result in PIX logging the remaining memory after the +// null terminator. +// +// By default this optimization is enabled unless Address Sanitizer is enabled, +// since this optimization can trigger a global-buffer-overflow when copying +// string literals. +// +// The PIX_ENABLE_BLOCK_ARGUMENT_COPY controls whether or not this optimization +// is enabled. Applications may also explicitly set this macro to 0 to disable +// the optimization if necessary. +// + +#if defined(PIX_ENABLE_BLOCK_ARGUMENT_COPY) +// Previously set values override everything +# define PIX_ENABLE_BLOCK_ARGUMENT_COPY_SET 0 +#elif defined(__has_feature) +# if __has_feature(address_sanitizer) +// Disable block argument copy when address sanitizer is enabled +# define PIX_ENABLE_BLOCK_ARGUMENT_COPY 0 +# define PIX_ENABLE_BLOCK_ARGUMENT_COPY_SET 1 +# endif +#endif + +#if !defined(PIX_ENABLE_BLOCK_ARGUMENT_COPY) +// Default to enabled. +# define PIX_ENABLE_BLOCK_ARGUMENT_COPY 1 +# define PIX_ENABLE_BLOCK_ARGUMENT_COPY_SET 1 +#endif + +struct PIXEventsBlockInfo; + +struct PIXEventsThreadInfo +{ + PIXEventsBlockInfo* block; + UINT64* biasedLimit; + UINT64* destination; +}; + +extern "C" UINT64 WINAPI PIXEventsReplaceBlock(PIXEventsThreadInfo* threadInfo, bool getEarliestTime) noexcept; + +enum PIXEventType +{ + PIXEvent_EndEvent = 0x000, + PIXEvent_BeginEvent_VarArgs = 0x001, + PIXEvent_BeginEvent_NoArgs = 0x002, + PIXEvent_SetMarker_VarArgs = 0x007, + PIXEvent_SetMarker_NoArgs = 0x008, + + PIXEvent_EndEvent_OnContext = 0x010, + PIXEvent_BeginEvent_OnContext_VarArgs = 0x011, + PIXEvent_BeginEvent_OnContext_NoArgs = 0x012, + PIXEvent_SetMarker_OnContext_VarArgs = 0x017, + PIXEvent_SetMarker_OnContext_NoArgs = 0x018, +}; + +static const UINT64 PIXEventsReservedRecordSpaceQwords = 64; +//this is used to make sure SSE string copy always will end 16-byte write in the current block +//this way only a check if destination < limit can be performed, instead of destination < limit - 1 +//since both these are UINT64* and SSE writes in 16 byte chunks, 8 bytes are kept in reserve +//so even if SSE overwrites 8 extra bytes, those will still belong to the correct block +//on next iteration check destination will be greater than limit +//this is used as well for fixed size UMD events and PIXEndEvent since these require less space +//than other variable length user events and do not need big reserved space +static const UINT64 PIXEventsReservedTailSpaceQwords = 2; +static const UINT64 PIXEventsSafeFastCopySpaceQwords = PIXEventsReservedRecordSpaceQwords - PIXEventsReservedTailSpaceQwords; +static const UINT64 PIXEventsGraphicsRecordSpaceQwords = 64; + +//Bits 7-19 (13 bits) +static const UINT64 PIXEventsBlockEndMarker = 0x00000000000FFF80; + +//Bits 10-19 (10 bits) +static const UINT64 PIXEventsTypeReadMask = 0x00000000000FFC00; +static const UINT64 PIXEventsTypeWriteMask = 0x00000000000003FF; +static const UINT64 PIXEventsTypeBitShift = 10; + +//Bits 20-63 (44 bits) +static const UINT64 PIXEventsTimestampReadMask = 0xFFFFFFFFFFF00000; +static const UINT64 PIXEventsTimestampWriteMask = 0x00000FFFFFFFFFFF; +static const UINT64 PIXEventsTimestampBitShift = 20; + +inline UINT64 PIXEncodeEventInfo(UINT64 timestamp, PIXEventType eventType) +{ + return ((timestamp & PIXEventsTimestampWriteMask) << PIXEventsTimestampBitShift) | + (((UINT64)eventType & PIXEventsTypeWriteMask) << PIXEventsTypeBitShift); +} + +//Bits 60-63 (4) +static const UINT64 PIXEventsStringAlignmentWriteMask = 0x000000000000000F; +static const UINT64 PIXEventsStringAlignmentReadMask = 0xF000000000000000; +static const UINT64 PIXEventsStringAlignmentBitShift = 60; + +//Bits 55-59 (5) +static const UINT64 PIXEventsStringCopyChunkSizeWriteMask = 0x000000000000001F; +static const UINT64 PIXEventsStringCopyChunkSizeReadMask = 0x0F80000000000000; +static const UINT64 PIXEventsStringCopyChunkSizeBitShift = 55; + +//Bit 54 +static const UINT64 PIXEventsStringIsANSIWriteMask = 0x0000000000000001; +static const UINT64 PIXEventsStringIsANSIReadMask = 0x0040000000000000; +static const UINT64 PIXEventsStringIsANSIBitShift = 54; + +//Bit 53 +static const UINT64 PIXEventsStringIsShortcutWriteMask = 0x0000000000000001; +static const UINT64 PIXEventsStringIsShortcutReadMask = 0x0020000000000000; +static const UINT64 PIXEventsStringIsShortcutBitShift = 53; + +inline UINT64 PIXEncodeStringInfo(UINT64 alignment, UINT64 copyChunkSize, BOOL isANSI, BOOL isShortcut) +{ + return ((alignment & PIXEventsStringAlignmentWriteMask) << PIXEventsStringAlignmentBitShift) | + ((copyChunkSize & PIXEventsStringCopyChunkSizeWriteMask) << PIXEventsStringCopyChunkSizeBitShift) | + (((UINT64)isANSI & PIXEventsStringIsANSIWriteMask) << PIXEventsStringIsANSIBitShift) | + (((UINT64)isShortcut & PIXEventsStringIsShortcutWriteMask) << PIXEventsStringIsShortcutBitShift); +} + +template +inline bool PIXIsPointerAligned(T* pointer) +{ + return !(((UINT64)pointer) & (alignment - 1)); +} + +// Generic template version slower because of the additional clear write +template +inline void PIXCopyEventArgument(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, T argument) +{ + if (destination < limit) + { + *destination = 0ull; + *((T*)destination) = argument; + ++destination; + } +} + +// int32 specialization to avoid slower double memory writes +template<> +inline void PIXCopyEventArgument(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, INT32 argument) +{ + if (destination < limit) + { + *reinterpret_cast(destination) = static_cast(argument); + ++destination; + } +} + +// unsigned int32 specialization to avoid slower double memory writes +template<> +inline void PIXCopyEventArgument(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, UINT32 argument) +{ + if (destination < limit) + { + *destination = static_cast(argument); + ++destination; + } +} + +// int64 specialization to avoid slower double memory writes +template<> +inline void PIXCopyEventArgument(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, INT64 argument) +{ + if (destination < limit) + { + *reinterpret_cast(destination) = argument; + ++destination; + } +} + +// unsigned int64 specialization to avoid slower double memory writes +template<> +inline void PIXCopyEventArgument(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, UINT64 argument) +{ + if (destination < limit) + { + *destination = argument; + ++destination; + } +} + +//floats must be cast to double during writing the data to be properly printed later when reading the data +//this is needed because when float is passed to varargs function it's cast to double +template<> +inline void PIXCopyEventArgument(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, float argument) +{ + if (destination < limit) + { + *reinterpret_cast(destination) = static_cast(argument); + ++destination; + } +} + +//char has to be cast to a longer signed integer type +//this is due to printf not ignoring correctly the upper bits of unsigned long long for a char format specifier +template<> +inline void PIXCopyEventArgument(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, char argument) +{ + if (destination < limit) + { + *reinterpret_cast(destination) = static_cast(argument); + ++destination; + } +} + +//unsigned char has to be cast to a longer unsigned integer type +//this is due to printf not ignoring correctly the upper bits of unsigned long long for a char format specifier +template<> +inline void PIXCopyEventArgument(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, unsigned char argument) +{ + if (destination < limit) + { + *destination = static_cast(argument); + ++destination; + } +} + +//bool has to be cast to an integer since it's not explicitly supported by string format routines +//there's no format specifier for bool type, but it should work with integer format specifiers +template<> +inline void PIXCopyEventArgument(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, bool argument) +{ + if (destination < limit) + { + *destination = static_cast(argument); + ++destination; + } +} + +inline void PIXCopyEventArgumentSlowest(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PCSTR argument) +{ + *destination++ = PIXEncodeStringInfo(0, 8, TRUE, FALSE); + while (destination < limit) + { + UINT64 c = static_cast(argument[0]); + if (!c) + { + *destination++ = 0; + return; + } + UINT64 x = c; + c = static_cast(argument[1]); + if (!c) + { + *destination++ = x; + return; + } + x |= c << 8; + c = static_cast(argument[2]); + if (!c) + { + *destination++ = x; + return; + } + x |= c << 16; + c = static_cast(argument[3]); + if (!c) + { + *destination++ = x; + return; + } + x |= c << 24; + c = static_cast(argument[4]); + if (!c) + { + *destination++ = x; + return; + } + x |= c << 32; + c = static_cast(argument[5]); + if (!c) + { + *destination++ = x; + return; + } + x |= c << 40; + c = static_cast(argument[6]); + if (!c) + { + *destination++ = x; + return; + } + x |= c << 48; + c = static_cast(argument[7]); + if (!c) + { + *destination++ = x; + return; + } + x |= c << 56; + *destination++ = x; + argument += 8; + } +} + +inline void PIXCopyEventArgumentSlow(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PCSTR argument) +{ +#if PIX_ENABLE_BLOCK_ARGUMENT_COPY + if (PIXIsPointerAligned<8>(argument)) + { + *destination++ = PIXEncodeStringInfo(0, 8, TRUE, FALSE); + UINT64* source = (UINT64*)argument; + while (destination < limit) + { + UINT64 qword = *source++; + *destination++ = qword; + //check if any of the characters is a terminating zero + if (!((qword & 0xFF00000000000000) && + (qword & 0xFF000000000000) && + (qword & 0xFF0000000000) && + (qword & 0xFF00000000) && + (qword & 0xFF000000) && + (qword & 0xFF0000) && + (qword & 0xFF00) && + (qword & 0xFF))) + { + break; + } + } + } + else +#endif // PIX_ENABLE_BLOCK_ARGUMENT_COPY + { + PIXCopyEventArgumentSlowest(destination, limit, argument); + } +} + +template<> +inline void PIXCopyEventArgument(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PCSTR argument) +{ + if (destination < limit) + { + if (argument != nullptr) + { +#if (defined(_M_X64) || defined(_M_IX86)) && PIX_ENABLE_BLOCK_ARGUMENT_COPY + if (PIXIsPointerAligned<16>(argument)) + { + *destination++ = PIXEncodeStringInfo(0, 16, TRUE, FALSE); + __m128i zero = _mm_setzero_si128(); + if (PIXIsPointerAligned<16>(destination)) + { + while (destination < limit) + { + __m128i mem = _mm_load_si128((__m128i*)argument); + _mm_store_si128((__m128i*)destination, mem); + //check if any of the characters is a terminating zero + __m128i res = _mm_cmpeq_epi8(mem, zero); + destination += 2; + if (_mm_movemask_epi8(res)) + break; + argument += 16; + } + } + else + { + while (destination < limit) + { + __m128i mem = _mm_load_si128((__m128i*)argument); + _mm_storeu_si128((__m128i*)destination, mem); + //check if any of the characters is a terminating zero + __m128i res = _mm_cmpeq_epi8(mem, zero); + destination += 2; + if (_mm_movemask_epi8(res)) + break; + argument += 16; + } + } + } + else +#endif // (defined(_M_X64) || defined(_M_IX86)) && PIX_ENABLE_BLOCK_ARGUMENT_COPY + { + PIXCopyEventArgumentSlow(destination, limit, argument); + } + } + else + { + *destination++ = 0ull; + } + } +} + +template<> +inline void PIXCopyEventArgument(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PSTR argument) +{ + PIXCopyEventArgument(destination, limit, (PCSTR)argument); +} + +inline void PIXCopyEventArgumentSlowest(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PCWSTR argument) +{ + *destination++ = PIXEncodeStringInfo(0, 8, FALSE, FALSE); + while (destination < limit) + { + UINT64 c = static_cast(argument[0]); + if (!c) + { + *destination++ = 0; + return; + } + UINT64 x = c; + c = static_cast(argument[1]); + if (!c) + { + *destination++ = x; + return; + } + x |= c << 16; + c = static_cast(argument[2]); + if (!c) + { + *destination++ = x; + return; + } + x |= c << 32; + c = static_cast(argument[3]); + if (!c) + { + *destination++ = x; + return; + } + x |= c << 48; + *destination++ = x; + argument += 4; + } +} + +inline void PIXCopyEventArgumentSlow(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PCWSTR argument) +{ +#if PIX_ENABLE_BLOCK_ARGUMENT_COPY + if (PIXIsPointerAligned<8>(argument)) + { + *destination++ = PIXEncodeStringInfo(0, 8, FALSE, FALSE); + UINT64* source = (UINT64*)argument; + while (destination < limit) + { + UINT64 qword = *source++; + *destination++ = qword; + //check if any of the characters is a terminating zero + //TODO: check if reversed condition is faster + if (!((qword & 0xFFFF000000000000) && + (qword & 0xFFFF00000000) && + (qword & 0xFFFF0000) && + (qword & 0xFFFF))) + { + break; + } + } + } + else +#endif // PIX_ENABLE_BLOCK_ARGUMENT_COPY + { + PIXCopyEventArgumentSlowest(destination, limit, argument); + } +} + +template<> +inline void PIXCopyEventArgument(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PCWSTR argument) +{ + if (destination < limit) + { + if (argument != nullptr) + { +#if (defined(_M_X64) || defined(_M_IX86)) && PIX_ENABLE_BLOCK_ARGUMENT_COPY + if (PIXIsPointerAligned<16>(argument)) + { + *destination++ = PIXEncodeStringInfo(0, 16, FALSE, FALSE); + __m128i zero = _mm_setzero_si128(); + if (PIXIsPointerAligned<16>(destination)) + { + while (destination < limit) + { + __m128i mem = _mm_load_si128((__m128i*)argument); + _mm_store_si128((__m128i*)destination, mem); + //check if any of the characters is a terminating zero + __m128i res = _mm_cmpeq_epi16(mem, zero); + destination += 2; + if (_mm_movemask_epi8(res)) + break; + argument += 8; + } + } + else + { + while (destination < limit) + { + __m128i mem = _mm_load_si128((__m128i*)argument); + _mm_storeu_si128((__m128i*)destination, mem); + //check if any of the characters is a terminating zero + __m128i res = _mm_cmpeq_epi16(mem, zero); + destination += 2; + if (_mm_movemask_epi8(res)) + break; + argument += 8; + } + } + } + else +#endif // (defined(_M_X64) || defined(_M_IX86)) && PIX_ENABLE_BLOCK_ARGUMENT_COPY + { + PIXCopyEventArgumentSlow(destination, limit, argument); + } + } + else + { + *destination++ = 0ull; + } + } +} + +template<> +inline void PIXCopyEventArgument(_Out_writes_to_ptr_(limit) UINT64*& destination, _In_ const UINT64* limit, _In_ PWSTR argument) +{ + PIXCopyEventArgument(destination, limit, (PCWSTR)argument); +}; + +#if defined(__d3d12_x_h__) || defined(__d3d12_h__) + +inline void PIXSetGPUMarkerOnContext(_In_ ID3D12GraphicsCommandList* commandList, _In_reads_bytes_(size) void* data, UINT size) +{ + commandList->SetMarker(D3D12_EVENT_METADATA, data, size); +} + +inline void PIXSetGPUMarkerOnContext(_In_ ID3D12CommandQueue* commandQueue, _In_reads_bytes_(size) void* data, UINT size) +{ + commandQueue->SetMarker(D3D12_EVENT_METADATA, data, size); +} + +inline void PIXBeginGPUEventOnContext(_In_ ID3D12GraphicsCommandList* commandList, _In_reads_bytes_(size) void* data, UINT size) +{ + commandList->BeginEvent(D3D12_EVENT_METADATA, data, size); +} + +inline void PIXBeginGPUEventOnContext(_In_ ID3D12CommandQueue* commandQueue, _In_reads_bytes_(size) void* data, UINT size) +{ + commandQueue->BeginEvent(D3D12_EVENT_METADATA, data, size); +} + +inline void PIXEndGPUEventOnContext(_In_ ID3D12GraphicsCommandList* commandList) +{ + commandList->EndEvent(); +} + +inline void PIXEndGPUEventOnContext(_In_ ID3D12CommandQueue* commandQueue) +{ + commandQueue->EndEvent(); +} + +#endif //__d3d12_x_h__ + +template struct PIXInferScopedEventType { typedef T Type; }; +template struct PIXInferScopedEventType { typedef T Type; }; +template struct PIXInferScopedEventType { typedef T Type; }; +template struct PIXInferScopedEventType { typedef T Type; }; +template<> struct PIXInferScopedEventType { typedef void Type; }; +template<> struct PIXInferScopedEventType { typedef void Type; }; +template<> struct PIXInferScopedEventType { typedef void Type; }; +template<> struct PIXInferScopedEventType { typedef void Type; }; +template<> struct PIXInferScopedEventType { typedef void Type; }; +template<> struct PIXInferScopedEventType { typedef void Type; }; +template<> struct PIXInferScopedEventType { typedef void Type; }; +template<> struct PIXInferScopedEventType { typedef void Type; }; + + +#if PIX_ENABLE_BLOCK_ARGUMENT_COPY_SET +#undef PIX_ENABLE_BLOCK_ARGUMENT_COPY +#endif + +#undef PIX_ENABLE_BLOCK_ARGUMENT_COPY_SET + +#endif //_PIXEventsCommon_H_ diff --git a/Libs/WinPixEventRuntime/Include/WinPixEventRuntime/pix3.h b/Libs/WinPixEventRuntime/Include/WinPixEventRuntime/pix3.h new file mode 100644 index 00000000..1b73fc96 --- /dev/null +++ b/Libs/WinPixEventRuntime/Include/WinPixEventRuntime/pix3.h @@ -0,0 +1,144 @@ +/*==========================================================================; + * + * Copyright (C) Microsoft Corporation. All Rights Reserved. + * + * File: pix3.h + * Content: PIX include file + * + ****************************************************************************/ +#pragma once + +#ifndef _PIX3_H_ +#define _PIX3_H_ + +#include + +#ifndef __cplusplus +#error "Only C++ files can include pix3.h. C is not supported." +#endif + +#if !defined(USE_PIX_SUPPORTED_ARCHITECTURE) +#if defined(_M_X64) || defined(USE_PIX_ON_ALL_ARCHITECTURES) || defined(_M_ARM64) +#define USE_PIX_SUPPORTED_ARCHITECTURE +#endif +#endif + +#if !defined(USE_PIX) +#if defined(USE_PIX_SUPPORTED_ARCHITECTURE) && (defined(_DEBUG) || DBG || defined(PROFILE) || defined(PROFILE_BUILD)) && !defined(_PREFAST_) +#define USE_PIX +#endif +#endif + +#if defined(USE_PIX) && !defined(USE_PIX_SUPPORTED_ARCHITECTURE) +#pragma message("Warning: Pix markers are only supported on AMD64 and ARM64") +#endif + +#if defined(XBOX) || defined(_XBOX_ONE) || defined(_DURANGO) || defined(_GAMING_XBOX) +#include "pix3_xbox.h" +#else +#include "pix3_win.h" +#endif + +// These flags are used by both PIXBeginCapture and PIXGetCaptureState +#define PIX_CAPTURE_TIMING (1 << 0) +#define PIX_CAPTURE_GPU (1 << 1) +#define PIX_CAPTURE_FUNCTION_SUMMARY (1 << 2) +#define PIX_CAPTURE_FUNCTION_DETAILS (1 << 3) +#define PIX_CAPTURE_CALLGRAPH (1 << 4) +#define PIX_CAPTURE_INSTRUCTION_TRACE (1 << 5) +#define PIX_CAPTURE_SYSTEM_MONITOR_COUNTERS (1 << 6) +#define PIX_CAPTURE_VIDEO (1 << 7) +#define PIX_CAPTURE_AUDIO (1 << 8) + +union PIXCaptureParameters +{ + enum PIXCaptureStorage + { + Hybrid = 0, + Disk, + Memory, + }; + + struct GpuCaptureParameters + { + PVOID reserved; + } GpuCaptureParameters; + + struct TimingCaptureParameters + { + PWSTR FileName; + UINT32 MaximumToolingMemorySizeMb; + PIXCaptureStorage CaptureStorage; + + BOOL CaptureGpuTiming; + + BOOL CaptureCallstacks; + BOOL CaptureCpuSamples; + UINT32 CpuSamplesPerSecond; + } TimingCaptureParameters; +}; + +typedef PIXCaptureParameters* PPIXCaptureParameters; + + +#if defined(USE_PIX) && defined(USE_PIX_SUPPORTED_ARCHITECTURE) + +#define PIX_EVENTS_ARE_TURNED_ON + +#include "PIXEventsCommon.h" +#include "PIXEvents.h" + +// Starts a programmatically controlled capture. +// captureFlags uses the PIX_CAPTURE_* family of flags to specify the type of capture to take +extern "C" HRESULT WINAPI PIXBeginCapture1(DWORD captureFlags, _In_opt_ const PPIXCaptureParameters captureParameters); +inline HRESULT PIXBeginCapture(DWORD captureFlags, _In_opt_ const PPIXCaptureParameters captureParameters) { return PIXBeginCapture1(captureFlags, captureParameters); } + +// Stops a programmatically controlled capture +// If discard == TRUE, the captured data is discarded +// If discard == FALSE, the captured data is saved +extern "C" HRESULT WINAPI PIXEndCapture(BOOL discard); + +extern "C" DWORD WINAPI PIXGetCaptureState(); + +extern "C" void WINAPI PIXReportCounter(_In_ PCWSTR name, float value); + +#else + +// Eliminate these APIs when not using PIX +inline HRESULT PIXBeginCapture1(DWORD, _In_opt_ const PIXCaptureParameters*) { return S_OK; } +inline HRESULT PIXBeginCapture(DWORD, _In_opt_ const PIXCaptureParameters*) { return S_OK; } +inline HRESULT PIXEndCapture(BOOL) { return S_OK; } +inline DWORD PIXGetCaptureState() { return 0; } +inline void PIXReportCounter(_In_ PCWSTR, float) {} +inline void PIXNotifyWakeFromFenceSignal(_In_ HANDLE) {} + +inline void PIXBeginEvent(UINT64, _In_ PCSTR, ...) {} +inline void PIXBeginEvent(UINT64, _In_ PCWSTR, ...) {} +inline void PIXBeginEvent(void*, UINT64, _In_ PCSTR, ...) {} +inline void PIXBeginEvent(void*, UINT64, _In_ PCWSTR, ...) {} +inline void PIXEndEvent() {} +inline void PIXEndEvent(void*) {} +inline void PIXSetMarker(UINT64, _In_ PCSTR, ...) {} +inline void PIXSetMarker(UINT64, _In_ PCWSTR, ...) {} +inline void PIXSetMarker(void*, UINT64, _In_ PCSTR, ...) {} +inline void PIXSetMarker(void*, UINT64, _In_ PCWSTR, ...) {} +inline void PIXScopedEvent(UINT64, _In_ PCSTR, ...) {} +inline void PIXScopedEvent(UINT64, _In_ PCWSTR, ...) {} +inline void PIXScopedEvent(void*, UINT64, _In_ PCSTR, ...) {} +inline void PIXScopedEvent(void*, UINT64, _In_ PCWSTR, ...) {} + +// don't show warnings about expressions with no effect +#pragma warning(disable:4548) +#pragma warning(disable:4555) + +#endif // USE_PIX + +// Use these functions to specify colors to pass as metadata to a PIX event/marker API. +// Use PIX_COLOR() to specify a particular color for an event. +// Or, use PIX_COLOR_INDEX() to specify a set of unique event categories, and let PIX choose +// the colors to represent each category. +inline UINT PIX_COLOR(BYTE r, BYTE g, BYTE b) { return 0xff000000 | (r << 16) | (g << 8) | b; } +inline UINT PIX_COLOR_INDEX(BYTE i) { return i; } +const UINT PIX_COLOR_DEFAULT = PIX_COLOR_INDEX(0); + +#endif // _PIX3_H_ diff --git a/Libs/WinPixEventRuntime/Include/WinPixEventRuntime/pix3_win.h b/Libs/WinPixEventRuntime/Include/WinPixEventRuntime/pix3_win.h new file mode 100644 index 00000000..7b2b8462 --- /dev/null +++ b/Libs/WinPixEventRuntime/Include/WinPixEventRuntime/pix3_win.h @@ -0,0 +1,48 @@ +/*==========================================================================; + * + * Copyright (C) Microsoft Corporation. All Rights Reserved. + * + * File: PIX3_win.h + * Content: PIX include file + * Don't include this file directly - use pix3.h + * + ****************************************************************************/ + +#pragma once + +#ifndef _PIX3_H_ +#error Don't include this file directly - use pix3.h +#endif + +#ifndef _PIX3_WIN_H_ +#define _PIX3_WIN_H_ + + // PIXEventsThreadInfo is defined in PIXEventsCommon.h +struct PIXEventsThreadInfo; + +extern "C" PIXEventsThreadInfo* PIXGetThreadInfo() noexcept; + +#if defined(USE_PIX) && defined(USE_PIX_SUPPORTED_ARCHITECTURE) +// Notifies PIX that an event handle was set as a result of a D3D12 fence being signaled. +// The event specified must have the same handle value as the handle +// used in ID3D12Fence::SetEventOnCompletion. +extern "C" void WINAPI PIXNotifyWakeFromFenceSignal(_In_ HANDLE event); +#endif + +// The following defines denote the different metadata values that have been used +// by tools to denote how to parse pix marker event data. The first two values +// are legacy values. +#define WINPIX_EVENT_UNICODE_VERSION 0 +#define WINPIX_EVENT_ANSI_VERSION 1 +#define WINPIX_EVENT_PIX3BLOB_VERSION 2 + +#define D3D12_EVENT_METADATA WINPIX_EVENT_PIX3BLOB_VERSION + +__forceinline UINT64 PIXGetTimestampCounter() +{ + LARGE_INTEGER time = {}; + QueryPerformanceCounter(&time); + return time.QuadPart; +} + +#endif //_PIX3_WIN_H_ diff --git a/Libs/WinPixEventRuntime/ThirdPartyNotices.txt b/Libs/WinPixEventRuntime/ThirdPartyNotices.txt new file mode 100644 index 00000000..8281e7e5 --- /dev/null +++ b/Libs/WinPixEventRuntime/ThirdPartyNotices.txt @@ -0,0 +1,149 @@ +THIRD-PARTY SOFTWARE NOTICES AND INFORMATION + +Note: While Microsoft is not the author of the files below, Microsoft is +offering you a license subject to the terms of the Microsoft Software License +Terms for Microsoft PIX Developer Tool (the "Microsoft Program"). Microsoft +reserves all other rights. The notices below are provided for informational +purposes only and are not the license terms under which Microsoft distributes +these files. + +The Microsoft Program includes the following third-party software: + +1. Boost v. 1.66.0 (https://sourceforge.net/projects/boost/files/boost/1.66.0) +2. fmt v4.1.0 (https://github.com/fmtlib/fmt/releases/tag/4.1.0) + + +As the recipient of the above third-party software, Microsoft sets forth a copy +of the notices and other information below. + + +BOOST NOTICES AND INFORMATION BEGIN HERE +======================================== + +Boost v. 1.66.0 +Copyright Beman Dawes, David Abrahams, 1998-2005 +Copyright Rene Rivera 2006-2007 +Provided for Informational Purposes Only +Boost Software License - Version 1.0 - August 17th, 2003 + +Permission is hereby granted, free of charge, to any person or organization +obtaining a copy of the software and accompanying documentation covered by this +license (the "Software") to use, reproduce, display, distribute, execute, and +transmit the Software, and to prepare derivative works of the Software, and to +permit third-parties to whom the Software is furnished to do so, all subject to +the following: + +The copyright notices in the Software and this entire statement, including the +above license grant, this restriction and the following disclaimer, must be +included in all copies of the Software, in whole or in part, and all derivative +works of the Software, unless such copies or derivative works are solely in the +form of machine-executable object code generated by a source language processor. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL +THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY +DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE + +END OF BOOST NOTICES AND INFORMATION +==================================== + +FMT NOTICES AND INFORMATION BEGIN HERE +====================================== + +fmt v4.1.0 +Copyright (c) 2012 - 2016, Victor Zverovich +Provided for Informational Purposes Only +BSD 2-clause + + +Copyright (c) 2012 - 2016, Victor Zverovich + +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +END OF FMT NOTICES AND INFORMATION +================================== + +RETROFIT NOTICES AND INFORMATION BEGIN HERE +=========================================== + +Copyright (C) 2016 Max Delta Group + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is furnished +to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE MAX +DELTA GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN +ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of the Max Delta Group and its +members shall not be used in advertising or otherwise to promote the sale, use +or other dealings in this Software without prior written authorization from the +Max Delta Group. + +END OF RETROFIT NOTICES AND INFORMATION +======================================= + +SQLITE3 NOTICES AND INFORMATION BEGIN HERE +========================================== + +https://www.sqlite.org/copyright.html +SQLite Is Public Domain + +All of the code and documentation in SQLite has been dedicated to the public +domain by the authors. All code authors, and representatives of the companies +they work for, have signed affidavits dedicating their contributions to the +public domain and originals of those signed affidavits are stored in a firesafe +at the main offices of Hwaci. Anyone is free to copy, modify, publish, use, +compile, sell, or distribute the original SQLite code, either in source code +form or as a compiled binary, for any purpose, commercial or non-commercial, and +by any means. + +The previous paragraph applies to the deliverable code and documentation in SQLite - +those parts of the SQLite library that you actually bundle and ship with a larger +application. Some scripts used as part of the build process (for example the "configure" +scripts generated by autoconf) might fall under other open-source licenses. Nothing +from these build scripts ever reaches the final deliverable SQLite library, however, +and so the licenses associated with those scripts should not be a factor in assessing +your rights to copy and use the SQLite library. + +All of the deliverable code in SQLite has been written from scratch. No code has been +taken from other projects or from the open internet. Every line of code can be traced +back to its original author, and all of those authors have public domain dedications +on file. So the SQLite code base is clean and is uncontaminated with licensed code +from other projects. + +END OF SQLITE3 NOTICES AND INFORMATION +====================================== diff --git a/Libs/WinPixEventRuntime/WinPixEventRuntime.nuspec b/Libs/WinPixEventRuntime/WinPixEventRuntime.nuspec new file mode 100644 index 00000000..17c51db1 --- /dev/null +++ b/Libs/WinPixEventRuntime/WinPixEventRuntime.nuspec @@ -0,0 +1,18 @@ + + + + WinPixEventRuntime + 1.0.200127001 + WinPixEventRuntime + Microsoft + pix,microsoft + https://www.microsoft.com/web/webpi/eula/eula_pix_event_runtime.htm + https://devblogs.microsoft.com/pix/winpixeventruntime/ + http://www.gravatar.com/avatar/df362936893270e6a1b53807fa90e8fa + false + Allows applications to be instrumented with marker events, for use with Microsoft PIX. + https://devblogs.microsoft.com/pix/winpixeventruntime/ + © Microsoft Corporation. All rights reserved. + PIX Direct3D graphics 3D + + \ No newline at end of file diff --git a/Libs/WinPixEventRuntime/[Content_Types].xml b/Libs/WinPixEventRuntime/[Content_Types].xml new file mode 100644 index 00000000..ee5b747c --- /dev/null +++ b/Libs/WinPixEventRuntime/[Content_Types].xml @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/Libs/WinPixEventRuntime/_rels/.rels b/Libs/WinPixEventRuntime/_rels/.rels new file mode 100644 index 00000000..73f9b819 --- /dev/null +++ b/Libs/WinPixEventRuntime/_rels/.rels @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/Libs/WinPixEventRuntime/build/WinPixEventRuntime.targets b/Libs/WinPixEventRuntime/build/WinPixEventRuntime.targets new file mode 100644 index 00000000..3679cf9d --- /dev/null +++ b/Libs/WinPixEventRuntime/build/WinPixEventRuntime.targets @@ -0,0 +1,68 @@ + + + + + + + $(MSBuildThisFileDirectory)..\Include\WinPixEventRuntime;%(AdditionalIncludeDirectories) + + + + + + $(MSBuildThisFileDirectory)..\bin\x64;%(AdditionalLibraryDirectories) + WinPixEventRuntime_UAP.lib;%(AdditionalDependencies) + + + + + + $(MSBuildThisFileDirectory)..\bin\ARM64;%(AdditionalLibraryDirectories) + WinPixEventRuntime_UAP.lib;%(AdditionalDependencies) + + + + + + WinPixEventBinary + $(ProjectName) + %(Filename)%(Extension) + + + + + + WinPixEventBinary + $(ProjectName) + %(Filename)%(Extension) + + + + + + $(MSBuildThisFileDirectory)..\bin\x64;%(AdditionalLibraryDirectories) + WinPixEventRuntime.lib;%(AdditionalDependencies) + + + + + + $(MSBuildThisFileDirectory)..\bin\ARM64;%(AdditionalLibraryDirectories) + WinPixEventRuntime.lib;%(AdditionalDependencies) + + + + + + %(RecursiveDir)%(FileName)%(Extension) + PreserveNewest + + + + + + %(RecursiveDir)%(FileName)%(Extension) + PreserveNewest + + + diff --git a/Libs/WinPixEventRuntime/package/services/metadata/core-properties/75b52844aad44082a4e6ddea0ac86508.psmdcp b/Libs/WinPixEventRuntime/package/services/metadata/core-properties/75b52844aad44082a4e6ddea0ac86508.psmdcp new file mode 100644 index 00000000..76149abe --- /dev/null +++ b/Libs/WinPixEventRuntime/package/services/metadata/core-properties/75b52844aad44082a4e6ddea0ac86508.psmdcp @@ -0,0 +1 @@ +MicrosoftAllows applications to be instrumented with marker events, for use with Microsoft PIX.WinPixEventRuntime1.0.200127001PIX Direct3D graphics 3DWinPixEventRuntimeNuGet, Version=3.3.0.212, Culture=neutral, PublicKeyToken=31bf3856ad364e35;Microsoft Windows NT 6.2.9200.0;.NET Framework 4.5 \ No newline at end of file diff --git a/Source/Application/GPUMarker.cpp b/Source/Application/GPUMarker.cpp new file mode 100644 index 00000000..8c0b9559 --- /dev/null +++ b/Source/Application/GPUMarker.cpp @@ -0,0 +1,37 @@ +// VQE +// Copyright(C) 2020 - Volkan Ilbeyli +// +// This program is free software : you can redistribute it and / or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program.If not, see . +// +// Contact: volkanilbeyli@gmail.com + +#include +#include "GPUMarker.h" + +ScopedGPUMarker::ScopedGPUMarker(ID3D12GraphicsCommandList* pCmdList, const char* pLabel, unsigned PIXColor) + : mpCmdList(pCmdList) +{ + PIXBeginEvent(mpCmdList, (unsigned long long)PIXColor, pLabel); +} + +ScopedGPUMarker::ScopedGPUMarker(ID3D12CommandQueue* pCmdQueue, const char* pLabel, unsigned PIXColor) + :mpCmdQueue(pCmdQueue) +{ + PIXBeginEvent(mpCmdQueue, PIXColor, pLabel); +} + +ScopedGPUMarker::~ScopedGPUMarker() +{ + PIXEndEvent(mpCmdList); +} diff --git a/Source/Application/GPUMarker.h b/Source/Application/GPUMarker.h new file mode 100644 index 00000000..30dde0b8 --- /dev/null +++ b/Source/Application/GPUMarker.h @@ -0,0 +1,44 @@ +// VQE +// Copyright(C) 2020 - Volkan Ilbeyli +// +// This program is free software : you can redistribute it and / or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program.If not, see . +// +// Contact: volkanilbeyli@gmail.com + +#pragma once + +#include "WinPixEventRuntime/pix3.h" + +#define SCOPED_GPU_MARKER(pCmd, pStr) ScopedGPUMarker GPUMarker(pCmd,pStr) + +struct ID3D12GraphicsCommandList; +struct ID3D12CommandQueue; + +class ScopedGPUMarker +{ +public: + ScopedGPUMarker(ID3D12GraphicsCommandList* pCmdList, const char* pLabel, unsigned PIXColor = PIX_COLOR_DEFAULT); + ScopedGPUMarker(ID3D12CommandQueue* pCmdQueue, const char* pLabel, unsigned PIXColor = PIX_COLOR_DEFAULT); + ~ScopedGPUMarker(); + + ScopedGPUMarker(const ScopedGPUMarker&) = delete; + ScopedGPUMarker(ScopedGPUMarker&&) = delete; + ScopedGPUMarker& operator=(ScopedGPUMarker&&) = delete; +private: + union + { + ID3D12GraphicsCommandList* mpCmdList; + ID3D12CommandQueue* mpCmdQueue; + }; +}; \ No newline at end of file diff --git a/Source/Application/VQEngine_Render.cpp b/Source/Application/VQEngine_Render.cpp index 41fbd329..ba4b3dc0 100644 --- a/Source/Application/VQEngine_Render.cpp +++ b/Source/Application/VQEngine_Render.cpp @@ -18,11 +18,11 @@ #include "VQEngine.h" #include "Geometry.h" +#include "GPUMarker.h" #include #include - // ------------------------------------------------------------------------------------------------------------------------------------------------------------ // // MAIN @@ -644,7 +644,6 @@ void VQEngine::DrawMesh(ID3D12GraphicsCommandList* pCmd, const Mesh& mesh) pCmd->DrawIndexedInstanced(NumIndices, NumInstances, 0, 0, 0); } - void VQEngine::TransitionForSceneRendering(FWindowRenderContext& ctx) { const bool& bMSAA = mSettings.gfx.bAntiAliasing; @@ -654,6 +653,8 @@ void VQEngine::TransitionForSceneRendering(FWindowRenderContext& ctx) auto pRscColor = mRenderer.GetTextureResource(mResources_MainWnd.Tex_MainViewColor); auto pRscColorMSAA = mRenderer.GetTextureResource(mResources_MainWnd.Tex_MainViewColorMSAA); + SCOPED_GPU_MARKER(pCmd, "TransitionForSceneRendering"); + if (bMSAA) { const CD3DX12_RESOURCE_BARRIER pBarriers[] = @@ -674,7 +675,10 @@ void VQEngine::TransitionForSceneRendering(FWindowRenderContext& ctx) void VQEngine::RenderShadowMaps(FWindowRenderContext& ctx) { - + ID3D12GraphicsCommandList*& pCmd = ctx.pCmdList_GFX; + //PIXBeginEvent(pCmd, VQ_PIXEventColor, "TransitionForSceneRendering"); + ////TODO + //PIXEndEvent(pCmd); } void VQEngine::RenderSceneColor(FWindowRenderContext& ctx, const FSceneView& SceneView) @@ -687,6 +691,9 @@ void VQEngine::RenderSceneColor(FWindowRenderContext& ctx, const FSceneView& Sce const RTV& rtv = mRenderer.GetRTV(bMSAA ? mResources_MainWnd.RTV_MainViewColorMSAA : mResources_MainWnd.RTV_MainViewColor); const DSV& dsv = mRenderer.GetDSV(bMSAA ? mResources_MainWnd.DSV_MainViewDepthMSAA : mResources_MainWnd.DSV_MainViewDepth); + + SCOPED_GPU_MARKER(pCmd, "RenderSceneColor"); + // Clear Depth & Render targets D3D12_CPU_DESCRIPTOR_HANDLE rtvHandle = rtv.GetCPUDescHandle(); D3D12_CPU_DESCRIPTOR_HANDLE dsvHandle = dsv.GetCPUDescHandle(); @@ -708,56 +715,59 @@ void VQEngine::RenderSceneColor(FWindowRenderContext& ctx, const FSceneView& Sce pCmd->SetPipelineState(mRenderer.GetPSO(bMSAA ? EBuiltinPSOs::OBJECT_PSO_MSAA_4 : EBuiltinPSOs::OBJECT_PSO)); - // Draw Objects ----------------------------------------------- ID3D12DescriptorHeap* ppHeaps[] = { mRenderer.GetDescHeap(EResourceHeapType::CBV_SRV_UAV_HEAP) }; - pCmd->SetGraphicsRootSignature(mRenderer.GetRootSignature(4)); // hardcoded root signature for now until shader reflection and rootsignature management is implemented - pCmd->SetDescriptorHeaps(_countof(ppHeaps), ppHeaps); - for (const FMeshRenderCommand& meshRenderCmd : SceneView.meshRenderCommands) + // Draw Objects ----------------------------------------------- { - // set constant buffer data - const XMMATRIX mMVP - = meshRenderCmd.WorldTransformationMatrix - * SceneView.viewProj; - - FFrameConstantBuffer2* pConstBuffer = {}; - D3D12_GPU_VIRTUAL_ADDRESS cbAddr = {}; - ctx.mDynamicHeap_ConstantBuffer.AllocConstantBuffer(sizeof(FFrameConstantBuffer2), (void**)(&pConstBuffer), &cbAddr); - pConstBuffer->matModelViewProj = mMVP; - pConstBuffer->iTextureConfig = 0; // TODO - pConstBuffer->iTextureOutput = EMaterialTextureMapBindings::ALBEDO; // TODO: drive thru material - - // set material data - const Material& mat = mpScene->GetMaterial(meshRenderCmd.matID); - if(mat.SRVMaterialMaps!=INVALID_ID) - pCmd->SetGraphicsRootDescriptorTable(0, mRenderer.GetSRV(mat.SRVMaterialMaps).GetGPUDescHandle(0)); - - pCmd->SetGraphicsRootConstantBufferView(1, cbAddr); - - const Mesh& mesh = mpScene->mMeshes.at(meshRenderCmd.meshID); - - const auto VBIBIDs = mesh.GetIABufferIDs(); - const uint32 NumIndices = mesh.GetNumIndices(); - const uint32 NumInstances = 1; - const BufferID& VB_ID = VBIBIDs.first; - const BufferID& IB_ID = VBIBIDs.second; - const VBV& vb = mRenderer.GetVertexBufferView(VB_ID); - const IBV& ib = mRenderer.GetIndexBufferView(IB_ID); - - pCmd->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST); - pCmd->IASetVertexBuffers(0, 1, &vb); - pCmd->IASetIndexBuffer(&ib); - - pCmd->DrawIndexedInstanced(NumIndices, NumInstances, 0, 0, 0); + SCOPED_GPU_MARKER(pCmd, "Geometry"); + pCmd->SetGraphicsRootSignature(mRenderer.GetRootSignature(4)); // hardcoded root signature for now until shader reflection and rootsignature management is implemented + pCmd->SetDescriptorHeaps(_countof(ppHeaps), ppHeaps); + for (const FMeshRenderCommand& meshRenderCmd : SceneView.meshRenderCommands) + { + // set constant buffer data + const XMMATRIX mMVP + = meshRenderCmd.WorldTransformationMatrix + * SceneView.viewProj; + + FFrameConstantBuffer2* pConstBuffer = {}; + D3D12_GPU_VIRTUAL_ADDRESS cbAddr = {}; + ctx.mDynamicHeap_ConstantBuffer.AllocConstantBuffer(sizeof(FFrameConstantBuffer2), (void**)(&pConstBuffer), &cbAddr); + pConstBuffer->matModelViewProj = mMVP; + pConstBuffer->iTextureConfig = 0; // TODO + pConstBuffer->iTextureOutput = EMaterialTextureMapBindings::ALBEDO; // TODO: drive thru material + + // set material data + const Material& mat = mpScene->GetMaterial(meshRenderCmd.matID); + if (mat.SRVMaterialMaps != INVALID_ID) + pCmd->SetGraphicsRootDescriptorTable(0, mRenderer.GetSRV(mat.SRVMaterialMaps).GetGPUDescHandle(0)); + + pCmd->SetGraphicsRootConstantBufferView(1, cbAddr); + + const Mesh& mesh = mpScene->mMeshes.at(meshRenderCmd.meshID); + + const auto VBIBIDs = mesh.GetIABufferIDs(); + const uint32 NumIndices = mesh.GetNumIndices(); + const uint32 NumInstances = 1; + const BufferID& VB_ID = VBIBIDs.first; + const BufferID& IB_ID = VBIBIDs.second; + const VBV& vb = mRenderer.GetVertexBufferView(VB_ID); + const IBV& ib = mRenderer.GetIndexBufferView(IB_ID); + + pCmd->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST); + pCmd->IASetVertexBuffers(0, 1, &vb); + pCmd->IASetIndexBuffer(&ib); + + pCmd->DrawIndexedInstanced(NumIndices, NumInstances, 0, 0, 0); + } } - - // Draw Environment Map --------------------------------------- const bool bHasEnvironmentMapHDRTexture = mResources_MainWnd.EnvironmentMap.SRV_HDREnvironment != INVALID_ID; const bool bDrawEnvironmentMap = bHasEnvironmentMapHDRTexture && true; if (bDrawEnvironmentMap) { + SCOPED_GPU_MARKER(pCmd, "EnvironmentMap"); + ID3D12DescriptorHeap* ppHeaps[] = { mRenderer.GetDescHeap(EResourceHeapType::CBV_SRV_UAV_HEAP) }; Camera skyCam = mpScene->GetActiveCamera().Clone(); @@ -790,7 +800,7 @@ void VQEngine::ResolveMSAA(FWindowRenderContext& ctx) if (!bMSAA) return; - + SCOPED_GPU_MARKER(pCmd, "ResolveMSAA"); auto pRscColor = mRenderer.GetTextureResource(mResources_MainWnd.Tex_MainViewColor); auto pRscColorMSAA = mRenderer.GetTextureResource(mResources_MainWnd.Tex_MainViewColorMSAA); @@ -815,6 +825,7 @@ void VQEngine::TransitionForPostProcessing(FWindowRenderContext& ctx) auto pRscInput = mRenderer.GetTextureResource(mResources_MainWnd.Tex_MainViewColor); auto pRscOutput = mRenderer.GetTextureResource(mResources_MainWnd.Tex_PostProcess_TonemapperOut); + SCOPED_GPU_MARKER(pCmd, "TransitionForPostProcessing"); const CD3DX12_RESOURCE_BARRIER pBarriers[] = { CD3DX12_RESOURCE_BARRIER::Transition(pRscInput , (bMSAA ? D3D12_RESOURCE_STATE_RESOLVE_DEST : D3D12_RESOURCE_STATE_RENDER_TARGET), D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE) @@ -847,6 +858,7 @@ void VQEngine::RenderPostProcess(FWindowRenderContext& ctx, const FPostProcessPa constexpr int DispatchZ = 1; // cmds + SCOPED_GPU_MARKER(pCmd, "RenderPostProcess"); pCmd->SetPipelineState(mRenderer.GetPSO(EBuiltinPSOs::TONEMAPPER_PSO)); pCmd->SetComputeRootSignature(mRenderer.GetRootSignature(3)); // compute RS pCmd->SetDescriptorHeaps(_countof(ppHeaps), ppHeaps); @@ -875,6 +887,7 @@ void VQEngine::RenderUI(FWindowRenderContext& ctx) ID3D12Resource* pSwapChainRT = ctx.SwapChain.GetCurrentBackBufferRenderTarget(); D3D12_CPU_DESCRIPTOR_HANDLE rtvHandle = ctx.SwapChain.GetCurrentBackBufferRTVHandle(); + SCOPED_GPU_MARKER(pCmd, "SwapchainPassthrough"); // Transition Input & Output resources auto pRscTonemapperOut = mRenderer.GetTextureResource(mResources_MainWnd.Tex_PostProcess_TonemapperOut); CD3DX12_RESOURCE_BARRIER barriers[] = @@ -910,6 +923,8 @@ HRESULT VQEngine::PresentFrame(FWindowRenderContext& ctx) ID3D12GraphicsCommandList*& pCmd = ctx.pCmdList_GFX; ID3D12Resource* pSwapChainRT = ctx.SwapChain.GetCurrentBackBufferRenderTarget(); + SCOPED_GPU_MARKER(pCmd, "PresentFrame"); + // Transition SwapChain for Present pCmd->ResourceBarrier(1, &CD3DX12_RESOURCE_BARRIER::Transition(pSwapChainRT , D3D12_RESOURCE_STATE_RENDER_TARGET From 51edd1645d453896290533d199472f3aacf3fd73 Mon Sep 17 00:00:00 2001 From: Volkan Date: Wed, 2 Sep 2020 18:52:21 -0700 Subject: [PATCH 33/67] Fix mising binaries for WinPixEventRuntime --- .gitignore | 5 ++++- .../bin/x64/WinPixEventRuntime.dll | Bin 0 -> 45944 bytes .../bin/x64/WinPixEventRuntime.lib | Bin 0 -> 4766 bytes .../bin/x64/WinPixEventRuntime_UAP.dll | Bin 0 -> 51584 bytes .../bin/x64/WinPixEventRuntime_UAP.lib | Bin 0 -> 3412 bytes README.md | 3 ++- Source/Application/GPUMarker.cpp | 3 +++ 7 files changed, 9 insertions(+), 2 deletions(-) create mode 100644 Libs/WinPixEventRuntime/bin/x64/WinPixEventRuntime.dll create mode 100644 Libs/WinPixEventRuntime/bin/x64/WinPixEventRuntime.lib create mode 100644 Libs/WinPixEventRuntime/bin/x64/WinPixEventRuntime_UAP.dll create mode 100644 Libs/WinPixEventRuntime/bin/x64/WinPixEventRuntime_UAP.lib diff --git a/.gitignore b/.gitignore index 48a676a7..ab25f330 100644 --- a/.gitignore +++ b/.gitignore @@ -344,4 +344,7 @@ $RECYCLE.BIN/ # EXCEPTIONS !Data/Models/*/*.obj !Tools/7z.exe -!Tools/wget.exe \ No newline at end of file +!Tools/wget.exe +!Libs/WinPixEventRuntime/bin +!Libs/WinPixEventRuntime/bin/x64/ +!Libs/WinPixEventRuntime/bin/x64/* \ No newline at end of file diff --git a/Libs/WinPixEventRuntime/bin/x64/WinPixEventRuntime.dll b/Libs/WinPixEventRuntime/bin/x64/WinPixEventRuntime.dll new file mode 100644 index 0000000000000000000000000000000000000000..41f36bbd34a49e0c1ab9f12a2e25902a85351b23 GIT binary patch literal 45944 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 Bn-l;5 literal 0 HcmV?d00001 diff --git a/Libs/WinPixEventRuntime/bin/x64/WinPixEventRuntime.lib b/Libs/WinPixEventRuntime/bin/x64/WinPixEventRuntime.lib new file mode 100644 index 0000000000000000000000000000000000000000..7b2e619a259e70c62bc3b90ef69c75870b5b3c2b GIT binary patch literal 4766 zcmcIoPj4Gl5Fgvnq)yT%Ap$OyOx2c9)FifJmr5wCW4pzQlUTMR7ev`C-c7u+y=$#E zsBqzcRD@IxT=D_>2_nIVJr zS9cU$?n=P(Ya8YAAQnCw1e?(MyBljOd?8oQL8WwkS=yGBywKBkG%1PF4Hv{Fn%+Z#FDb5I$)IT zVj~V^s+yix@pvT7!Fkz;TT^v;>yw7imab}Q_o}2crJB602pwllFytNDf+8B0t}A)9 z+Z7bCEcbPedoOprQp|0X3h6>Jbxjj`ExFnEAh`FLila)Q^~Ux6KRfu9N^!a1u_g>@ zWK~VlR|TytX+s~5k5M5A8#>N2PMl9*pl3$`Zezqh90Mqv2Dpo~HwlnJx;O=JVH)5L z_D>PKgtU9gNDeR#V=w_Pz>6>fCtwufa1tUA_2tJPtosbZuR=I<%RBAlVg`+sMQAjb z1(55LE(W4JI5bg!H`b4uN6j=A*4;SL!pR>Y+>@QB1D*m`mbalkH)qcsyg&DZD_7g> z;JdUT-Wxs4%Qk-?M$;_nRV#v+7cq<0U8(-f) z8^M|ZGYYjiQTk|S`&`W&0hI9rO9@ZoU~+j*76n~6hZTg`X0ZDS>324cVb8(BKEq)} zVzyVYi=#dZM_djP`%&!AU?!sWvj1jZhnFTtaQX)Wgyjg#fZm>7m7AK{SGV-UZ1s&q zxwN*z<~`jwj>sk=!0bm~m?$v|(wDzNw5+Lid$@9=3b42}O_-n9Xy(*Qpid6EdD0JjU5AGWl zlimJaC7M(Augj~_7L&Yc&l<3vyz02U`5L z_#bhZu?~&mn&Q&kIN+?fT(tOv``H?>o^Z!`(uXWg446xQ1skXeTIkL1GT0efSunf(UZ8)Nn!<@FBD&g9~NosF~ie*6&aJjv_~ zp*{#Oci6m@wY`S^b~e4B(f{-jc^$nHSh#r$kdX9dtjkO|djI5he>sm@qo!V0g%hB3 zXdlX2F7MKM{)2npT{8A+?AE7-3Qc>8IfhI7=fCFuz<)sCD{N>#SfvH14&#=;czojl x-SP=rv#SgYN$+K!9p`7i`ks>Rh^aTY&J4*0KMxn9-~2^;A2n_87P0|){{_JCxz7Lq literal 0 HcmV?d00001 diff --git a/Libs/WinPixEventRuntime/bin/x64/WinPixEventRuntime_UAP.dll b/Libs/WinPixEventRuntime/bin/x64/WinPixEventRuntime_UAP.dll new file mode 100644 index 0000000000000000000000000000000000000000..36e7455650681dd88d91e11583b5a616e7c9bf5e GIT binary patch literal 51584 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 literal 0 HcmV?d00001 diff --git a/README.md b/README.md index 1037405c..57e2e39e 100644 --- a/README.md +++ b/README.md @@ -128,4 +128,5 @@ VQE supports the following command line parameters: - [D3D12MA](https://github.com/GPUOpen-LibrariesAndSDKs/D3D12MemoryAllocator) - [stb](https://github.com/nothings/stb) - [tinyxml2](https://github.com/leethomason/tinyxml2) -- [assimp](https://github.com/assimp/assimp) \ No newline at end of file +- [assimp](https://github.com/assimp/assimp) +- [WinPixEventRuntime](https://devblogs.microsoft.com/pix/winpixeventruntime/) \ No newline at end of file diff --git a/Source/Application/GPUMarker.cpp b/Source/Application/GPUMarker.cpp index 8c0b9559..2e5750a8 100644 --- a/Source/Application/GPUMarker.cpp +++ b/Source/Application/GPUMarker.cpp @@ -19,6 +19,9 @@ #include #include "GPUMarker.h" +// https://devblogs.microsoft.com/pix/winpixeventruntime/#:~:text=An%20%E2%80%9Cevent%E2%80%9D%20represents%20a%20region,a%20single%20point%20in%20time. +// https://devblogs.microsoft.com/pix/pix-2008-26-new-capture-layer/ + ScopedGPUMarker::ScopedGPUMarker(ID3D12GraphicsCommandList* pCmdList, const char* pLabel, unsigned PIXColor) : mpCmdList(pCmdList) { From 4c0b324b23e3c1846c516f6bdccf88a1e1577642 Mon Sep 17 00:00:00 2001 From: Volkan Date: Thu, 3 Sep 2020 12:28:02 -0700 Subject: [PATCH 34/67] Fix GPU marker error --- Source/Application/VQEngine_Render.cpp | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/Source/Application/VQEngine_Render.cpp b/Source/Application/VQEngine_Render.cpp index ba4b3dc0..299a36d9 100644 --- a/Source/Application/VQEngine_Render.cpp +++ b/Source/Application/VQEngine_Render.cpp @@ -923,14 +923,14 @@ HRESULT VQEngine::PresentFrame(FWindowRenderContext& ctx) ID3D12GraphicsCommandList*& pCmd = ctx.pCmdList_GFX; ID3D12Resource* pSwapChainRT = ctx.SwapChain.GetCurrentBackBufferRenderTarget(); - SCOPED_GPU_MARKER(pCmd, "PresentFrame"); - - // Transition SwapChain for Present - pCmd->ResourceBarrier(1, &CD3DX12_RESOURCE_BARRIER::Transition(pSwapChainRT - , D3D12_RESOURCE_STATE_RENDER_TARGET - , D3D12_RESOURCE_STATE_PRESENT) - ); - + { + SCOPED_GPU_MARKER(pCmd, "PresentFrame"); + // Transition SwapChain for Present + pCmd->ResourceBarrier(1, &CD3DX12_RESOURCE_BARRIER::Transition(pSwapChainRT + , D3D12_RESOURCE_STATE_RENDER_TARGET + , D3D12_RESOURCE_STATE_PRESENT) + ); + } pCmd->Close(); ID3D12CommandList* ppCommandLists[] = { pCmd }; From 2fb6520ac75c8ebe1d60c9ed3819820d22f468ec Mon Sep 17 00:00:00 2001 From: Volkan Date: Thu, 3 Sep 2020 18:19:53 -0700 Subject: [PATCH 35/67] Update vqutils submodule to fix the empty queue issue with the threadpool --- Libs/VQUtils | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Libs/VQUtils b/Libs/VQUtils index 1dfc1667..c6d4bc99 160000 --- a/Libs/VQUtils +++ b/Libs/VQUtils @@ -1 +1 @@ -Subproject commit 1dfc1667337efd404cba6713543eea343f032cf5 +Subproject commit c6d4bc9936195245082179b693ce07f9234188cf From 6eba1657b5dc5e12ac70d971fd9ced6fd3ab14c7 Mon Sep 17 00:00:00 2001 From: Volkan Date: Thu, 3 Sep 2020 22:05:34 -0700 Subject: [PATCH 36/67] Fix threading issues on app exit when loading isnt complete yet --- Libs/VQUtils | 2 +- Source/Application/AssetLoader.cpp | 21 ++++++++++++++++++++- Source/Application/AssetLoader.h | 4 ++++ Source/Application/Scene.cpp | 1 + Source/Application/VQEngine_Main.cpp | 3 ++- Source/Application/VQEngine_Render.cpp | 3 --- Source/Application/VQEngine_Update.cpp | 2 +- Source/Renderer/Renderer.cpp | 6 ++++++ Source/Renderer/Renderer_Resources.cpp | 2 +- 9 files changed, 36 insertions(+), 8 deletions(-) diff --git a/Libs/VQUtils b/Libs/VQUtils index c6d4bc99..645f4c73 160000 --- a/Libs/VQUtils +++ b/Libs/VQUtils @@ -1 +1 @@ -Subproject commit c6d4bc9936195245082179b693ce07f9234188cf +Subproject commit 645f4c732e5162f6711ebd9586b80fcb21a158dc diff --git a/Source/Application/AssetLoader.cpp b/Source/Application/AssetLoader.cpp index 3ea22b08..88c4bc79 100644 --- a/Source/Application/AssetLoader.cpp +++ b/Source/Application/AssetLoader.cpp @@ -78,6 +78,12 @@ AssetLoader::ModelLoadResults_t AssetLoader::StartLoadingModels(Scene* pScene) { mUniqueModelPaths.insert(ModelPath); + // check whether Exit signal is given to the app before dispatching workers + if (mWorkers.IsExiting()) + { + break; + } + // start loading modelLoadResult = std::move(mWorkers.AddTask([=]() { @@ -134,6 +140,12 @@ AssetLoader::TextureLoadResults_t AssetLoader::StartLoadingTextures() ? VQRenderer::GetProceduralTextureEnumFromName(vPathTokens[1]) : EProceduralTextures::NUM_PROCEDURAL_TEXTURES; + // check whether Exit signal is given to the app before dispatching workers + if (mWorkers.IsExiting()) + { + break; + } + std::future texLoadResult = std::move(mWorkers.AddTask([this, TexLoadParams, ProcTex]() { const bool IS_PROCEDURAL = ProcTex != EProceduralTextures::NUM_PROCEDURAL_TEXTURES; @@ -204,6 +216,9 @@ void AssetLoader::FMaterialTextureAssignments::DoAssignments(Scene* pScene, VQRe const MaterialID& matID = it->first; TextureLoadResult_t& result = it->second; + if (mWorkers.IsExiting()) + break; + assert(result.texLoadResult.valid()); switch (result.type) { @@ -237,6 +252,10 @@ void AssetLoader::FMaterialTextureAssignments::WaitForTextureLoads() const MaterialID& matID = it->first; const TextureLoadResult_t& result = it->second; assert(result.texLoadResult.valid()); + + if (mWorkers.IsExiting()) + break; + result.texLoadResult.wait(); } } @@ -303,7 +322,7 @@ ModelID AssetLoader::ImportModel_obj(Scene* pScene, AssetLoader* pAssetLoader, V Log::Info(" ReadFile(): %.3fs", fTimeReadFile); // parse scene and initialize model data - FMaterialTextureAssignments MaterialTextureAssignments; + FMaterialTextureAssignments MaterialTextureAssignments(pAssetLoader->mWorkers); Model::Data data = ProcessAssimpNode(pAiScene->mRootNode, pAiScene, modelDirectory, pAssetLoader, pScene, pRenderer, MaterialTextureAssignments); pRenderer->UploadVertexAndIndexBufferHeaps(); // load VB/IBs diff --git a/Source/Application/AssetLoader.h b/Source/Application/AssetLoader.h index e47e2151..540c6ae4 100644 --- a/Source/Application/AssetLoader.h +++ b/Source/Application/AssetLoader.h @@ -80,8 +80,11 @@ class AssetLoader }; struct FMaterialTextureAssignments { + FMaterialTextureAssignments(const ThreadPool& workers) : mWorkers(workers) {} + std::vector mAssignments; TextureLoadResults_t mTextureLoadResults; + const ThreadPool& mWorkers; // to check if pool IsExiting() void DoAssignments(Scene* pScene, VQRenderer* pRenderer); void WaitForTextureLoads(); @@ -91,6 +94,7 @@ class AssetLoader : mWorkers(WorkerThreads) , mRenderer(renderer) {} + inline const ThreadPool& GetThreadPool() const { return mWorkers; } void QueueModelLoad(GameObject* pObject, const std::string& ModelPath, const std::string& ModelName); ModelLoadResults_t StartLoadingModels(Scene* pScene); diff --git a/Source/Application/Scene.cpp b/Source/Application/Scene.cpp index 049fe8fb..b5f0e88a 100644 --- a/Source/Application/Scene.cpp +++ b/Source/Application/Scene.cpp @@ -127,6 +127,7 @@ Scene::Scene(VQEngine& engine, int NumFrameBuffers, const Input& input, const st , mResourceNames(engine.GetResourceNames()) , mAssetLoader(engine.GetAssetLoader()) , mRenderer(renderer) + , mMaterialAssignments(engine.GetAssetLoader().GetThreadPool()) {} void Scene::Update(float dt, int FRAME_DATA_INDEX) diff --git a/Source/Application/VQEngine_Main.cpp b/Source/Application/VQEngine_Main.cpp index 9b2f877d..15b596f3 100644 --- a/Source/Application/VQEngine_Main.cpp +++ b/Source/Application/VQEngine_Main.cpp @@ -81,7 +81,8 @@ bool VQEngine::Initialize(const FStartupParameters& Params) ReportSystemInfo(this->mSysInfo); #endif HWND hwnd = mpWinMain->GetHWND(); - mEventQueue_WinToVQE_Renderer.AddItem(std::make_shared(hwnd, this->GatherHDRMetaDataParameters(hwnd))); + if(!mpWinMain->IsClosed()) + mEventQueue_WinToVQE_Renderer.AddItem(std::make_shared(hwnd, this->GatherHDRMetaDataParameters(hwnd))); }); float f0 = t.Tick(); diff --git a/Source/Application/VQEngine_Render.cpp b/Source/Application/VQEngine_Render.cpp index 299a36d9..a4085610 100644 --- a/Source/Application/VQEngine_Render.cpp +++ b/Source/Application/VQEngine_Render.cpp @@ -72,9 +72,6 @@ void VQEngine::RenderThread_Main() } } - // busy wait until all loading is finished before calling Exit - while (mWorkers_Load.GetNumActiveTasks() > 0); - RenderThread_Exit(); Log::Info("RenderThread_Main() : Exit"); } diff --git a/Source/Application/VQEngine_Update.cpp b/Source/Application/VQEngine_Update.cpp index a87e7311..8f56b7bb 100644 --- a/Source/Application/VQEngine_Update.cpp +++ b/Source/Application/VQEngine_Update.cpp @@ -128,7 +128,7 @@ void VQEngine::UpdateThread_UpdateAppState(const float dt) { mpScene->OnLoadComplete(); WaitUntilRenderingFinishes(); - Log::Info("Update Thread loaded, starting simulation..."); + Log::Info("Loading completed, starting scene simulation"); mAppState = EAppState::SIMULATING; mbLoadingLevel.store(false); } diff --git a/Source/Renderer/Renderer.cpp b/Source/Renderer/Renderer.cpp index b9d4ebc3..ba176759 100644 --- a/Source/Renderer/Renderer.cpp +++ b/Source/Renderer/Renderer.cpp @@ -16,6 +16,12 @@ // // Contact: volkanilbeyli@gmail.com + +// Resources for reading +// - http://diligentgraphics.com/diligent-engine/architecture/d3d12/managing-descriptor-heaps/ +// - https://asawicki.info/articles/memory_management_vulkan_direct3d_12.php5 +// - https://simonstechblog.blogspot.com/2019/06/d3d12-descriptor-heap-management.html + #include "Renderer.h" #include "Device.h" #include "Texture.h" diff --git a/Source/Renderer/Renderer_Resources.cpp b/Source/Renderer/Renderer_Resources.cpp index c5b6b7a4..d0928662 100644 --- a/Source/Renderer/Renderer_Resources.cpp +++ b/Source/Renderer/Renderer_Resources.cpp @@ -263,7 +263,7 @@ void VQRenderer::InitializeSRV(SRV_ID srvID, uint heapIndex, TextureID texID) mTextures.at(texID).InitializeSRV(heapIndex, &mSRVs.at(srvID)); } else // init NULL SRV - { + { // Describe and create 2 null SRVs. Null descriptors are needed in order // to achieve the effect of an "unbound" resource. D3D12_SHADER_RESOURCE_VIEW_DESC nullSrvDesc = {}; From c1cc0a16c02ac1f19546883c16c2129ff05a87b1 Mon Sep 17 00:00:00 2001 From: Volkan Date: Thu, 3 Sep 2020 23:25:12 -0700 Subject: [PATCH 37/67] Fix environment map rendering with orthographic scene camera --- Data/Levels/Default.xml | 4 ++-- Source/Application/Camera.cpp | 2 +- Source/Application/Camera.h | 2 ++ Source/Application/VQEngine_Render.cpp | 14 +++++++++++++- 4 files changed, 18 insertions(+), 4 deletions(-) diff --git a/Data/Levels/Default.xml b/Data/Levels/Default.xml index ae94d3a1..133890e3 100644 --- a/Data/Levels/Default.xml +++ b/Data/Levels/Default.xml @@ -35,10 +35,10 @@ 65 6 - Orthographic + Perspective 90.0 0.01 - 1000 + 5000 1000 diff --git a/Source/Application/Camera.cpp b/Source/Application/Camera.cpp index e0d92075..8b1cbe6b 100644 --- a/Source/Application/Camera.cpp +++ b/Source/Application/Camera.cpp @@ -66,7 +66,7 @@ void Camera::InitializeCamera(const FCameraParameters& data) { this->mProjParams = data.ProjectionParams; this->mProjParams.FieldOfView *= DEG2RAD; // convert FoV to radians - this->mYaw = this->mPitch = 0; + this->mYaw = this->mPitch = 0; // set with Rotate() below SetProjectionMatrix(this->mProjParams); diff --git a/Source/Application/Camera.h b/Source/Application/Camera.h index 32425e0b..80e1a6bf 100644 --- a/Source/Application/Camera.h +++ b/Source/Application/Camera.h @@ -132,6 +132,8 @@ class Camera void UpdateViewMatrix(); inline void Update(float dt, const Input& input) { if(pController) pController->UpdateCamera(input, dt); } + inline float GetYaw() const { return mYaw; } + inline float GetPitch() const { return mPitch; } DirectX::XMFLOAT3 GetPositionF() const; DirectX::XMMATRIX GetViewMatrix() const; DirectX::XMMATRIX GetViewInverseMatrix() const; diff --git a/Source/Application/VQEngine_Render.cpp b/Source/Application/VQEngine_Render.cpp index a4085610..fba067f7 100644 --- a/Source/Application/VQEngine_Render.cpp +++ b/Source/Application/VQEngine_Render.cpp @@ -768,8 +768,20 @@ void VQEngine::RenderSceneColor(FWindowRenderContext& ctx, const FSceneView& Sce ID3D12DescriptorHeap* ppHeaps[] = { mRenderer.GetDescHeap(EResourceHeapType::CBV_SRV_UAV_HEAP) }; Camera skyCam = mpScene->GetActiveCamera().Clone(); - skyCam.SetPosition(0, 0, 0); +#if 1 + FCameraParameters p = {}; + p.bInitializeCameraController = false; + p.ProjectionParams = skyCam.GetProjectionParameters(); + p.ProjectionParams.bPerspectiveProjection = true; + p.ProjectionParams.FieldOfView = 45; + p.x = p.y = p.z = 0; + p.Yaw = skyCam.GetYaw() * RAD2DEG; + p.Pitch = skyCam.GetPitch() * RAD2DEG; + skyCam.InitializeCamera(p); +#else + skyCam.SetPosition(0,0,0); skyCam.UpdateViewMatrix(); +#endif D3D12_GPU_VIRTUAL_ADDRESS cbAddr = {}; FFrameConstantBuffer * pConstBuffer = {}; From a75fb4ef918c4808ae6957ade61a55d33d8ae357 Mon Sep 17 00:00:00 2001 From: Volkan Date: Mon, 7 Sep 2020 22:05:41 -0700 Subject: [PATCH 38/67] Fix synchronization issue with GatherHDRMetaDataParameters(hwnd) --- Source/Application/VQEngine_Update.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/Source/Application/VQEngine_Update.cpp b/Source/Application/VQEngine_Update.cpp index 8f56b7bb..b1fc281b 100644 --- a/Source/Application/VQEngine_Update.cpp +++ b/Source/Application/VQEngine_Update.cpp @@ -314,6 +314,8 @@ FSetHDRMetaDataParams VQEngine::GatherHDRMetaDataParameters(HWND hwnd) { FSetHDRMetaDataParams params; + while (!mbRenderThreadInitialized); // wait until renderer is initialized + const SwapChain& Swapchain = mRenderer.GetWindowSwapChain(hwnd); const DXGI_OUTPUT_DESC1 desc = Swapchain.GetContainingMonitorDesc(); const FDisplayHDRProfile* pProfile = GetHDRProfileIfExists(desc.DeviceName); From 76589deecc2b36a4501a00789798ef81d520dd33 Mon Sep 17 00:00:00 2001 From: Volkan Date: Mon, 7 Sep 2020 22:45:17 -0700 Subject: [PATCH 39/67] Parallel texture loading done without creating new upload heap every time --- Libs/VQUtils | 2 +- Source/Application/AssetLoader.cpp | 24 +++- Source/Application/Scene.cpp | 21 ++- Source/Application/VQEngine_Main.cpp | 5 +- Source/Renderer/Renderer.cpp | 31 ++++- Source/Renderer/Renderer.h | 30 ++++- Source/Renderer/Renderer_Resources.cpp | 177 ++++++++++++++++++++----- Source/Renderer/ResourceHeaps.cpp | 10 +- Source/Renderer/ResourceHeaps.h | 5 +- Source/Renderer/Texture.cpp | 127 ++++-------------- Source/Renderer/Texture.h | 12 +- 11 files changed, 290 insertions(+), 154 deletions(-) diff --git a/Libs/VQUtils b/Libs/VQUtils index 645f4c73..07dacad7 160000 --- a/Libs/VQUtils +++ b/Libs/VQUtils @@ -1 +1 @@ -Subproject commit 645f4c732e5162f6711ebd9586b80fcb21a158dc +Subproject commit 07dacad7f190fe000c33bc37f59ab5776a0ef0d8 diff --git a/Source/Application/AssetLoader.cpp b/Source/Application/AssetLoader.cpp index 88c4bc79..a84e28f3 100644 --- a/Source/Application/AssetLoader.cpp +++ b/Source/Application/AssetLoader.cpp @@ -25,6 +25,7 @@ #include "Libs/VQUtils/Source/Multithreading.h" #include "Libs/VQUtils/Source/utils.h" +#include "Libs/VQUtils/Source/Image.h" #include "Libs/VQUtils/Source/Timer.h" #include "Libs/VQUtils/Source/Log.h" @@ -149,9 +150,12 @@ AssetLoader::TextureLoadResults_t AssetLoader::StartLoadingTextures() std::future texLoadResult = std::move(mWorkers.AddTask([this, TexLoadParams, ProcTex]() { const bool IS_PROCEDURAL = ProcTex != EProceduralTextures::NUM_PROCEDURAL_TEXTURES; - return IS_PROCEDURAL - ? mRenderer.GetProceduralTextureSRV_ID(ProcTex) - : mRenderer.CreateTextureFromFile(TexLoadParams.TexturePath.c_str()); + if (IS_PROCEDURAL) + { + return mRenderer.GetProceduralTexture(ProcTex); + } + + return mRenderer.CreateTextureFromFile(TexLoadParams.TexturePath.c_str()); })); TextureLoadResults.emplace(std::make_pair(TexLoadParams.MatID, TextureLoadResult_t{ TexLoadParams.TexType, std::move(texLoadResult) })); } @@ -159,6 +163,9 @@ AssetLoader::TextureLoadResults_t AssetLoader::StartLoadingTextures() mUniqueTexturePaths.clear(); + // Currently mRenderer.CreateTextureFromFile() starts the texture uploads + ///mRenderer.StartTextureUploads(); + return std::move(TextureLoadResults); } @@ -210,16 +217,25 @@ void AssetLoader::FMaterialTextureAssignments::DoAssignments(Scene* pScene, VQRe { Material& mat = pScene->GetMaterial(assignment.matID); + bool bFound = mTextureLoadResults.find(assignment.matID) != mTextureLoadResults.end(); + if (!bFound) + { + Log::Error("TextureLoadResutls for MatID=%d not found!", assignment.matID); + continue; + } + auto pair_itBeginEnd = mTextureLoadResults.equal_range(assignment.matID); for (auto it = pair_itBeginEnd.first; it != pair_itBeginEnd.second; ++it) { const MaterialID& matID = it->first; TextureLoadResult_t& result = it->second; - + if (mWorkers.IsExiting()) break; assert(result.texLoadResult.valid()); + + result.texLoadResult.wait(); switch (result.type) { case DIFFUSE : mat.TexDiffuseMap = result.texLoadResult.get(); break; diff --git a/Source/Application/Scene.cpp b/Source/Application/Scene.cpp index b5f0e88a..7224792f 100644 --- a/Source/Application/Scene.cpp +++ b/Source/Application/Scene.cpp @@ -104,13 +104,21 @@ MaterialID Scene::CreateMaterial(const std::string& UniqueMaterialName) Material& Scene::GetMaterial(MaterialID ID) { - // TODO: err handle + if (mMaterials.find(ID) == mMaterials.end()) + { + Log::Error("Material not created. Did you call Scene::CreateMaterial()? (matID=%d)", ID); + assert(false); + } return mMaterials.at(ID); } Model& Scene::GetModel(ModelID id) { - // TODO: err handle + if (mModels.find(id) == mModels.end()) + { + Log::Error("Model not created. Did you call Scene::CreateModel()? (modelID=%d)", id); + assert(false); + } return mModels.at(id); } @@ -292,10 +300,13 @@ void Scene::StartLoading(const BuiltinMeshArray_t& builtinMeshes, FSceneRepresen MatTexAssignment.matID = id; mMaterialAssignments.mAssignments.push_back(MatTexAssignment); } + Log::Info("[Scene] Materials Created"); - // start loading material textures mMaterialAssignments.mTextureLoadResults = mAssetLoader.StartLoadingTextures(); + // start loading material textures + Log::Info("[Scene] Start loading textures..."); + if constexpr (B_LOAD_SERIAL) { // GAME OBJECTS @@ -311,6 +322,7 @@ void Scene::StartLoading(const BuiltinMeshArray_t& builtinMeshes, FSceneRepresen } mModelLoadResults = mAssetLoader.StartLoadingModels(this); + Log::Info("[Scene] Start loading models..."); // CAMERAS for (FCameraParameters& param : scene.Cameras) @@ -333,6 +345,7 @@ void Scene::StartLoading(const BuiltinMeshArray_t& builtinMeshes, FSceneRepresen mCameras[i].InitializeController(scene.Cameras[i].bFirstPerson, scene.Cameras[i]); } } + Log::Info("[Scene] Cameras initialized"); // assign scene rep @@ -341,6 +354,8 @@ void Scene::StartLoading(const BuiltinMeshArray_t& builtinMeshes, FSceneRepresen void Scene::OnLoadComplete() { + Log::Info("[Scene] OnLoadComplete()"); + // Assign model data for (auto it = mModelLoadResults.begin(); it != mModelLoadResults.end(); ++it) { diff --git a/Source/Application/VQEngine_Main.cpp b/Source/Application/VQEngine_Main.cpp index 15b596f3..eac2932a 100644 --- a/Source/Application/VQEngine_Main.cpp +++ b/Source/Application/VQEngine_Main.cpp @@ -77,12 +77,15 @@ bool VQEngine::Initialize(const FStartupParameters& Params) mWorkers_Update.AddTask([&]() { this->mSysInfo = VQSystemInfo::GetSystemInfo(); + #if REPORT_SYSTEM_INFO ReportSystemInfo(this->mSysInfo); #endif HWND hwnd = mpWinMain->GetHWND(); - if(!mpWinMain->IsClosed()) + if (!mpWinMain->IsClosed()) + { mEventQueue_WinToVQE_Renderer.AddItem(std::make_shared(hwnd, this->GatherHDRMetaDataParameters(hwnd))); + } }); float f0 = t.Tick(); diff --git a/Source/Renderer/Renderer.cpp b/Source/Renderer/Renderer.cpp index ba176759..f8ca85a8 100644 --- a/Source/Renderer/Renderer.cpp +++ b/Source/Renderer/Renderer.cpp @@ -129,13 +129,16 @@ void VQRenderer::Initialize(const FGraphicsSettings& Settings) mComputeQueue.Create(pVQDevice, CommandQueue::ECommandQueueType::COMPUTE); mCopyQueue.Create(pVQDevice, CommandQueue::ECommandQueueType::COPY); - // Initialize memory InitializeD3D12MA(); InitializeHeaps(); + // initialize thread + mbExitUploadThread.store(false); + mbDefaultResourcesLoaded.store(false); + mTextureUploadThread = std::thread(&VQRenderer::TextureUploadThread_Main, this); + Log::Info("[Renderer] Initialized."); - // TODO: Log system info } void VQRenderer::Load() @@ -143,6 +146,7 @@ void VQRenderer::Load() LoadPSOs(); LoadDefaultResources(); this->UploadVertexAndIndexBufferHeaps(); + mbDefaultResourcesLoaded.store(true); } void VQRenderer::Unload() @@ -153,6 +157,9 @@ void VQRenderer::Unload() void VQRenderer::Exit() { + mbExitUploadThread.store(true); + mSignal_UploadThreadWorkReady.NotifyAll(); + mHeapUpload.Destroy(); mHeapCBV_SRV_UAV.Destroy(); mHeapDSV.Destroy(); @@ -201,6 +208,8 @@ void VQRenderer::Exit() mCopyQueue.Destroy(); mDevice.Destroy(); + + mTextureUploadThread.join(); } void VQRenderer::OnWindowSizeChanged(HWND hwnd, unsigned w, unsigned h) @@ -355,8 +364,8 @@ void VQRenderer::InitializeHeaps() { ID3D12Device* pDevice = mDevice.GetDevicePtr(); - const uint32 UPLOAD_HEAP_SIZE = 256 * MEGABYTE; // TODO: from RendererSettings.ini - mHeapUpload.Create(pDevice, UPLOAD_HEAP_SIZE); + const uint32 UPLOAD_HEAP_SIZE = 513 * MEGABYTE; // TODO: from RendererSettings.ini + mHeapUpload.Create(pDevice, UPLOAD_HEAP_SIZE, this->mGFXQueue.pQueue); constexpr uint32 NumDescsCBV = 10; constexpr uint32 NumDescsSRV = 300; @@ -864,11 +873,13 @@ void VQRenderer::LoadDefaultResources() { std::vector texture = Texture::GenerateTexture_Checkerboard(sizeX); TextureID texID = this->CreateTexture("Checkerboard", textureDesc, D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE, texture.data()); + mLookup_ProceduralTextureIDs[EProceduralTextures::CHECKERBOARD] = texID; mLookup_ProceduralTextureSRVs[EProceduralTextures::CHECKERBOARD] = this->CreateAndInitializeSRV(texID); } { std::vector texture = Texture::GenerateTexture_Checkerboard(sizeX, true); TextureID texID = this->CreateTexture("Checkerboard_Gray", textureDesc, D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE, texture.data()); + mLookup_ProceduralTextureIDs[EProceduralTextures::CHECKERBOARD_GRAYSCALE] = texID; mLookup_ProceduralTextureSRVs[EProceduralTextures::CHECKERBOARD_GRAYSCALE] = this->CreateAndInitializeSRV(texID); } } @@ -876,7 +887,6 @@ void VQRenderer::UploadVertexAndIndexBufferHeaps() { mStaticHeap_VertexBuffer.UploadData(mHeapUpload.GetCommandList()); mStaticHeap_IndexBuffer.UploadData(mHeapUpload.GetCommandList()); - mHeapUpload.UploadToGPUAndWait(mGFXQueue.pQueue); } @@ -894,7 +904,16 @@ ID3D12DescriptorHeap* VQRenderer::GetDescHeap(EResourceHeapType HeapType) } - +TextureID VQRenderer::GetProceduralTexture(EProceduralTextures tex) const +{ + while (!mbDefaultResourcesLoaded); + if (mLookup_ProceduralTextureIDs.find(tex) == mLookup_ProceduralTextureIDs.end()) + { + Log::Error("Couldn't find procedural texture %d", tex); + return INVALID_ID; + } + return mLookup_ProceduralTextureIDs.at(tex); +} diff --git a/Source/Renderer/Renderer.h b/Source/Renderer/Renderer.h index 397cca1e..d0b60eb4 100644 --- a/Source/Renderer/Renderer.h +++ b/Source/Renderer/Renderer.h @@ -32,10 +32,13 @@ #define VQUTILS_SYSTEMINFO_INCLUDE_D3D12 1 #include "../../Libs/VQUtils/Source/SystemInfo.h" // FGPUInfo +#include "../../Libs/VQUtils/Source/Image.h" +#include "../../Libs/VQUtils/Source/Multithreading.h" #include #include #include +#include namespace D3D12MA { class Allocator; } class Window; @@ -43,7 +46,6 @@ struct ID3D12RootSignature; struct ID3D12PipelineState; - // // TYPE DEFINITIONS // @@ -73,6 +75,18 @@ struct FWindowRenderContext int MainRTResolutionY = -1; }; +struct FTextureUploadDesc +{ + FTextureUploadDesc(Image&& img_ , TextureID texID, const TextureCreateDesc& tDesc) : img(img_), id(texID), desc(tDesc), pData(nullptr) {} + FTextureUploadDesc(const void* pData_, TextureID texID, const TextureCreateDesc& tDesc) : img({ }), id(texID), desc(tDesc), pData(pData_) {} + FTextureUploadDesc() = delete; + + Image img; + const void* pData; + TextureID id; + TextureCreateDesc desc; +}; + enum EBuiltinPSOs // TODO: hardcoded PSOs until a generic Shader solution is integrated { HELLO_WORLD_TRIANGLE_PSO = 0, @@ -170,6 +184,13 @@ class VQRenderer inline const SRV& GetProceduralTextureSRV(EProceduralTextures tex) const { return GetSRV(GetProceduralTextureSRV_ID(tex)); } inline const SRV_ID GetProceduralTextureSRV_ID(EProceduralTextures tex) const { return mLookup_ProceduralTextureSRVs.at(tex); } + TextureID GetProceduralTexture(EProceduralTextures tex) const; + + // Texture Residency + void QueueTextureUpload(const FTextureUploadDesc& desc); + void ProcessTextureUploadQueue(); + void TextureUploadThread_Main(); + inline void StartTextureUploads() { mSignal_UploadThreadWorkReady.NotifyOne(); }; private: using PSOArray_t = std::array; @@ -226,8 +247,15 @@ class VQRenderer // bookkeeping std::unordered_map mLookup_TextureDiskLocations; std::unordered_map mLookup_ProceduralTextureSRVs; + std::unordered_map mLookup_ProceduralTextureIDs; + std::atomic mbExitUploadThread; + Signal mSignal_UploadThreadWorkReady; + std::thread mTextureUploadThread; + std::mutex mMtxTextureUploadQueue; + std::queue mTextureUploadQueue; + std::atomic mbDefaultResourcesLoaded; private: void InitializeD3D12MA(); diff --git a/Source/Renderer/Renderer_Resources.cpp b/Source/Renderer/Renderer_Resources.cpp index d0928662..435a6b72 100644 --- a/Source/Renderer/Renderer_Resources.cpp +++ b/Source/Renderer/Renderer_Resources.cpp @@ -25,6 +25,7 @@ #include "../../Libs/VQUtils/Source/Log.h" #include "../../Libs/VQUtils/Source/utils.h" #include "../../Libs/VQUtils/Source/Timer.h" +#include "../../Libs/VQUtils/Source/Image.h" #include "../../Libs/D3D12MA/src/Common.h" #include @@ -84,65 +85,91 @@ TextureID VQRenderer::CreateTextureFromFile(const char* pFilePath) #endif return it->second; } - + // check path + if (strlen(pFilePath) == 0) + { + Log::Warning("VQRenderer::CreateTextureFromFile: Empty FilePath provided"); + return INVALID_ID; + } + + // -------------------------------------------------------- + + TextureID ID = INVALID_ID; + Timer t; t.Start(); Texture tex; - // https://docs.microsoft.com/en-us/windows/win32/direct3d12/residency#heap-resources - // Heap creation can be slow; but it is optimized for background thread processing. - // It's recommended to create heaps on background threads to avoid glitching the render - // thread. In D3D12, multiple threads may safely call create routines concurrently. - UploadHeap uploadHeap; - { - std::unique_lock lk(mMtxUploadHeapCreation); - uploadHeap.Create(mDevice.GetDevicePtr(), 1024 * MEGABYTE); // TODO: drive the heapsize through RendererSettings.ini - } const std::string FileNameAndExtension = DirectoryUtil::GetFileNameFromPath(pFilePath); TextureCreateDesc tDesc(FileNameAndExtension); tDesc.pAllocator = mpAllocator; tDesc.pDevice = mDevice.GetDevicePtr(); - tDesc.pUploadHeap = &uploadHeap; - tDesc.Desc = {}; - bool bSuccess = tex.CreateFromFile(tDesc, pFilePath); - TextureID ID = INVALID_ID; + Image image; + const bool bSuccess = Texture::ReadImageFromDisk(pFilePath, image); + const bool bHDR = image.BytesPerPixel > 4; if (bSuccess) { - uploadHeap.UploadToGPUAndWait(mGFXQueue.pQueue); + // Fill D3D12 Descriptor + tDesc.d3d12Desc = {}; + tDesc.d3d12Desc.Width = image.Width; + tDesc.d3d12Desc.Height = image.Height; + tDesc.d3d12Desc.Format = bHDR ? DXGI_FORMAT_R32G32B32A32_FLOAT : DXGI_FORMAT_R8G8B8A8_UNORM; + tDesc.d3d12Desc.DepthOrArraySize = 1; + tDesc.d3d12Desc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D; + tDesc.d3d12Desc.Alignment = 0; + tDesc.d3d12Desc.DepthOrArraySize = 1; + tDesc.d3d12Desc.MipLevels = 1; + tDesc.d3d12Desc.SampleDesc.Count = 1; + tDesc.d3d12Desc.SampleDesc.Quality = 0; + tDesc.d3d12Desc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN; + tDesc.d3d12Desc.Flags = D3D12_RESOURCE_FLAG_NONE; + + tex.Create(tDesc, image.pData); ID = AddTexture_ThreadSafe(std::move(tex)); - mLoadedTexturePaths[std::string(pFilePath)] = ID; + this->QueueTextureUpload(FTextureUploadDesc(std::move(image), ID, tDesc)); + + this->StartTextureUploads(); + while (!mTextures.at(ID).bResident); // busy wait here until the texture is made resident; + #if LOG_RESOURCE_CREATE Log::Info("VQRenderer::CreateTextureFromFile(): [%.2fs] %s", t.StopGetDeltaTimeAndReset(), pFilePath); #endif } - uploadHeap.Destroy(); // this is VERY expensive, TODO: find another solution. + return ID; } TextureID VQRenderer::CreateTexture(const std::string& name, const D3D12_RESOURCE_DESC& desc, D3D12_RESOURCE_STATES ResourceState, const void* pData) { Texture tex; - - // https://docs.microsoft.com/en-us/windows/win32/direct3d12/residency#heap-resources - // Heap creation can be slow; but it is optimized for background thread processing. - // It's recommended to create heaps on background threads to avoid glitching the render - // thread. In D3D12, multiple threads may safely call create routines concurrently. - UploadHeap uploadHeap; - uploadHeap.Create(mDevice.GetDevicePtr(), 32 * MEGABYTE); // TODO: drive the heapsize through RendererSettings.ini + Timer t; t.Start(); TextureCreateDesc tDesc(name); - tDesc.Desc = desc; + tDesc.d3d12Desc = desc; tDesc.pAllocator = mpAllocator; tDesc.pDevice = mDevice.GetDevicePtr(); - tDesc.pUploadHeap = &uploadHeap; tDesc.ResourceState = ResourceState; tex.Create(tDesc, pData); - uploadHeap.UploadToGPUAndWait(mGFXQueue.pQueue); - uploadHeap.Destroy(); + TextureID ID = AddTexture_ThreadSafe(std::move(tex)); + if (pData) + { + this->QueueTextureUpload(FTextureUploadDesc(pData, ID, tDesc)); + + this->StartTextureUploads(); + std::atomic& bResident = mTextures.at(ID).bResident; + while (!bResident); // busy wait here until the texture is made resident; + } + + if (pData) + { +#if LOG_RESOURCE_CREATE + Log::Info("VQRenderer::CreateTexture(): [%.2fs] %s", t.StopGetDeltaTimeAndReset(), name.c_str()); +#endif + } - return AddTexture_ThreadSafe(std::move(tex)); + return ID; } SRV_ID VQRenderer::CreateAndInitializeSRV(TextureID texID) { @@ -374,6 +401,95 @@ ID3D12Resource* VQRenderer::GetTextureResource(TextureID Id) return mTextures.at(Id).GetResource(); } +void VQRenderer::QueueTextureUpload(const FTextureUploadDesc& desc) +{ + std::unique_lock lk(mMtxTextureUploadQueue); + mTextureUploadQueue.push(desc); +} + +void VQRenderer::ProcessTextureUploadQueue() +{ + std::unique_lock lk(mMtxTextureUploadQueue); + if (mTextureUploadQueue.empty()) + return; + + ID3D12GraphicsCommandList* pCmd = mHeapUpload.GetCommandList(); + ID3D12Device* pDevice = mDevice.GetDevicePtr(); + + std::vector*> vTexResidentBools; + + while (!mTextureUploadQueue.empty()) + { + FTextureUploadDesc desc = std::move(mTextureUploadQueue.front()); + mTextureUploadQueue.pop(); + + ID3D12Resource* pResc = GetTextureResource(desc.id); + const void* pData = desc.img.pData ? desc.img.pData : desc.pData; + assert(pData); + + const UINT64 UploadBufferSize = GetRequiredIntermediateSize(pResc, 0, 1); + + UINT8* pUploadBufferMem = mHeapUpload.Suballocate(SIZE_T(UploadBufferSize), D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT); + if (pUploadBufferMem == NULL) + { + // We ran out of mem in the upload heap, flush it and try allocating mem from it again + mHeapUpload.UploadToGPUAndWait(); + pUploadBufferMem = mHeapUpload.Suballocate(SIZE_T(UploadBufferSize), D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT); + assert(pUploadBufferMem); + } + + UINT64 UplHeapSize; + uint32_t num_rows = {}; + UINT64 row_size_in_bytes = {}; + D3D12_PLACED_SUBRESOURCE_FOOTPRINT placedTex2D = {}; + D3D12_RESOURCE_DESC d3dDesc = {}; + + pDevice->GetCopyableFootprints(&desc.desc.d3d12Desc, 0, 1, 0, &placedTex2D, &num_rows, &row_size_in_bytes, &UplHeapSize); + placedTex2D.Offset += UINT64(pUploadBufferMem - mHeapUpload.BasePtr()); + + // copy data row by row + for (uint32_t y = 0; y < num_rows; y++) + { + const UINT64 UploadMemOffset = y * placedTex2D.Footprint.RowPitch; + const UINT64 DataMemOffset = y * row_size_in_bytes; + memcpy(pUploadBufferMem + UploadMemOffset, (UINT8*)pData + DataMemOffset, row_size_in_bytes); + } + + CD3DX12_TEXTURE_COPY_LOCATION Dst(pResc, 0); + CD3DX12_TEXTURE_COPY_LOCATION Src(mHeapUpload.GetResource(), placedTex2D); + pCmd->CopyTextureRegion(&Dst, 0, 0, 0, &Src, NULL); + + D3D12_RESOURCE_BARRIER textureBarrier = {}; + textureBarrier.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION; + textureBarrier.Transition.pResource = pResc; + textureBarrier.Transition.StateBefore = D3D12_RESOURCE_STATE_COPY_DEST; + textureBarrier.Transition.StateAfter = desc.desc.ResourceState; + textureBarrier.Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES; + pCmd->ResourceBarrier(1, &textureBarrier); + + Texture& tex = mTextures.at(desc.id); + vTexResidentBools.push_back(&tex.bResident); + } + + mHeapUpload.UploadToGPUAndWait(); + + for (std::atomic* pbResident : vTexResidentBools) + pbResident->store(true); +} + +void VQRenderer::TextureUploadThread_Main() +{ + while (!mbExitUploadThread) + { + mSignal_UploadThreadWorkReady.Wait([&]() { return mbExitUploadThread.load() || !mTextureUploadQueue.empty(); }); + + if (mbExitUploadThread) + break; + + this->ProcessTextureUploadQueue(); + } +} + TextureID VQRenderer::AddTexture_ThreadSafe(Texture&& tex) { @@ -381,7 +497,8 @@ TextureID VQRenderer::AddTexture_ThreadSafe(Texture&& tex) std::lock_guard lk(mMtxTextures); Id = LAST_USED_TEXTURE_ID++; - mTextures[Id] = tex; + + mTextures[Id] = std::move(tex); return Id; } diff --git a/Source/Renderer/ResourceHeaps.cpp b/Source/Renderer/ResourceHeaps.cpp index d5f7bdfe..2b1f1f5f 100644 --- a/Source/Renderer/ResourceHeaps.cpp +++ b/Source/Renderer/ResourceHeaps.cpp @@ -109,9 +109,10 @@ bool StaticResourceViewHeap::AllocDescriptor(uint32 size, ResourceView* pRV) // UploadHeap // //-------------------------------------------------------------------------------------- -void UploadHeap::Create(ID3D12Device* pDevice, SIZE_T uSize) +void UploadHeap::Create(ID3D12Device* pDevice, SIZE_T uSize, ID3D12CommandQueue* pQueue) { mpDevice = pDevice; + mpQueue = pQueue; // Create command list and allocators @@ -177,8 +178,13 @@ UINT8* UploadHeap::Suballocate(SIZE_T uSize, UINT64 uAlign) return pRet; } -void UploadHeap::UploadToGPUAndWait(ID3D12CommandQueue* pCmdQueue) +void UploadHeap::UploadToGPUAndWait(ID3D12CommandQueue* pCmdQueue /* =nullptr */) { + if (!pCmdQueue) + { + pCmdQueue = this->mpQueue; + } + mpCommandList->Close(); pCmdQueue->ExecuteCommandLists(1, CommandListCast(&mpCommandList)); pCmdQueue->Signal(mpFence, mFenceValue); diff --git a/Source/Renderer/ResourceHeaps.h b/Source/Renderer/ResourceHeaps.h index 53017e18..beb05f67 100644 --- a/Source/Renderer/ResourceHeaps.h +++ b/Source/Renderer/ResourceHeaps.h @@ -77,7 +77,7 @@ class StaticResourceViewHeap class UploadHeap { public: - void Create(ID3D12Device* pDevice, SIZE_T uSize); + void Create(ID3D12Device* pDevice, SIZE_T uSize, ID3D12CommandQueue* pQueue); void Destroy(); UINT8* Suballocate(SIZE_T uSize, UINT64 uAlign); @@ -86,11 +86,12 @@ class UploadHeap inline ID3D12Resource* GetResource() const { return mpUploadHeap; } inline ID3D12GraphicsCommandList* GetCommandList() const { return mpCommandList; } - void UploadToGPUAndWait(ID3D12CommandQueue* pCmdQueue); + void UploadToGPUAndWait(ID3D12CommandQueue* pCmdQueue = nullptr); private: ID3D12Device* mpDevice = nullptr; ID3D12Resource* mpUploadHeap = nullptr; + ID3D12CommandQueue* mpQueue = nullptr; ID3D12GraphicsCommandList* mpCommandList = nullptr; ID3D12CommandAllocator* mpCommandAllocator = nullptr; diff --git a/Source/Renderer/Texture.cpp b/Source/Renderer/Texture.cpp index f47d7414..80046843 100644 --- a/Source/Renderer/Texture.cpp +++ b/Source/Renderer/Texture.cpp @@ -29,16 +29,26 @@ #include #include +Texture::Texture(const Texture& other) + : mpAlloc(other.mpAlloc) + , mpTexture(other.mpTexture) + , bResident(other.bResident.load()) +{} -// -// TEXTURE -// -bool Texture::CreateFromFile(const TextureCreateDesc& tDesc, const std::string& FilePath) +Texture& Texture::operator=(const Texture& other) { + mpAlloc = other.mpAlloc; + mpTexture = other.mpTexture; + bResident = other.bResident.load(); + return *this; +} + +bool Texture::ReadImageFromDisk(const std::string& FilePath, Image& img) +{ if (FilePath.empty()) { - Log::Error("Cannot create Texture from file: empty FilePath provided."); + Log::Error("Cannot load Image from file: empty FilePath provided."); return false; } @@ -58,46 +68,20 @@ bool Texture::CreateFromFile(const TextureCreateDesc& tDesc, const std::string& assert(FileExtension != "exr"); // TODO: add exr loading support to Image class const bool bHDR = S_HDR_FORMATS.find(FileExtension) != S_HDR_FORMATS.end(); - // load img - Image image = Image::LoadFromFile(FilePath.c_str(), bHDR); - const bool bImageLoadSucceeded = image.pData && image.BytesPerPixel > 0; - if (bImageLoadSucceeded) - { - TextureCreateDesc desc = tDesc; - desc.Desc.Width = image.Width; - desc.Desc.Height = image.Height; - desc.Desc.Format = bHDR ? DXGI_FORMAT_R32G32B32A32_FLOAT : DXGI_FORMAT_R8G8B8A8_UNORM; - //------------------------------- - desc.Desc.DepthOrArraySize = 1; - desc.Desc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D; - desc.Desc.Alignment = 0; - desc.Desc.DepthOrArraySize = 1; - desc.Desc.MipLevels = 1; - desc.Desc.SampleDesc.Count = 1; - desc.Desc.SampleDesc.Quality = 0; - desc.Desc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN; - desc.Desc.Flags = D3D12_RESOURCE_FLAG_NONE; - //------------------------------- - Create(desc, image.pData); - } - else - { - Log::Error("Texture::CreateFromFile() : TexName=%s, FileName=%s", tDesc.TexName.c_str(), FileName.c_str() ); - } - image.Destroy(); - return bImageLoadSucceeded; + img = Image::LoadFromFile(FilePath.c_str(), bHDR); + return img.pData && img.BytesPerPixel > 0; } -// TODO: clean up function +// +// TEXTURE +// void Texture::Create(const TextureCreateDesc& desc, const void* pData /*= nullptr*/) { HRESULT hr = {}; - ID3D12GraphicsCommandList* pCmd = desc.pUploadHeap->GetCommandList(); - - const bool bDepthStencilTexture = desc.Desc.Format == DXGI_FORMAT_R32_TYPELESS; // TODO: change this? - const bool bRenderTargetTexture = (desc.Desc.Flags & D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET) != 0; - const bool bUnorderedAccessTexture = (desc.Desc.Flags & D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS) != 0; + const bool bDepthStencilTexture = desc.d3d12Desc.Format == DXGI_FORMAT_R32_TYPELESS; // TODO: change this? + const bool bRenderTargetTexture = (desc.d3d12Desc.Flags & D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET) != 0; + const bool bUnorderedAccessTexture = (desc.d3d12Desc.Flags & D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS) != 0; // determine resource state & optimal clear value D3D12_RESOURCE_STATES ResourceState = pData @@ -107,7 +91,7 @@ void Texture::Create(const TextureCreateDesc& desc, const void* pData /*= nullpt if (bDepthStencilTexture) { D3D12_CLEAR_VALUE ClearValue = {}; - ClearValue.Format = (desc.Desc.Format == DXGI_FORMAT_R32_TYPELESS) ? DXGI_FORMAT_D32_FLOAT : desc.Desc.Format; + ClearValue.Format = (desc.d3d12Desc.Format == DXGI_FORMAT_R32_TYPELESS) ? DXGI_FORMAT_D32_FLOAT : desc.d3d12Desc.Format; ClearValue.DepthStencil.Depth = 1.0f; ClearValue.DepthStencil.Stencil = 0; pClearValue = &ClearValue; @@ -115,7 +99,7 @@ void Texture::Create(const TextureCreateDesc& desc, const void* pData /*= nullpt if (bRenderTargetTexture) { D3D12_CLEAR_VALUE ClearValue = {}; - ClearValue.Format = desc.Desc.Format; + ClearValue.Format = desc.d3d12Desc.Format; pClearValue = &ClearValue; } if (bUnorderedAccessTexture) @@ -129,7 +113,7 @@ void Texture::Create(const TextureCreateDesc& desc, const void* pData /*= nullpt textureAllocDesc.HeapType = D3D12_HEAP_TYPE_DEFAULT; hr = desc.pAllocator->CreateResource( &textureAllocDesc, - &desc.Desc, + &desc.d3d12Desc, ResourceState, pClearValue, &mpAlloc, @@ -140,64 +124,6 @@ void Texture::Create(const TextureCreateDesc& desc, const void* pData /*= nullpt return; } SetName(mpTexture, desc.TexName.c_str()); - - // upload the data - if (pData) - { - const UINT64 UploadBufferSize = GetRequiredIntermediateSize(mpTexture, 0, 1); - -#if 1 - UINT8* pUploadBufferMem = desc.pUploadHeap->Suballocate(SIZE_T(UploadBufferSize), D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT); - if (pUploadBufferMem == NULL) - { - - // TODO: - // We ran out of mem in the upload heap, flush it and try allocating mem from it again -#if 0 - desc.pUploadHeap->UploadToGPUAndWait(); - pUploadBufferMem = desc.pUploadHeap->Suballocate(SIZE_T(UploadBufferSize), D3D12_TEXTURE_DATA_PLACEMENT_ALIGNMENT); - assert(pUploadBufferMem); -#else - assert(false); -#endif - } - - UINT64 UplHeapSize; - uint32_t num_rows = {}; - UINT64 row_size_in_bytes = {}; - D3D12_PLACED_SUBRESOURCE_FOOTPRINT placedTex2D = {}; - desc.pDevice->GetCopyableFootprints(&desc.Desc, 0, 1, 0, &placedTex2D, &num_rows, &row_size_in_bytes, &UplHeapSize); - placedTex2D.Offset += UINT64(pUploadBufferMem - desc.pUploadHeap->BasePtr()); - - // copy data row by row - for (uint32_t y = 0; y < num_rows; y++) - { - const UINT64 UploadMemOffset = y * placedTex2D.Footprint.RowPitch; - const UINT64 DataMemOffset = y * row_size_in_bytes; - memcpy(pUploadBufferMem + UploadMemOffset, (UINT8*)pData + DataMemOffset, row_size_in_bytes); - } - - CD3DX12_TEXTURE_COPY_LOCATION Dst(mpTexture, 0); - CD3DX12_TEXTURE_COPY_LOCATION Src(desc.pUploadHeap->GetResource(), placedTex2D); - desc.pUploadHeap->GetCommandList()->CopyTextureRegion(&Dst, 0, 0, 0, &Src, NULL); - -#else - D3D12_SUBRESOURCE_DATA textureSubresourceData = {}; - textureSubresourceData.pData = pData; - textureSubresourceData.RowPitch = imageBytesPerRow; - textureSubresourceData.SlicePitch = imageBytesPerRow * desc.Desc.Height; - - UpdateSubresources(pCmd, mpTexture, textureUpload, 0, 0, 1, &textureSubresourceData); -#endif - - D3D12_RESOURCE_BARRIER textureBarrier = {}; - textureBarrier.Type = D3D12_RESOURCE_BARRIER_TYPE_TRANSITION; - textureBarrier.Transition.pResource = mpTexture; - textureBarrier.Transition.StateBefore = D3D12_RESOURCE_STATE_COPY_DEST; - textureBarrier.Transition.StateAfter = desc.ResourceState; - textureBarrier.Transition.Subresource = D3D12_RESOURCE_BARRIER_ALL_SUBRESOURCES; - pCmd->ResourceBarrier(1, &textureBarrier); - } } @@ -278,6 +204,7 @@ void Texture::InitializeUAV(uint32 index, CBV_SRV_UAV* pRV, D3D12_UNORDERED_ACCE pDevice->Release(); } + #if 0 void Texture::CreateUAV(uint32_t index, Texture* pCounterTex, CBV_SRV_UAV* pRV, D3D12_UNORDERED_ACCESS_VIEW_DESC* pUavDesc) { diff --git a/Source/Renderer/Texture.h b/Source/Renderer/Texture.h index 8ba6c33c..81c363bd 100644 --- a/Source/Renderer/Texture.h +++ b/Source/Renderer/Texture.h @@ -22,6 +22,7 @@ #include +#include #include namespace D3D12MA { class Allocation; class Allocator; } @@ -31,17 +32,16 @@ class CBV_SRV_UAV; class DSV; class RTV; struct D3D12_SHADER_RESOURCE_VIEW_DESC; +struct Image; struct TextureCreateDesc { TextureCreateDesc(const std::string& name) : TexName(name) {} ID3D12Device* pDevice = nullptr; D3D12MA::Allocator* pAllocator = nullptr; - UploadHeap* pUploadHeap = nullptr; - D3D12_RESOURCE_DESC Desc = {}; + D3D12_RESOURCE_DESC d3d12Desc = {}; D3D12_RESOURCE_STATES ResourceState = D3D12_RESOURCE_STATE_COMMON; const std::string& TexName; - }; @@ -77,8 +77,9 @@ class Texture Texture() = default; ~Texture() = default; + Texture(const Texture& other); + Texture& operator=(const Texture& other); - bool CreateFromFile(const TextureCreateDesc& desc, const std::string& FilePath); void Create(const TextureCreateDesc& desc, const void* pData = nullptr); void Destroy(); @@ -91,8 +92,11 @@ class Texture inline const ID3D12Resource* GetResource() const { return mpTexture; } inline ID3D12Resource* GetResource() { return mpTexture; } public: + static bool ReadImageFromDisk(const std::string& path, Image& img); private: + friend class VQRenderer; D3D12MA::Allocation* mpAlloc = nullptr; ID3D12Resource* mpTexture = nullptr; + std::atomic bResident = false; }; \ No newline at end of file From b24ed1fb6c468c95ff2cfb68ded23fffed8fdc53 Mon Sep 17 00:00:00 2001 From: Volkan Date: Mon, 7 Sep 2020 22:58:48 -0700 Subject: [PATCH 40/67] Fix memory leak on Images --- Source/Renderer/Renderer_Resources.cpp | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/Source/Renderer/Renderer_Resources.cpp b/Source/Renderer/Renderer_Resources.cpp index 435a6b72..8237ee05 100644 --- a/Source/Renderer/Renderer_Resources.cpp +++ b/Source/Renderer/Renderer_Resources.cpp @@ -417,6 +417,7 @@ void VQRenderer::ProcessTextureUploadQueue() ID3D12Device* pDevice = mDevice.GetDevicePtr(); std::vector*> vTexResidentBools; + std::vector vImages; while (!mTextureUploadQueue.empty()) { @@ -469,12 +470,20 @@ void VQRenderer::ProcessTextureUploadQueue() Texture& tex = mTextures.at(desc.id); vTexResidentBools.push_back(&tex.bResident); + + if (desc.img.pData) + { + vImages.push_back(std::move(desc.img)); + } } mHeapUpload.UploadToGPUAndWait(); for (std::atomic* pbResident : vTexResidentBools) pbResident->store(true); + + for (Image& img : vImages) + img.Destroy(); // free the image memory } void VQRenderer::TextureUploadThread_Main() From 97009d2c0ff99da8dd51bf089ec5f4ae9edb1628 Mon Sep 17 00:00:00 2001 From: Volkan Date: Mon, 7 Sep 2020 23:12:00 -0700 Subject: [PATCH 41/67] Fix vertex/index buffer heap upload sync issue --- Source/Application/Scene.cpp | 4 ++++ Source/Application/VQEngine_Render.cpp | 2 ++ Source/Application/VQEngine_Update.cpp | 5 +---- Source/Renderer/Buffer.cpp | 8 +++++++- Source/Renderer/Renderer.cpp | 4 +++- Source/Renderer/Renderer.h | 1 + Source/Renderer/Renderer_Resources.cpp | 2 +- 7 files changed, 19 insertions(+), 7 deletions(-) diff --git a/Source/Application/Scene.cpp b/Source/Application/Scene.cpp index 7224792f..d68a1c2a 100644 --- a/Source/Application/Scene.cpp +++ b/Source/Application/Scene.cpp @@ -193,6 +193,10 @@ void Scene::PostUpdate(int FRAME_DATA_INDEX, int FRAME_DATA_NEXT_INDEX) void Scene::StartLoading(const BuiltinMeshArray_t& builtinMeshes, FSceneRepresentation& scene) { + mRenderer.WaitForLoadCompletion(); + + Log::Info("[Scene] Loading Scene: %s", scene.SceneName.c_str()); + constexpr bool B_LOAD_SERIAL = true; auto fnDeserializeGameObject = [&](FGameObjectRepresentation& ObjRep) { diff --git a/Source/Application/VQEngine_Render.cpp b/Source/Application/VQEngine_Render.cpp index fba067f7..d2e1412e 100644 --- a/Source/Application/VQEngine_Render.cpp +++ b/Source/Application/VQEngine_Render.cpp @@ -187,6 +187,8 @@ void VQEngine::InitializeBuiltinMeshes() } // ... + + mRenderer.UploadVertexAndIndexBufferHeaps(); } diff --git a/Source/Application/VQEngine_Update.cpp b/Source/Application/VQEngine_Update.cpp index b1fc281b..3b9f021b 100644 --- a/Source/Application/VQEngine_Update.cpp +++ b/Source/Application/VQEngine_Update.cpp @@ -476,11 +476,8 @@ void VQEngine::Load_SceneData_Dispatch() FSceneRepresentation SceneRep = VQEngine::ParseSceneFile(SceneFilePath); fnCreateSceneInstance(SceneRep.SceneName, mpScene); - // let the custom scene logic edit the scene representation - mpScene->StartLoading(this->mBuiltinMeshes, SceneRep); - // start loading; - Log::Info("[Scene] Loading: %s", SceneRep.SceneName.c_str()); + mpScene->StartLoading(this->mBuiltinMeshes, SceneRep); if (!SceneRep.EnvironmentMapPreset.empty()) { diff --git a/Source/Renderer/Buffer.cpp b/Source/Renderer/Buffer.cpp index bd5d641d..1b0f0f5d 100644 --- a/Source/Renderer/Buffer.cpp +++ b/Source/Renderer/Buffer.cpp @@ -152,7 +152,13 @@ bool StaticBufferHeap::AllocBuffer(uint32 numElements, uint32 strideInBytes, voi std::lock_guard lock(mMtx); uint32 size = AlignOffset(numElements * strideInBytes, (uint32)StaticBufferHeap::MEMORY_ALIGNMENT); - assert( (mMemOffset + size) < mTotalMemSize); // if this is hit, initialize heap with a larger size. + const bool bHeapOutOfMemory = ((mMemOffset + size) > mTotalMemSize); + assert( !bHeapOutOfMemory); // if this is hit, initialize heap with a larger size. + if (bHeapOutOfMemory) + { + Log::Error("Static Heap out of memory."); + return false; + } *ppDataOut = (void*)(mpData + mMemOffset); diff --git a/Source/Renderer/Renderer.cpp b/Source/Renderer/Renderer.cpp index f8ca85a8..bb490910 100644 --- a/Source/Renderer/Renderer.cpp +++ b/Source/Renderer/Renderer.cpp @@ -145,7 +145,8 @@ void VQRenderer::Load() { LoadPSOs(); LoadDefaultResources(); - this->UploadVertexAndIndexBufferHeaps(); + + Log::Info("[Renderer] Loaded."); mbDefaultResourcesLoaded.store(true); } @@ -885,6 +886,7 @@ void VQRenderer::LoadDefaultResources() } void VQRenderer::UploadVertexAndIndexBufferHeaps() { + std::lock_guard lk(mMtxTextureUploadQueue); mStaticHeap_VertexBuffer.UploadData(mHeapUpload.GetCommandList()); mStaticHeap_IndexBuffer.UploadData(mHeapUpload.GetCommandList()); } diff --git a/Source/Renderer/Renderer.h b/Source/Renderer/Renderer.h index d0b60eb4..296179f5 100644 --- a/Source/Renderer/Renderer.h +++ b/Source/Renderer/Renderer.h @@ -122,6 +122,7 @@ class VQRenderer void Load(); void Unload(); void Exit(); + inline void WaitForLoadCompletion() const { while (!mbDefaultResourcesLoaded); }; void OnWindowSizeChanged(HWND hwnd, unsigned w, unsigned h); diff --git a/Source/Renderer/Renderer_Resources.cpp b/Source/Renderer/Renderer_Resources.cpp index 8237ee05..7d0c943a 100644 --- a/Source/Renderer/Renderer_Resources.cpp +++ b/Source/Renderer/Renderer_Resources.cpp @@ -283,10 +283,10 @@ void VQRenderer::InitializeDSV(DSV_ID dsvID, uint32 heapIndex, TextureID texID) } void VQRenderer::InitializeSRV(SRV_ID srvID, uint heapIndex, TextureID texID) { + CHECK_RESOURCE_VIEW(SRV, srvID); if (texID != INVALID_ID) { CHECK_TEXTURE(mTextures, texID); - CHECK_RESOURCE_VIEW(SRV, srvID); mTextures.at(texID).InitializeSRV(heapIndex, &mSRVs.at(srvID)); } else // init NULL SRV From bf3d557c20e437b639addc590143f67e55395100 Mon Sep 17 00:00:00 2001 From: Volkan Date: Tue, 8 Sep 2020 00:05:19 -0700 Subject: [PATCH 42/67] update assimp to latest version --- Libs/assimp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Libs/assimp b/Libs/assimp index 48ec3ef4..9ce06711 160000 --- a/Libs/assimp +++ b/Libs/assimp @@ -1 +1 @@ -Subproject commit 48ec3ef458011dc21fa8bb2f5cf351490febf5f2 +Subproject commit 9ce0671134912fd49010d81b89ae56dc41029c39 From 9e9a12d9813d51657c78667ab815ec83bb54e719 Mon Sep 17 00:00:00 2001 From: Volkan Date: Wed, 9 Sep 2020 00:03:05 -0700 Subject: [PATCH 43/67] Add GLTF loader to assimp, remove obj sponza --- Build/GenerateProjectFiles.bat | 1 + Source/Application/AssetLoader.cpp | 18 ++---------------- Source/Application/AssetLoader.h | 3 +-- 3 files changed, 4 insertions(+), 18 deletions(-) diff --git a/Build/GenerateProjectFiles.bat b/Build/GenerateProjectFiles.bat index 23826247..cf0fd25f 100644 --- a/Build/GenerateProjectFiles.bat +++ b/Build/GenerateProjectFiles.bat @@ -130,6 +130,7 @@ exit /b 0 :: assimp importers set ASSIMP_IMPORT_FORMATS=-DASSIMP_BUILD_OBJ_IMPORTER=TRUE +set ASSIMP_IMPORT_FORMATS=!ASSIMP_IMPORT_FORMATS! -DASSIMP_BUILD_GLTF_IMPORTER=TRUE :: assimp build options set CMAKE_ASSIMP_PARAMETERS=-DASSIMP_BUILD_ASSIMP_TOOLS=OFF set CMAKE_ASSIMP_PARAMETERS=!CMAKE_ASSIMP_PARAMETERS! -DASSIMP_NO_EXPORT=ON diff --git a/Source/Application/AssetLoader.cpp b/Source/Application/AssetLoader.cpp index a84e28f3..4501f913 100644 --- a/Source/Application/AssetLoader.cpp +++ b/Source/Application/AssetLoader.cpp @@ -43,14 +43,8 @@ void AssetLoader::QueueModelLoad(GameObject* pObject, const std::string& ModelPa { const std::string FileExtension = DirectoryUtil::GetFileExtension(ModelPath); - static const std::unordered_map MODEL_IMPORT_FUNCTIONS = - { - { "obj" , AssetLoader::ImportModel_obj } - , { "gltf", AssetLoader::ImportModel_gltf } // TODO - }; - std::unique_lock lk(mMtxQueue_ModelLoad); - mModelLoadQueue.push({pObject, ModelPath, ModelName, MODEL_IMPORT_FUNCTIONS.at(FileExtension)}); + mModelLoadQueue.push({pObject, ModelPath, ModelName, AssetLoader::ImportModel }); } AssetLoader::ModelLoadResults_t AssetLoader::StartLoadingModels(Scene* pScene) @@ -306,7 +300,7 @@ Model::Data ProcessAssimpNode( , AssetLoader::FMaterialTextureAssignments& MaterialTextureAssignments ); -ModelID AssetLoader::ImportModel_obj(Scene* pScene, AssetLoader* pAssetLoader, VQRenderer* pRenderer, const std::string& objFilePath, std::string ModelName) +ModelID AssetLoader::ImportModel(Scene* pScene, AssetLoader* pAssetLoader, VQRenderer* pRenderer, const std::string& objFilePath, std::string ModelName) { constexpr auto ASSIMP_LOAD_FLAGS = aiProcess_Triangulate @@ -362,14 +356,6 @@ ModelID AssetLoader::ImportModel_obj(Scene* pScene, AssetLoader* pAssetLoader, V return mID; } -ModelID AssetLoader::ImportModel_gltf(Scene* pScene, AssetLoader* pAssetLoader, VQRenderer* pRenderer, const std::string& objFilePath, std::string ModelName) -{ - assert(false); // TODO - return INVALID_ID; -} - - - //---------------------------------------------------------------------------------------------------------------- // ASSIMP HELPER FUNCTIONS //---------------------------------------------------------------------------------------------------------------- diff --git a/Source/Application/AssetLoader.h b/Source/Application/AssetLoader.h index 540c6ae4..d3ba209e 100644 --- a/Source/Application/AssetLoader.h +++ b/Source/Application/AssetLoader.h @@ -102,8 +102,7 @@ class AssetLoader void QueueTextureLoad(const FTextureLoadParams& TexLoadParam); TextureLoadResults_t StartLoadingTextures(); private: - static ModelID ImportModel_obj (Scene* pScene, AssetLoader* pAssetLoader, VQRenderer* pRenderer, const std::string& objFilePath, std::string ModelName = "NONE"); // TODO: rename to LoadModel_obj() ? - static ModelID ImportModel_gltf(Scene* pScene, AssetLoader* pAssetLoader, VQRenderer* pRenderer, const std::string& objFilePath, std::string ModelName = "NONE"); // TODO: rename to LoadModel_gltf() ? + static ModelID ImportModel(Scene* pScene, AssetLoader* pAssetLoader, VQRenderer* pRenderer, const std::string& objFilePath, std::string ModelName = "NONE"); private: std::unordered_map mLoadedModels; From c95d5f0e69cfb8bb9cfcff512fc6f748276472e3 Mon Sep 17 00:00:00 2001 From: Volkan Date: Wed, 9 Sep 2020 00:27:04 -0700 Subject: [PATCH 44/67] Add VQModels as submodule --- .gitmodules | 3 +++ Data/Models | 1 + 2 files changed, 4 insertions(+) create mode 160000 Data/Models diff --git a/.gitmodules b/.gitmodules index fd3dfce1..39e0fe45 100644 --- a/.gitmodules +++ b/.gitmodules @@ -10,3 +10,6 @@ [submodule "Libs/assimp"] path = Libs/assimp url = https://github.com/assimp/assimp.git +[submodule "Data/Models"] + path = Data/Models + url = https://github.com/vilbeyli/VQModels.git diff --git a/Data/Models b/Data/Models new file mode 160000 index 00000000..942f5d87 --- /dev/null +++ b/Data/Models @@ -0,0 +1 @@ +Subproject commit 942f5d871b95683e6db8126de710994ff3f78204 From 23c76866dc1823ddeb5ea4f2dc1998bfcfb5b50d Mon Sep 17 00:00:00 2001 From: Volkan Date: Wed, 9 Sep 2020 18:37:13 -0700 Subject: [PATCH 45/67] Fix multithreaded texture loading during asset import, update sponza model --- Data/Levels/Sponza.xml | 8 +- Data/Levels/StressTest.xml | 82 ++++++++++++++++++- Source/Application/AssetLoader.cpp | 108 +++++++++++++++++-------- Source/Application/AssetLoader.h | 24 ++++-- Source/Application/Scene.cpp | 8 +- Source/Renderer/Renderer_Resources.cpp | 5 +- 6 files changed, 185 insertions(+), 50 deletions(-) diff --git a/Data/Levels/Sponza.xml b/Data/Levels/Sponza.xml index be5e31da..3ebe082c 100644 --- a/Data/Levels/Sponza.xml +++ b/Data/Levels/Sponza.xml @@ -30,7 +30,7 @@ 1 1 1 - Data/Models/sponza/sponza.obj + Data/Models/Sponza/glTF/Sponza.gltf Sponza @@ -43,7 +43,7 @@ 0.05 0.05 0.05 - Data/Models/sponza/sponza.obj + Data/Models/Sponza/glTF/Sponza.gltf Sponza @@ -54,7 +54,7 @@ 0.06 0.06 0.06 - Data/Models/sponza/sponza.obj + Data/Models/Sponza/glTF/Sponza.gltf Sponza @@ -65,7 +65,7 @@ 0.07 0.07 0.07 - Data/Models/sponza/sponza.obj + Data/Models/Sponza/glTF/Sponza.gltf Sponza diff --git a/Data/Levels/StressTest.xml b/Data/Levels/StressTest.xml index 0697c5c0..3633f6d0 100644 --- a/Data/Levels/StressTest.xml +++ b/Data/Levels/StressTest.xml @@ -31,7 +31,7 @@ --> - 0.0 3.0 -5 + 0.0 24.0 -93 15 0 Perspective @@ -46,7 +46,87 @@ + + + -20 40 0 + 0 0 0 1 + 50 50 50 + + + Data/Models/FlightHelmet/glTF/FlightHelmet.gltf + FlightHelmet + + + + + 20 20 0 + 0 0 0 1 + 0.01 0.01 0.01 + + + Data/Models/Sponza/glTF/Sponza.gltf + Sponza + + + + + -60 20 0 + 0 0 0 1 + 1000 1000 1000 + + + Data/Models/BoomBox/glTF/BoomBox.gltf + BoomBox + + + + + + -40 20 0 + 0 0 0 1 + 10 10 10 + + + Data/Models/DamagedHelmet/glTF/DamagedHelmet.gltf + DamagedHelmet + + + + + -20 20 0 + 0 0 0 1 + 10 10 10 + + + Data/Models/Suzanne/glTF/Suzanne.gltf + Suzanne + + + + + + -60 40 0 + 0 0 0 1 + 8 8 8 + + + Data/Models/SciFiHelmet/glTF/SciFiHelmet.gltf + SciFiHelmet + + + + + + -40 40 0 + 0 0 0 1 + 1 1 1 + + + Data/Models/Lantern/glTF/Lantern.gltf + Lantern + + diff --git a/Source/Application/AssetLoader.cpp b/Source/Application/AssetLoader.cpp index 4501f913..e198d403 100644 --- a/Source/Application/AssetLoader.cpp +++ b/Source/Application/AssetLoader.cpp @@ -36,6 +36,13 @@ using namespace Assimp; using namespace DirectX; +AssetLoader::LoadTaskID AssetLoader::GenerateLoadTaskID() +{ + static std::atomic LOAD_TASK_ID = 0; + LoadTaskID id = LOAD_TASK_ID.fetch_add(1); + return id; +} + //---------------------------------------------------------------------------------------------------------------- // ASSET LOADER //---------------------------------------------------------------------------------------------------------------- @@ -99,32 +106,36 @@ AssetLoader::ModelLoadResults_t AssetLoader::StartLoadingModels(Scene* pScene) return ModelLoadResults; } -void AssetLoader::QueueTextureLoad(const FTextureLoadParams& TexLoadParam) +void AssetLoader::QueueTextureLoad(LoadTaskID taskID, const FTextureLoadParams& TexLoadParam) { - std::unique_lock lk(mMtxQueue_TextureLoad); - mTextureLoadQueue.push(TexLoadParam); + FLoadTaskContext& ctx = mLookup_TextureLoadContext[taskID]; + std::unique_lock lk(ctx.Mtx); + ctx.LoadQueue.push(TexLoadParam); } -AssetLoader::TextureLoadResults_t AssetLoader::StartLoadingTextures() +AssetLoader::TextureLoadResults_t AssetLoader::StartLoadingTextures(LoadTaskID taskID) { TextureLoadResults_t TextureLoadResults; - if (mTextureLoadQueue.empty()) + FLoadTaskContext& ctx = mLookup_TextureLoadContext.at(taskID); + + if (ctx.LoadQueue.empty()) { - Log::Warning("AssetLoader::StartLoadingTextures(): no Textures to load"); + Log::Warning("AssetLoader::StartLoadingTextures(taskID=%d): no Textures to load", taskID); return TextureLoadResults; } + std::unordered_map> Lookup_TextureLoadResult; + // process model load queue - std::unique_lock lk(mMtxQueue_ModelLoad); do { - FTextureLoadParams TexLoadParams = std::move(mTextureLoadQueue.front()); - mTextureLoadQueue.pop(); + FTextureLoadParams TexLoadParams = std::move(ctx.LoadQueue.front()); + ctx.LoadQueue.pop(); - // eliminate duplicates - if (mUniqueTexturePaths.find(TexLoadParams.TexturePath) == mUniqueTexturePaths.end()) + // handle duplicate texture load paths + if (ctx.UniquePaths.find(TexLoadParams.TexturePath) == ctx.UniquePaths.end()) { - mUniqueTexturePaths.insert(TexLoadParams.TexturePath); + ctx.UniquePaths.insert(TexLoadParams.TexturePath); // determine whether we'll load file OR use a procedurally generated texture auto vPathTokens = StrUtil::split(TexLoadParams.TexturePath, '/'); @@ -141,7 +152,8 @@ AssetLoader::TextureLoadResults_t AssetLoader::StartLoadingTextures() break; } - std::future texLoadResult = std::move(mWorkers.AddTask([this, TexLoadParams, ProcTex]() + // dispatch worker thread + std::shared_future texLoadResult = std::move(mWorkers.AddTask([this, TexLoadParams, ProcTex]() { const bool IS_PROCEDURAL = ProcTex != EProceduralTextures::NUM_PROCEDURAL_TEXTURES; if (IS_PROCEDURAL) @@ -151,11 +163,21 @@ AssetLoader::TextureLoadResults_t AssetLoader::StartLoadingTextures() return mRenderer.CreateTextureFromFile(TexLoadParams.TexturePath.c_str()); })); + + // update results lookup for the shared textures (among different materials) + Lookup_TextureLoadResult[TexLoadParams.TexturePath] = texLoadResult; + + // record load results TextureLoadResults.emplace(std::make_pair(TexLoadParams.MatID, TextureLoadResult_t{ TexLoadParams.TexType, std::move(texLoadResult) })); } - } while (!mTextureLoadQueue.empty()); + // shared textures among materials + else + { + TextureLoadResults.emplace(std::make_pair(TexLoadParams.MatID, TextureLoadResult_t{ TexLoadParams.TexType, Lookup_TextureLoadResult.at(TexLoadParams.TexturePath) })); + } + } while (!ctx.LoadQueue.empty()); - mUniqueTexturePaths.clear(); + ctx.UniquePaths.clear(); // Currently mRenderer.CreateTextureFromFile() starts the texture uploads ///mRenderer.StartTextureUploads(); @@ -297,7 +319,8 @@ Model::Data ProcessAssimpNode( , AssetLoader* pAssetLoader , Scene* pScene , VQRenderer* pRenderer - , AssetLoader::FMaterialTextureAssignments& MaterialTextureAssignments + , AssetLoader::FMaterialTextureAssignments& MaterialTextureAssignments, + AssetLoader::LoadTaskID taskID ); ModelID AssetLoader::ImportModel(Scene* pScene, AssetLoader* pAssetLoader, VQRenderer* pRenderer, const std::string& objFilePath, std::string ModelName) @@ -313,10 +336,12 @@ ModelID AssetLoader::ImportModel(Scene* pScene, AssetLoader* pAssetLoader, VQRen | aiProcess_JoinIdenticalVertices | aiProcess_GenSmoothNormals; - + + LoadTaskID taskID = GenerateLoadTaskID(); + //----------------------------------------------- const std::string modelDirectory = DirectoryUtil::GetFolderPath(objFilePath); - Log::Info("ImportModel_obj: %s - %s", ModelName.c_str(), objFilePath.c_str()); + Log::Info("ImportModel: %s - %s", ModelName.c_str(), objFilePath.c_str()); Timer t; t.Start(); @@ -329,14 +354,14 @@ ModelID AssetLoader::ImportModel(Scene* pScene, AssetLoader* pAssetLoader, VQRen return INVALID_ID; } t.Tick(); float fTimeReadFile = t.DeltaTime(); - Log::Info(" ReadFile(): %.3fs", fTimeReadFile); + Log::Info(" [%.2fs] ReadFile=%s ", fTimeReadFile, objFilePath.c_str()); // parse scene and initialize model data FMaterialTextureAssignments MaterialTextureAssignments(pAssetLoader->mWorkers); - Model::Data data = ProcessAssimpNode(pAiScene->mRootNode, pAiScene, modelDirectory, pAssetLoader, pScene, pRenderer, MaterialTextureAssignments); + Model::Data data = ProcessAssimpNode(pAiScene->mRootNode, pAiScene, modelDirectory, pAssetLoader, pScene, pRenderer, MaterialTextureAssignments, taskID); pRenderer->UploadVertexAndIndexBufferHeaps(); // load VB/IBs - MaterialTextureAssignments.mTextureLoadResults = pAssetLoader->StartLoadingTextures(); + MaterialTextureAssignments.mTextureLoadResults = pAssetLoader->StartLoadingTextures(taskID); // cache the imported model in Scene ModelID mID = pScene->CreateModel(); @@ -352,10 +377,14 @@ ModelID AssetLoader::ImportModel(Scene* pScene, AssetLoader* pAssetLoader, VQRen MaterialTextureAssignments.DoAssignments(pScene, pRenderer); t.Stop(); - Log::Info("Loaded Model '%s' in %.2f seconds.", ModelName.c_str(), t.DeltaTime()); + Log::Info(" [%.2fs] Loaded Model '%s'.", fTimeReadFile + t.DeltaTime(), ModelName.c_str()); return mID; } + + + + //---------------------------------------------------------------------------------------------------------------- // ASSIMP HELPER FUNCTIONS //---------------------------------------------------------------------------------------------------------------- @@ -448,7 +477,8 @@ static Model::Data ProcessAssimpNode( AssetLoader* pAssetLoader, Scene* pScene, VQRenderer* pRenderer, - AssetLoader::FMaterialTextureAssignments& MaterialTextureAssignments + AssetLoader::FMaterialTextureAssignments& MaterialTextureAssignments, + AssetLoader::LoadTaskID taskID ) { Model::Data modelData; @@ -460,20 +490,30 @@ static Model::Data ProcessAssimpNode( // MATERIAL - http://assimp.sourceforge.net/lib_html/materials.html aiMaterial* material = pAiScene->mMaterials[pAiMesh->mMaterialIndex]; - // Every material assumed to have a name : Create material here - MaterialID matID = INVALID_ID; - aiString name; - if (aiReturn_SUCCESS == material->Get(AI_MATKEY_NAME, name)) + // Every material assumed to have a name + std::string uniqueMatName; { - const std::string ModelFolderName = DirectoryUtil::GetFlattenedFolderHierarchy(modelDirectory).back(); - std::string uniqueMatName = name.C_Str(); + aiString matName; + if (aiReturn_SUCCESS != material->Get(AI_MATKEY_NAME, matName)) + // material doesn't have a name, use generic name Material# + { + matName = std::string("Material#") + std::to_string(pAiMesh->mMaterialIndex); + } + + // Data/Models/%MODEL_NAME%/... : index 2 will give model name + auto vFolders = DirectoryUtil::GetFlattenedFolderHierarchy(modelDirectory); + assert(vFolders.size() > 2); + const std::string ModelFolderName = vFolders[2]; + uniqueMatName = matName.C_Str(); // modelDirectory = "Data/Models/%MODEL_NAME%/" // Materials use the following unique naming: %MODEL_NAME%/%MATERIAL_NAME% uniqueMatName = ModelFolderName + "/" + uniqueMatName; - matID = pScene->CreateMaterial(uniqueMatName); - Material& mat = pScene->GetMaterial(matID); } + // Create new Material + MaterialID matID = pScene->CreateMaterial(uniqueMatName); + Material& mat = pScene->GetMaterial(matID); + // get texture paths to load AssetLoader::FMaterialTextureAssignment MatTexAssignment = {}; std::vector diffuseMaps = GenerateTextureLoadParams(material, matID, aiTextureType_DIFFUSE, "texture_diffuse", modelDirectory); @@ -490,7 +530,7 @@ static Model::Data ProcessAssimpNode( int iTex = 0; for (const AssetLoader::FTextureLoadParams& param : *pvLoadParams) { - pAssetLoader->QueueTextureLoad(param); + pAssetLoader->QueueTextureLoad(taskID, param); ++iTex; } ++iTexType; @@ -501,8 +541,6 @@ static Model::Data ProcessAssimpNode( MatTexAssignment.matID = matID; MaterialTextureAssignments.mAssignments.push_back(std::move(MatTexAssignment)); - Material& mat = pScene->GetMaterial(matID); - aiColor3D color(0.f, 0.f, 0.f); if (aiReturn_SUCCESS == material->Get(AI_MATKEY_COLOR_DIFFUSE, color)) { @@ -561,7 +599,7 @@ static Model::Data ProcessAssimpNode( for (unsigned int i = 0; i < pNode->mNumChildren; i++) { // then do the same for each of its children - Model::Data childModelData = ProcessAssimpNode(pNode->mChildren[i], pAiScene, modelDirectory, pAssetLoader, pScene, pRenderer, MaterialTextureAssignments); + Model::Data childModelData = ProcessAssimpNode(pNode->mChildren[i], pAiScene, modelDirectory, pAssetLoader, pScene, pRenderer, MaterialTextureAssignments, taskID); std::vector& ChildMeshes = childModelData.mOpaueMeshIDs; std::vector& ChildMeshesTransparent = childModelData.mTransparentMeshIDs; diff --git a/Source/Application/AssetLoader.h b/Source/Application/AssetLoader.h index d3ba209e..63947ae2 100644 --- a/Source/Application/AssetLoader.h +++ b/Source/Application/AssetLoader.h @@ -90,6 +90,9 @@ class AssetLoader void WaitForTextureLoads(); }; public: + using LoadTaskID = int; + static LoadTaskID GenerateLoadTaskID(); + AssetLoader(ThreadPool& WorkerThreads, VQRenderer& renderer) : mWorkers(WorkerThreads) , mRenderer(renderer) @@ -99,8 +102,9 @@ class AssetLoader void QueueModelLoad(GameObject* pObject, const std::string& ModelPath, const std::string& ModelName); ModelLoadResults_t StartLoadingModels(Scene* pScene); - void QueueTextureLoad(const FTextureLoadParams& TexLoadParam); - TextureLoadResults_t StartLoadingTextures(); + void QueueTextureLoad(LoadTaskID taskID, const FTextureLoadParams& TexLoadParam); + TextureLoadResults_t StartLoadingTextures(LoadTaskID taskID); + private: static ModelID ImportModel(Scene* pScene, AssetLoader* pAssetLoader, VQRenderer* pRenderer, const std::string& objFilePath, std::string ModelName = "NONE"); @@ -110,11 +114,21 @@ class AssetLoader // MT Model loading ThreadPool& mWorkers; VQRenderer& mRenderer; + + template + struct FLoadTaskContext + { + std::mutex Mtx; + std::queue LoadQueue; + std::set UniquePaths; + }; + std::unordered_map> mLookup_TextureLoadContext; + // TODO: use ConcurrentQueue with ProcessElements(pfnProcess); std::queue mModelLoadQueue; - std::queue mTextureLoadQueue; + //std::queue mTextureLoadQueue; std::set mUniqueModelPaths; - std::set mUniqueTexturePaths; + //std::set mUniqueTexturePaths; std::mutex mMtxQueue_ModelLoad; - std::mutex mMtxQueue_TextureLoad; + //std::mutex mMtxQueue_TextureLoad; }; \ No newline at end of file diff --git a/Source/Application/Scene.cpp b/Source/Application/Scene.cpp index d68a1c2a..a13f5712 100644 --- a/Source/Application/Scene.cpp +++ b/Source/Application/Scene.cpp @@ -85,7 +85,7 @@ MaterialID Scene::CreateMaterial(const std::string& UniqueMaterialName) mMaterials[id] = Material(); mLoadedMaterials[UniqueMaterialName] = id; #if LOG_RESOURCE_CREATE - Log::Info("Scene::CreateMaterial(): %s", UniqueMaterialName.c_str()); + Log::Info("Scene::CreateMaterial() ID=%d - %s", id, UniqueMaterialName.c_str()); #endif Material& mat = mMaterials.at(id); @@ -266,6 +266,8 @@ void Scene::StartLoading(const BuiltinMeshArray_t& builtinMeshes, FSceneRepresen // scene-specific load this->LoadScene(scene); + AssetLoader::LoadTaskID taskID = AssetLoader::GenerateLoadTaskID(); + // Create scene materials before deserializing gameobjects for (const FMaterialRepresentation& matRep : scene.Materials) { @@ -281,7 +283,7 @@ void Scene::StartLoading(const BuiltinMeshArray_t& builtinMeshes, FSceneRepresen p.MatID = matID; p.TexturePath = path; p.TexType = type; - mAssetLoader.QueueTextureLoad(p); + mAssetLoader.QueueTextureLoad(taskID, p); }; // immediate values @@ -306,7 +308,7 @@ void Scene::StartLoading(const BuiltinMeshArray_t& builtinMeshes, FSceneRepresen } Log::Info("[Scene] Materials Created"); - mMaterialAssignments.mTextureLoadResults = mAssetLoader.StartLoadingTextures(); + mMaterialAssignments.mTextureLoadResults = mAssetLoader.StartLoadingTextures(taskID); // start loading material textures Log::Info("[Scene] Start loading textures..."); diff --git a/Source/Renderer/Renderer_Resources.cpp b/Source/Renderer/Renderer_Resources.cpp index 7d0c943a..5f60ca7a 100644 --- a/Source/Renderer/Renderer_Resources.cpp +++ b/Source/Renderer/Renderer_Resources.cpp @@ -129,7 +129,8 @@ TextureID VQRenderer::CreateTextureFromFile(const char* pFilePath) this->QueueTextureUpload(FTextureUploadDesc(std::move(image), ID, tDesc)); this->StartTextureUploads(); - while (!mTextures.at(ID).bResident); // busy wait here until the texture is made resident; + std::atomic& bResident = mTextures.at(ID).bResident; + while (!bResident.load()); // busy wait here until the texture is made resident; #if LOG_RESOURCE_CREATE Log::Info("VQRenderer::CreateTextureFromFile(): [%.2fs] %s", t.StopGetDeltaTimeAndReset(), pFilePath); @@ -159,7 +160,7 @@ TextureID VQRenderer::CreateTexture(const std::string& name, const D3D12_RESOURC this->StartTextureUploads(); std::atomic& bResident = mTextures.at(ID).bResident; - while (!bResident); // busy wait here until the texture is made resident; + while (!bResident.load()); // busy wait here until the texture is made resident; } if (pData) From 92e6cc7a858948ac91bc8c8a50f6d63b737787e4 Mon Sep 17 00:00:00 2001 From: Volkan Date: Wed, 9 Sep 2020 19:05:47 -0700 Subject: [PATCH 46/67] Fix assertion on empty texture load queue --- Source/Application/AssetLoader.cpp | 4 +++- Source/Application/Scene.cpp | 3 ++- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/Source/Application/AssetLoader.cpp b/Source/Application/AssetLoader.cpp index e198d403..6e72d29a 100644 --- a/Source/Application/AssetLoader.cpp +++ b/Source/Application/AssetLoader.cpp @@ -361,7 +361,9 @@ ModelID AssetLoader::ImportModel(Scene* pScene, AssetLoader* pAssetLoader, VQRen Model::Data data = ProcessAssimpNode(pAiScene->mRootNode, pAiScene, modelDirectory, pAssetLoader, pScene, pRenderer, MaterialTextureAssignments, taskID); pRenderer->UploadVertexAndIndexBufferHeaps(); // load VB/IBs - MaterialTextureAssignments.mTextureLoadResults = pAssetLoader->StartLoadingTextures(taskID); + + if(!MaterialTextureAssignments.mAssignments.empty()) + MaterialTextureAssignments.mTextureLoadResults = pAssetLoader->StartLoadingTextures(taskID); // cache the imported model in Scene ModelID mID = pScene->CreateModel(); diff --git a/Source/Application/Scene.cpp b/Source/Application/Scene.cpp index a13f5712..3c18923d 100644 --- a/Source/Application/Scene.cpp +++ b/Source/Application/Scene.cpp @@ -308,7 +308,8 @@ void Scene::StartLoading(const BuiltinMeshArray_t& builtinMeshes, FSceneRepresen } Log::Info("[Scene] Materials Created"); - mMaterialAssignments.mTextureLoadResults = mAssetLoader.StartLoadingTextures(taskID); + if(!mMaterialAssignments.mAssignments.empty()) + mMaterialAssignments.mTextureLoadResults = mAssetLoader.StartLoadingTextures(taskID); // start loading material textures Log::Info("[Scene] Start loading textures..."); From fe74298bb3db526927f8ebb6980381bbdfedb4e9 Mon Sep 17 00:00:00 2001 From: Volkan Date: Wed, 9 Sep 2020 19:54:57 -0700 Subject: [PATCH 47/67] Fix crash/assert on model not found --- Source/Application/Scene.cpp | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/Source/Application/Scene.cpp b/Source/Application/Scene.cpp index 3c18923d..a07edaa9 100644 --- a/Source/Application/Scene.cpp +++ b/Source/Application/Scene.cpp @@ -173,6 +173,14 @@ void Scene::PostUpdate(int FRAME_DATA_INDEX, int FRAME_DATA_NEXT_INDEX) for (const GameObject* pObj : mpObjects) { const XMMATRIX matWorldTransform = mpTransforms.at(pObj->mTransformID)->WorldTransformationMatrix(); + + const bool bModelNotFound = mModels.find(pObj->mModelID) == mModels.end(); + if (bModelNotFound) + { + Log::Warning("[Scene] Model not found: ID=%d", pObj->mModelID); + continue; + } + const Model& model = mModels.at(pObj->mModelID); assert(pObj->mModelID != INVALID_ID); From 995534ae417aec7adf0ba5bf5357b267f909be48 Mon Sep 17 00:00:00 2001 From: Volkan Date: Wed, 9 Sep 2020 21:11:19 -0700 Subject: [PATCH 48/67] Add khronos gltf samples to readme --- README.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 57e2e39e..9681a032 100644 --- a/README.md +++ b/README.md @@ -129,4 +129,5 @@ VQE supports the following command line parameters: - [stb](https://github.com/nothings/stb) - [tinyxml2](https://github.com/leethomason/tinyxml2) - [assimp](https://github.com/assimp/assimp) -- [WinPixEventRuntime](https://devblogs.microsoft.com/pix/winpixeventruntime/) \ No newline at end of file +- [WinPixEventRuntime](https://devblogs.microsoft.com/pix/winpixeventruntime/) +- [Khronos glTF Sample Models](https://github.com/KhronosGroup/glTF-Sample-Models) \ No newline at end of file From acc4bc1d3ba17f23bdb454c6946860d8860f31d8 Mon Sep 17 00:00:00 2001 From: Volkan Date: Wed, 9 Sep 2020 21:22:06 -0700 Subject: [PATCH 49/67] Code cleanup, scene adjustments, SRV heap and VB/IB heap sizes are at least 2x larger --- Source/Application/AssetLoader.h | 36 +- Source/Renderer/Renderer.cpp | 4 +- Source/Renderer/Shader.cpp | 900 ++++++++++++++++++++++++++++++ Source/Renderer/Shader.h | 289 ++++++++++ Source/Scenes/StressTestScene.cpp | 2 +- 5 files changed, 1206 insertions(+), 25 deletions(-) create mode 100644 Source/Renderer/Shader.cpp create mode 100644 Source/Renderer/Shader.h diff --git a/Source/Application/AssetLoader.h b/Source/Application/AssetLoader.h index 63947ae2..6b5a4025 100644 --- a/Source/Application/AssetLoader.h +++ b/Source/Application/AssetLoader.h @@ -81,22 +81,18 @@ class AssetLoader struct FMaterialTextureAssignments { FMaterialTextureAssignments(const ThreadPool& workers) : mWorkers(workers) {} - - std::vector mAssignments; - TextureLoadResults_t mTextureLoadResults; - const ThreadPool& mWorkers; // to check if pool IsExiting() - void DoAssignments(Scene* pScene, VQRenderer* pRenderer); void WaitForTextureLoads(); + + const ThreadPool& mWorkers; // to check if pool IsExiting() + std::vector mAssignments; + TextureLoadResults_t mTextureLoadResults; }; public: using LoadTaskID = int; static LoadTaskID GenerateLoadTaskID(); - AssetLoader(ThreadPool& WorkerThreads, VQRenderer& renderer) - : mWorkers(WorkerThreads) - , mRenderer(renderer) - {} + AssetLoader(ThreadPool& WorkerThreads, VQRenderer& renderer): mWorkers(WorkerThreads), mRenderer(renderer){} inline const ThreadPool& GetThreadPool() const { return mWorkers; } void QueueModelLoad(GameObject* pObject, const std::string& ModelPath, const std::string& ModelName); @@ -109,26 +105,22 @@ class AssetLoader static ModelID ImportModel(Scene* pScene, AssetLoader* pAssetLoader, VQRenderer* pRenderer, const std::string& objFilePath, std::string ModelName = "NONE"); private: - std::unordered_map mLoadedModels; - - // MT Model loading + ThreadPool& mWorkers; VQRenderer& mRenderer; - template - struct FLoadTaskContext + template struct FLoadTaskContext { - std::mutex Mtx; - std::queue LoadQueue; + std::mutex Mtx; + std::queue LoadQueue; std::set UniquePaths; }; std::unordered_map> mLookup_TextureLoadContext; // TODO: use ConcurrentQueue with ProcessElements(pfnProcess); - std::queue mModelLoadQueue; - //std::queue mTextureLoadQueue; - std::set mUniqueModelPaths; - //std::set mUniqueTexturePaths; - std::mutex mMtxQueue_ModelLoad; - //std::mutex mMtxQueue_TextureLoad; + std::queue mModelLoadQueue; + std::set mUniqueModelPaths; + std::mutex mMtxQueue_ModelLoad; + + std::unordered_map mLoadedModels; }; \ No newline at end of file diff --git a/Source/Renderer/Renderer.cpp b/Source/Renderer/Renderer.cpp index bb490910..426ea656 100644 --- a/Source/Renderer/Renderer.cpp +++ b/Source/Renderer/Renderer.cpp @@ -369,7 +369,7 @@ void VQRenderer::InitializeHeaps() mHeapUpload.Create(pDevice, UPLOAD_HEAP_SIZE, this->mGFXQueue.pQueue); constexpr uint32 NumDescsCBV = 10; - constexpr uint32 NumDescsSRV = 300; + constexpr uint32 NumDescsSRV = 1000; constexpr uint32 NumDescsUAV = 10; constexpr bool bCPUVisible = false; mHeapCBV_SRV_UAV.Create(pDevice, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV, NumDescsCBV + NumDescsSRV + NumDescsUAV, bCPUVisible); @@ -380,7 +380,7 @@ void VQRenderer::InitializeHeaps() constexpr uint32 NumDescsRTV = 10; mHeapRTV.Create(pDevice, D3D12_DESCRIPTOR_HEAP_TYPE_RTV, NumDescsRTV); - constexpr uint32 STATIC_GEOMETRY_MEMORY_SIZE = 16 * MEGABYTE; + constexpr uint32 STATIC_GEOMETRY_MEMORY_SIZE = 32 * MEGABYTE; constexpr bool USE_GPU_MEMORY = true; mStaticHeap_VertexBuffer.Create(pDevice, EBufferType::VERTEX_BUFFER, STATIC_GEOMETRY_MEMORY_SIZE, USE_GPU_MEMORY, "VQRenderer::mStaticVertexBufferPool"); mStaticHeap_IndexBuffer .Create(pDevice, EBufferType::INDEX_BUFFER , STATIC_GEOMETRY_MEMORY_SIZE, USE_GPU_MEMORY, "VQRenderer::mStaticIndexBufferPool"); diff --git a/Source/Renderer/Shader.cpp b/Source/Renderer/Shader.cpp new file mode 100644 index 00000000..f1e9ccd6 --- /dev/null +++ b/Source/Renderer/Shader.cpp @@ -0,0 +1,900 @@ +// VQEngine | DirectX11 Renderer +// Copyright(C) 2018 - Volkan Ilbeyli +// +// This program is free software : you can redistribute it and / or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program.If not, see . +// +// Contact: volkanilbeyli@gmail.com + +#include "Shader.h" +#include "Renderer.h" + +#if 0 +#include "Utilities/Log.h" +#include "Utilities/utils.h" +#include "Utilities/PerfTimer.h" +#include "Application/Application.h" + +#include +#include +#include +#include + +//------------------------------------------------------------------------------------------------------------- +// CONSTANTS & STATICS +//------------------------------------------------------------------------------------------------------------- +static const std::unordered_map SHADER_COMPILER_VERSION_LOOKUP = +{ + { EShaderStage::VS, "vs_5_0" }, + { EShaderStage::GS, "gs_5_0" }, + { EShaderStage::DS, "ds_5_0" }, + { EShaderStage::HS, "hs_5_0" }, + { EShaderStage::PS, "ps_5_0" }, + { EShaderStage::CS, "cs_5_0" }, +}; +static const std::unordered_map SHADER_ENTRY_POINT_LOOKUP = +{ + { EShaderStage::VS, "VSMain" }, + { EShaderStage::GS, "GSMain" }, + { EShaderStage::DS, "DSMain" }, + { EShaderStage::HS, "HSMain" }, + { EShaderStage::PS, "PSMain" }, + { EShaderStage::CS, "CSMain" }, +}; + +ID3DInclude* const SHADER_INCLUDE_HANDLER = D3D_COMPILE_STANDARD_FILE_INCLUDE; // use default include handler for using #include in shader files + +#if defined( _DEBUG ) || defined ( FORCE_DEBUG ) +const UINT SHADER_COMPILE_FLAGS = D3DCOMPILE_ENABLE_STRICTNESS | D3DCOMPILE_DEBUG | D3DCOMPILE_SKIP_OPTIMIZATION; +#else +const UINT SHADER_COMPILE_FLAGS = D3DCOMPILE_ENABLE_STRICTNESS; +#endif + + + +#ifdef _WIN64 +#define CALLING_CONVENTION __cdecl +#else // _WIN32 +#define CALLING_CONVENTION __stdcall +#endif + +static void(CALLING_CONVENTION ID3D11DeviceContext:: *SetShaderConstants[EShaderStage::COUNT]) +(UINT StartSlot, UINT NumBuffers, ID3D11Buffer *const *ppConstantBuffers) = +{ + &ID3D11DeviceContext::VSSetConstantBuffers, + &ID3D11DeviceContext::GSSetConstantBuffers, + &ID3D11DeviceContext::DSSetConstantBuffers, + &ID3D11DeviceContext::HSSetConstantBuffers, + &ID3D11DeviceContext::PSSetConstantBuffers, + &ID3D11DeviceContext::CSSetConstantBuffers, +}; + +static std::unordered_map s_ShaderTypeStrLookup = +{ + {"vs", EShaderStage::VS}, + {"gs", EShaderStage::GS}, + {"ds", EShaderStage::DS}, + {"hs", EShaderStage::HS}, + {"cs", EShaderStage::CS}, + {"ps", EShaderStage::PS} +}; + + +//------------------------------------------------------------------------------------------------------------- +// STATIC FUNCTIONS +//------------------------------------------------------------------------------------------------------------- +std::string GetCompileError(ID3D10Blob*& errorMessage, const std::string& shdPath) +{ + if (errorMessage) + { + char* compileErrors = (char*)errorMessage->GetBufferPointer(); + size_t bufferSize = errorMessage->GetBufferSize(); + + std::stringstream ss; + for (unsigned int i = 0; i < bufferSize; ++i) + { + ss << compileErrors[i]; + } + errorMessage->Release(); + return ss.str(); + } + else + { + Log::Error(shdPath); + return ("Error: " + shdPath); + } +} + +static std::string GetIncludeFileName(const std::string& line) +{ + const std::string str_search = "#include \""; + const size_t foundPos = line.find(str_search); + if (foundPos != std::string::npos) + { + std::string quotedFileName = line.substr(foundPos + strlen("#include "), line.size() - foundPos);// +str_search.size() - 1); + return quotedFileName.substr(1, quotedFileName.size() - 2); + } + return std::string(); +} + +static bool AreIncludesDirty(const std::string& srcPath, const std::string& cachePath) +{ + + const std::string ShaderSourceDir = DirectoryUtil::GetFolderPath(srcPath); + const std::string ShaderCacheDir = DirectoryUtil::GetFolderPath(cachePath); + + std::stack includeStack; + includeStack.push(srcPath); + while (!includeStack.empty()) + { + const std::string includeFilePath = includeStack.top(); + includeStack.pop(); + std::ifstream src = std::ifstream(includeFilePath.c_str()); + if (!src.good()) + { + Log::Error("[ShaderCompile] Cannot open source file: %s", includeFilePath.c_str()); + continue; + } + + std::string line; + while (getline(src, line)) + { + const std::string includeFileName = GetIncludeFileName(line); + if (includeFileName.empty()) continue; + + const std::string includeSourcePath = ShaderSourceDir + includeFileName; + const std::string includeCachePath = ShaderCacheDir + includeFileName; + + if (DirectoryUtil::IsFileNewer(includeSourcePath, cachePath)) + return true; + includeStack.push(includeSourcePath); + } + src.close(); + } + return false; +} + +bool IsCacheDirty(const std::string& sourcePath, const std::string& cachePath) +{ + if (!DirectoryUtil::FileExists(cachePath)) return true; + + return DirectoryUtil::IsFileNewer(sourcePath, cachePath) || AreIncludesDirty(sourcePath, cachePath); +} + + +bool Shader::CompileFromSource(const std::string& pathToFile, const EShaderStage& type, ID3D10Blob *& ref_pBob, std::string& errMsg, const std::vector& macros) +{ + const StrUtil::UnicodeString Path = pathToFile; + const WCHAR* PathStr = Path.GetUnicodePtr(); + ID3D10Blob* errorMessage = nullptr; + + int i = 0; + std::vector d3dMacros(macros.size() + 1); + std::for_each(RANGE(macros), [&](const ShaderMacro& macro) + { + d3dMacros[i++] = D3D10_SHADER_MACRO({ macro.name.c_str(), macro.value.c_str() }); + }); + d3dMacros[i] = { NULL, NULL }; + + if (FAILED(D3DCompileFromFile( + PathStr, + d3dMacros.data(), + SHADER_INCLUDE_HANDLER, + SHADER_ENTRY_POINT_LOOKUP.at(type), + SHADER_COMPILER_VERSION_LOOKUP.at(type), + SHADER_COMPILE_FLAGS, + 0, + &ref_pBob, + &errorMessage))) + { + + errMsg = GetCompileError(errorMessage, pathToFile); + return false; + } + return true; +} + +ID3D10Blob * Shader::CompileFromCachedBinary(const std::string & cachedBinaryFilePath) +{ + std::ifstream cache(cachedBinaryFilePath, std::ios::in | std::ios::binary | std::ios::ate); + const size_t shaderBinarySize = cache.tellg(); + void* pBuffer = calloc(1, shaderBinarySize); + cache.seekg(0); + cache.read(reinterpret_cast(pBuffer), shaderBinarySize); + cache.close(); + + ID3D10Blob* pBlob = { nullptr }; + D3DCreateBlob(shaderBinarySize, &pBlob); + memcpy(pBlob->GetBufferPointer(), pBuffer, shaderBinarySize); + free(pBuffer); + + return pBlob; +} + +void Shader::CacheShaderBinary(const std::string& shaderCacheFileName, ID3D10Blob * pCompiledBinary) +{ + const size_t shaderBinarySize = pCompiledBinary->GetBufferSize(); + + char* pBuffer = reinterpret_cast(pCompiledBinary->GetBufferPointer()); + std::ofstream cache(shaderCacheFileName, std::ios::out | std::ios::binary); + cache.write(pBuffer, shaderBinarySize); + cache.close(); +} + +EShaderStage Shader::GetShaderTypeFromSourceFilePath(const std::string & shaderFilePath) +{ + const std::string sourceFileName = DirectoryUtil::GetFileNameWithoutExtension(shaderFilePath); + const std::string shaderTypeStr = { *(sourceFileName.rbegin() + 1), *sourceFileName.rbegin() }; + return s_ShaderTypeStrLookup.at(shaderTypeStr); +} + + +//------------------------------------------------------------------------------------------------------------- +// PUBLIC INTERFACE +//------------------------------------------------------------------------------------------------------------- +const std::vector& Shader::GetConstantBufferLayouts() const { return m_CBLayouts; } +const std::vector& Shader::GetConstantBuffers() const { return mConstantBuffers; } +const TextureBinding& Shader::GetTextureBinding(const std::string& textureName) const { return mTextureBindings[mShaderTextureLookup.at(textureName)]; } +const SamplerBinding& Shader::GetSamplerBinding(const std::string& samplerName) const { return mSamplerBindings[mShaderSamplerLookup.at(samplerName)]; } +bool Shader::HasTextureBinding(const std::string& textureName) const { return mShaderTextureLookup.find(textureName) != mShaderTextureLookup.end(); } +bool Shader::HasSamplerBinding(const std::string& samplerName) const { return mShaderSamplerLookup.find(samplerName) != mShaderSamplerLookup.end(); } + +Shader::Shader(const std::string& shaderFileName) + : mName(shaderFileName) + , mID(-1) +{} + +Shader::Shader(const ShaderDesc& desc) + : mName(desc.shaderName) + , mDescriptor(desc) + , mID(-1) +{} + +Shader::~Shader(void) +{ +#if _DEBUG + //Log::Info("Shader dtor: %s", m_name.c_str()); +#endif + + // todo: this really could use smart pointers... + + // release constants + ReleaseResources(); +} +void Shader::ReleaseResources() +{ + for (ConstantBufferBinding& cbuf : mConstantBuffers) + { + if (cbuf.data) + { + cbuf.data->Release(); + cbuf.data = nullptr; + } + } + mConstantBuffers.clear(); + + for (CPUConstant cbuf : mCPUConstantBuffers) + { + if (cbuf._data) + { + delete cbuf._data; + cbuf._data = nullptr; + } + } + mCPUConstantBuffers.clear(); + + + if (mpInputLayout) + { + mpInputLayout->Release(); + mpInputLayout = nullptr; + } + + if (mStages.mPixelShader) + { + mStages.mPixelShader->Release(); + mStages.mPixelShader = nullptr; + } + + if (mStages.mVertexShader) + { + mStages.mVertexShader->Release(); + mStages.mVertexShader = nullptr; + } + + if (mStages.mComputeShader) + { + mStages.mComputeShader->Release(); + mStages.mComputeShader = nullptr; + } + + if (mStages.mGeometryShader) + { + mStages.mGeometryShader->Release(); + mStages.mGeometryShader = nullptr; + } + + for (unsigned type = EShaderStage::VS; type < EShaderStage::COUNT; ++type) + { + if (mReflections.of[type]) + { + mReflections.of[type]->Release(); + mReflections.of[type] = nullptr; + } + } + + m_CBLayouts.clear(); + m_constants.clear(); + mTextureBindings.clear(); + mSamplerBindings.clear(); + mShaderTextureLookup.clear(); + mShaderSamplerLookup.clear(); +} + + + + +size_t Shader::GeneratePreprocessorDefinitionsHash(const std::vector& macros) const +{ + if (macros.empty()) return 0; + std::string concatenatedMacros; + for (const ShaderMacro& macro : macros) + concatenatedMacros += macro.name + macro.value; + return std::hash()(concatenatedMacros); +} + +bool Shader::Reload(ID3D11Device* device) +{ + Shader copy(this->mDescriptor); + copy.mID = this->mID; + ReleaseResources(); + this->mID = copy.mID; + return CompileShaders(device, copy.mDescriptor); +} + +bool Shader::HasSourceFileBeenUpdated() const +{ + bool bUpdated = false; + for (EShaderStage stage = EShaderStage::VS; stage < EShaderStage::COUNT; stage = (EShaderStage)(stage + 1)) + { + if (mDirectories.find(stage) != mDirectories.end()) + { + const std::string& path = mDirectories.at(stage).fullPath; + const std::string& cachePath = mDirectories.at(stage).cachePath; + bUpdated |= mDirectories.at(stage).lastWriteTime < std::experimental::filesystem::last_write_time(path); + + if (!bUpdated) // check include files only when source is not updated + { + bUpdated |= AreIncludesDirty(path, cachePath); + } + } + } + return bUpdated; +} + +void Shader::ClearConstantBuffers() +{ + for (ConstantBufferBinding& cBuffer : mConstantBuffers) + { + cBuffer.dirty = true; + } +} + +void Shader::UpdateConstants(ID3D11DeviceContext* context) +{ + for (unsigned i = 0; i < mConstantBuffers.size(); ++i) + { + ConstantBufferBinding& CB = mConstantBuffers[i]; + if (CB.dirty) // if the CPU-side buffer is updated + { + ID3D11Buffer* data = CB.data; + D3D11_MAPPED_SUBRESOURCE mappedResource; + + // Map sub-resource to GPU - update contents - discard the sub-resource + context->Map(data, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); + char* bufferPos = static_cast(mappedResource.pData); // char* so we can advance the pointer + for (const ConstantBufferMapping& indexIDPair : m_constants) + { + if (indexIDPair.first != i) + { + continue; + } + + const int slotIndex = indexIDPair.first; + const CPUConstantID c_id = indexIDPair.second; + assert(c_id < mCPUConstantBuffers.size()); + CPUConstant& c = mCPUConstantBuffers[c_id]; + memcpy(bufferPos, c._data, c._size); + bufferPos += c._size; + } + context->Unmap(data, 0); + + // TODO: research update sub-resource (Setting constant buffer can be done once in setting the shader) + + // call XSSetConstantBuffers() from array using ShaderType enum + (context->*SetShaderConstants[CB.shaderStage])(CB.bufferSlot, 1, &data); + CB.dirty = false; + } + } +} + + + + +//------------------------------------------------------------------------------------------------------------- +// UTILITY FUNCTIONS +//------------------------------------------------------------------------------------------------------------- +bool Shader::CompileShaders(ID3D11Device* device, const ShaderDesc& desc) +{ + constexpr const char * SHADER_BINARY_EXTENSION = ".bin"; + mDescriptor = desc; + HRESULT result; + ShaderBlobs blobs; + bool bPrinted = false; + + PerfTimer timer; + timer.Start(); + + // COMPILE SHADER STAGES + //---------------------------------------------------------------------------- + for (const ShaderStageDesc& stageDesc : desc.stages) + { + if (stageDesc.fileName.empty()) + continue; + + // stage.macros + const std::string sourceFilePath = std::string(Renderer::sShaderRoot + stageDesc.fileName); + + const EShaderStage stage = GetShaderTypeFromSourceFilePath(sourceFilePath); + + // USE SHADER CACHE + // + const size_t ShaderHash = GeneratePreprocessorDefinitionsHash(stageDesc.macros); + const std::string cacheFileName = stageDesc.macros.empty() + ? DirectoryUtil::GetFileNameFromPath(sourceFilePath) + SHADER_BINARY_EXTENSION + : DirectoryUtil::GetFileNameFromPath(sourceFilePath) + "_" + std::to_string(ShaderHash) + SHADER_BINARY_EXTENSION; + const std::string cacheFilePath = Application::s_ShaderCacheDirectory + "\\" + cacheFileName; + const bool bUseCachedShaders = + DirectoryUtil::FileExists(cacheFilePath) + && !IsCacheDirty(sourceFilePath, cacheFilePath); + //--------------------------------------------------------------------------------- + if (!bPrinted) // quick status print here + { + const char* pMsgLoad = bUseCachedShaders ? "Loading cached shader binaries" : "Compiling shader from source"; + Log::Info("\t%s %s...", pMsgLoad, mName.c_str()); + bPrinted = true; + } + //--------------------------------------------------------------------------------- + if (bUseCachedShaders) + { + blobs.of[stage] = CompileFromCachedBinary(cacheFilePath); + } + else + { + std::string errMsg; + ID3D10Blob* pBlob; + if (CompileFromSource(sourceFilePath, stage, pBlob, errMsg, stageDesc.macros)) + { + blobs.of[stage] = pBlob; + CacheShaderBinary(cacheFilePath, blobs.of[stage]); + } + else + { + Log::Error(errMsg); + return false; + } + } + + CreateShaderStage(device, stage, blobs.of[stage]->GetBufferPointer(), blobs.of[stage]->GetBufferSize()); + SetReflections(blobs); + //CheckSignatures(); + + mDirectories[stage] = ShaderLoadDesc(sourceFilePath, cacheFilePath); + } + + // INPUT LAYOUT (VS) + //--------------------------------------------------------------------------- + // src: https://stackoverflow.com/questions/42388979/directx-11-vertex-shader-reflection + // setup the layout of the data that goes into the shader + // + if(mReflections.vsRefl) + { + + D3D11_SHADER_DESC shaderDesc = {}; + mReflections.vsRefl->GetDesc(&shaderDesc); + std::vector inputLayout(shaderDesc.InputParameters); + + D3D_PRIMITIVE primitiveDesc = shaderDesc.InputPrimitive; + + for (unsigned i = 0; i < shaderDesc.InputParameters; ++i) + { + D3D11_SIGNATURE_PARAMETER_DESC paramDesc; + mReflections.vsRefl->GetInputParameterDesc(i, ¶mDesc); + + // fill out input element desc + D3D11_INPUT_ELEMENT_DESC elementDesc; + elementDesc.SemanticName = paramDesc.SemanticName; + elementDesc.SemanticIndex = paramDesc.SemanticIndex; + elementDesc.InputSlot = 0; + elementDesc.AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT; + elementDesc.InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA; + elementDesc.InstanceDataStepRate = 0; + + // determine DXGI format + if (paramDesc.Mask == 1) + { + if (paramDesc.ComponentType == D3D_REGISTER_COMPONENT_UINT32) elementDesc.Format = DXGI_FORMAT_R32_UINT; + else if (paramDesc.ComponentType == D3D_REGISTER_COMPONENT_SINT32) elementDesc.Format = DXGI_FORMAT_R32_SINT; + else if (paramDesc.ComponentType == D3D_REGISTER_COMPONENT_FLOAT32) elementDesc.Format = DXGI_FORMAT_R32_FLOAT; + } + else if (paramDesc.Mask <= 3) + { + if (paramDesc.ComponentType == D3D_REGISTER_COMPONENT_UINT32) elementDesc.Format = DXGI_FORMAT_R32G32_UINT; + else if (paramDesc.ComponentType == D3D_REGISTER_COMPONENT_SINT32) elementDesc.Format = DXGI_FORMAT_R32G32_SINT; + else if (paramDesc.ComponentType == D3D_REGISTER_COMPONENT_FLOAT32) elementDesc.Format = DXGI_FORMAT_R32G32_FLOAT; + } + else if (paramDesc.Mask <= 7) + { + if (paramDesc.ComponentType == D3D_REGISTER_COMPONENT_UINT32) elementDesc.Format = DXGI_FORMAT_R32G32B32_UINT; + else if (paramDesc.ComponentType == D3D_REGISTER_COMPONENT_SINT32) elementDesc.Format = DXGI_FORMAT_R32G32B32_SINT; + else if (paramDesc.ComponentType == D3D_REGISTER_COMPONENT_FLOAT32) elementDesc.Format = DXGI_FORMAT_R32G32B32_FLOAT; + } + else if (paramDesc.Mask <= 15) + { + if (paramDesc.ComponentType == D3D_REGISTER_COMPONENT_UINT32) elementDesc.Format = DXGI_FORMAT_R32G32B32A32_UINT; + else if (paramDesc.ComponentType == D3D_REGISTER_COMPONENT_SINT32) elementDesc.Format = DXGI_FORMAT_R32G32B32A32_SINT; + else if (paramDesc.ComponentType == D3D_REGISTER_COMPONENT_FLOAT32) elementDesc.Format = DXGI_FORMAT_R32G32B32A32_FLOAT; + } + + inputLayout[i] = elementDesc; //save element desc + } + + // Try to create Input Layout + const auto* pData = inputLayout.data(); + if (pData) + { + result = device->CreateInputLayout( + pData, + shaderDesc.InputParameters, + blobs.vs->GetBufferPointer(), + blobs.vs->GetBufferSize(), + &mpInputLayout); + + if (FAILED(result)) + { + OutputDebugString("Error creating input layout"); + return false; + } + } + } + + // CONSTANT BUFFERS + //--------------------------------------------------------------------------- + // Obtain cbuffer layout information + for (EShaderStage type = EShaderStage::VS; type < EShaderStage::COUNT; type = (EShaderStage)(type + 1)) + { + if (mReflections.of[type]) + { + ReflectConstantBufferLayouts(mReflections.of[type], type); + } + } + + // Create CPU & GPU constant buffers + // CPU CBuffers + int constantBufferSlot = 0; + for (const ConstantBufferLayout& cbLayout : m_CBLayouts) + { + std::vector cpuBuffers; + for (D3D11_SHADER_VARIABLE_DESC varDesc : cbLayout.variables) + { + CPUConstant c; + CPUConstantID c_id = static_cast(mCPUConstantBuffers.size()); + + c._name = varDesc.Name; + c._size = varDesc.Size; + c._data = new char[c._size]; + memset(c._data, 0, c._size); + m_constants.push_back(std::make_pair(constantBufferSlot, c_id)); + mCPUConstantBuffers.push_back(c); + } + ++constantBufferSlot; + } + + // GPU CBuffers + D3D11_BUFFER_DESC cBufferDesc; + cBufferDesc.Usage = D3D11_USAGE_DYNAMIC; + cBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; + cBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; + cBufferDesc.MiscFlags = 0; + cBufferDesc.StructureByteStride = 0; + for (const ConstantBufferLayout& cbLayout : m_CBLayouts) + { + ConstantBufferBinding cBuffer; + cBufferDesc.ByteWidth = cbLayout.desc.Size; + if (FAILED(device->CreateBuffer(&cBufferDesc, NULL, &cBuffer.data))) + { + OutputDebugString("Error creating constant buffer"); + return false; + } + cBuffer.dirty = true; + cBuffer.shaderStage = cbLayout.stage; + cBuffer.bufferSlot = cbLayout.bufSlot; + mConstantBuffers.push_back(cBuffer); + } + + + // TEXTURES & SAMPLERS + //--------------------------------------------------------------------------- + for (int shaderStage = 0; shaderStage < EShaderStage::COUNT; ++shaderStage) + { + unsigned texSlot = 0; unsigned smpSlot = 0; + unsigned uavSlot = 0; + auto& sRefl = mReflections.of[shaderStage]; + if (sRefl) + { + D3D11_SHADER_DESC desc = {}; + sRefl->GetDesc(&desc); + + for (unsigned i = 0; i < desc.BoundResources; ++i) + { + D3D11_SHADER_INPUT_BIND_DESC shdInpDesc; + sRefl->GetResourceBindingDesc(i, &shdInpDesc); + + switch (shdInpDesc.Type) + { + case D3D_SIT_SAMPLER: + { + SamplerBinding smp; + smp.shaderStage = static_cast(shaderStage); + smp.samplerSlot = smpSlot++; + mSamplerBindings.push_back(smp); + mShaderSamplerLookup[shdInpDesc.Name] = static_cast(mSamplerBindings.size() - 1); + } break; + + case D3D_SIT_TEXTURE: + { + TextureBinding tex; + tex.shaderStage = static_cast(shaderStage); + tex.textureSlot = texSlot++; + mTextureBindings.push_back(tex); + mShaderTextureLookup[shdInpDesc.Name] = static_cast(mTextureBindings.size() - 1); + } break; + + case D3D_SIT_UAV_RWTYPED: + { + TextureBinding tex; + tex.shaderStage = static_cast(shaderStage); + tex.textureSlot = uavSlot++; + mTextureBindings.push_back(tex); + mShaderTextureLookup[shdInpDesc.Name] = static_cast(mTextureBindings.size() - 1); + } break; + + case D3D_SIT_CBUFFER: break; + + + default: + Log::Warning("Unhandled shader input bind type in shader reflection"); + break; + + } // switch shader input type + } // bound resource + } // sRefl + } // shaderStage + + // release blobs + for (unsigned type = EShaderStage::VS; type < EShaderStage::COUNT; ++type) + { + if (blobs.of[type]) + blobs.of[type]->Release(); + } + + return true; +} + +void Shader::CreateShaderStage(ID3D11Device* pDevice, EShaderStage stage, void* pBuffer, const size_t szShaderBinary) +{ + HRESULT result = {}; + const char* msg = ""; + switch (stage) + { + case EShaderStage::VS: + if (FAILED(pDevice->CreateVertexShader(pBuffer, szShaderBinary, NULL, &mStages.mVertexShader))) + { + msg = "Error creating vertex shader program"; + } + break; + case EShaderStage::PS: + if (FAILED(pDevice->CreatePixelShader(pBuffer, szShaderBinary, NULL, &mStages.mPixelShader))) + { + msg = "Error creating pixel shader program"; + } + break; + case EShaderStage::GS: + if (FAILED(pDevice->CreateGeometryShader(pBuffer, szShaderBinary, NULL, &mStages.mGeometryShader))) + { + msg = "Error creating pixel geometry program"; + } + break; + case EShaderStage::CS: + if (FAILED(pDevice->CreateComputeShader(pBuffer, szShaderBinary, NULL, &mStages.mComputeShader))) + { + msg = "Error creating compute shader program"; + } + break; + } + + if (FAILED(result)) + { + OutputDebugString(msg); + assert(false); + } +} + +void Shader::SetReflections(const ShaderBlobs& blobs) +{ + for(unsigned type = EShaderStage::VS; type < EShaderStage::COUNT; ++type) + { + if (blobs.of[type]) + { + void** ppBuffer = reinterpret_cast(&this->mReflections.of[type]); + if (FAILED(D3DReflect(blobs.of[type]->GetBufferPointer(), blobs.of[type]->GetBufferSize(), IID_ID3D11ShaderReflection, ppBuffer))) + { + Log::Error("Cannot get vertex shader reflection"); + assert(false); + } + } + } +} + +void Shader::CheckSignatures() +{ +#if 0 + // get shader description --> input/output parameters + std::vector VSISignDescs, VSOSignDescs, PSISignDescs, PSOSignDescs; + D3D11_SHADER_DESC VSDesc; + m_vsRefl->GetDesc(&VSDesc); + for (unsigned i = 0; i < VSDesc.InputParameters; ++i) + { + D3D11_SIGNATURE_PARAMETER_DESC input_desc; + m_vsRefl->GetInputParameterDesc(i, &input_desc); + VSISignDescs.push_back(input_desc); + } + + for (unsigned i = 0; i < VSDesc.OutputParameters; ++i) + { + D3D11_SIGNATURE_PARAMETER_DESC output_desc; + m_vsRefl->GetInputParameterDesc(i, &output_desc); + VSOSignDescs.push_back(output_desc); + } + + + D3D11_SHADER_DESC PSDesc; + m_psRefl->GetDesc(&PSDesc); + for (unsigned i = 0; i < PSDesc.InputParameters; ++i) + { + D3D11_SIGNATURE_PARAMETER_DESC input_desc; + m_psRefl->GetInputParameterDesc(i, &input_desc); + PSISignDescs.push_back(input_desc); + } + + for (unsigned i = 0; i < PSDesc.OutputParameters; ++i) + { + D3D11_SIGNATURE_PARAMETER_DESC output_desc; + m_psRefl->GetInputParameterDesc(i, &output_desc); + PSOSignDescs.push_back(output_desc); + } + + // check VS-PS signature compatibility | wont be necessary when its 1 file. + // THIS IS TEMPORARY + if (VSOSignDescs.size() != PSISignDescs.size()) + { + OutputDebugString("Error: Incompatible shader input/output signatures (sizes don't match)\n"); + assert(false); + } + else + { + for (size_t i = 0; i < VSOSignDescs.size(); ++i) + { + // TODO: order matters, semantic slot doesn't. check order + ; + } + } +#endif + assert(false); // todo: refactor this +} + + +void Shader::LogConstantBufferLayouts() const +{ + char inputTable[2048]; + sprintf_s(inputTable, "\n%s ConstantBuffers: -----\n", this->mName.c_str()); + std::for_each(m_constants.begin(), m_constants.end(), [&](const ConstantBufferMapping& cMapping) { + char entry[32]; + sprintf_s(entry, "(%d, %d)\t- %s\n", cMapping.first, cMapping.second, mCPUConstantBuffers[cMapping.second]._name.c_str()); + strcat_s(inputTable, entry); + }); + strcat_s(inputTable, "-----\n"); + Log::Info(std::string(inputTable)); +} + +void Shader::ReflectConstantBufferLayouts(ID3D11ShaderReflection* sRefl, EShaderStage type) +{ + D3D11_SHADER_DESC desc; + sRefl->GetDesc(&desc); + + unsigned bufSlot = 0; + for (unsigned i = 0; i < desc.ConstantBuffers; ++i) + { + ConstantBufferLayout bufferLayout; + bufferLayout.buffSize = 0; + ID3D11ShaderReflectionConstantBuffer* pCBuffer = sRefl->GetConstantBufferByIndex(i); + pCBuffer->GetDesc(&bufferLayout.desc); + + // load desc of each variable for binding on buffer later on + for (unsigned j = 0; j < bufferLayout.desc.Variables; ++j) + { + // get variable and type descriptions + ID3D11ShaderReflectionVariable* pVariable = pCBuffer->GetVariableByIndex(j); + D3D11_SHADER_VARIABLE_DESC varDesc; + pVariable->GetDesc(&varDesc); + bufferLayout.variables.push_back(varDesc); + + ID3D11ShaderReflectionType* pType = pVariable->GetType(); + D3D11_SHADER_TYPE_DESC typeDesc; + pType->GetDesc(&typeDesc); + bufferLayout.types.push_back(typeDesc); + + // accumulate buffer size + bufferLayout.buffSize += varDesc.Size; + } + bufferLayout.stage = type; + bufferLayout.bufSlot = bufSlot; + ++bufSlot; + m_CBLayouts.push_back(bufferLayout); + } +} + + + +std::array ShaderDesc::CreateStageDescsFromShaderName(const char* pShaderName, unsigned flagStages) +{ + const std::string shaderName = pShaderName; + std::array descs; + int idx = 0; + if (flagStages & SHADER_STAGE_VS) + { + descs[idx++] = ShaderStageDesc{ shaderName + "_vs.hlsl", {} }; + } + if (flagStages & SHADER_STAGE_GS) + { + descs[idx++] = ShaderStageDesc{ shaderName + "_gs.hlsl", {} }; + } + if (flagStages & SHADER_STAGE_DS) + { + descs[idx++] = ShaderStageDesc{ shaderName + "_ds.hlsl", {} }; + } + if (flagStages & SHADER_STAGE_HS) + { + descs[idx++] = ShaderStageDesc{ shaderName + "_hs.hlsl", {} }; + } + if (flagStages & SHADER_STAGE_PS) + { + descs[idx++] = ShaderStageDesc{ shaderName + "_ps.hlsl", {} }; + } + if (flagStages & SHADER_STAGE_CS) + { + descs[idx++] = ShaderStageDesc{ shaderName + "_cs.hlsl", {} }; + } + return descs; +} +#endif \ No newline at end of file diff --git a/Source/Renderer/Shader.h b/Source/Renderer/Shader.h new file mode 100644 index 00000000..20c24d10 --- /dev/null +++ b/Source/Renderer/Shader.h @@ -0,0 +1,289 @@ +// VQEngine | DirectX11 Renderer +// Copyright(C) 2018 - Volkan Ilbeyli +// +// This program is free software : you can redistribute it and / or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program.If not, see . +// +// Contact: volkanilbeyli@gmail.com + +#pragma once + +#include "../Application/Types.h" + +#include + +#include +#include +#include +#include +#include +#include + + +enum EShaderStageFlags : unsigned +{ + SHADER_STAGE_NONE = 0x00000000, + SHADER_STAGE_VS = 0x00000001, + SHADER_STAGE_GS = 0x00000002, + SHADER_STAGE_DS = 0x00000004, + SHADER_STAGE_HS = 0x00000008, + SHADER_STAGE_PS = 0x00000010, + SHADER_STAGE_ALL_GRAPHICS = 0X0000001F, + SHADER_STAGE_CS = 0x00000020, + + SHADER_STAGE_COUNT = 6 +}; +enum EShaderStage : unsigned // array-index enum mapping +{ // used to map **SetShaderConstant(); function in Renderer::Apply() + VS = 0, + GS, + DS, + HS, + PS, + CS, + + NUM_SHADER_STAGES +}; + +#if 0 +enum ELayoutFormat +{ + FLOAT32_2 = DXGI_FORMAT_R32G32_FLOAT, + FLOAT32_3 = DXGI_FORMAT_R32G32B32_FLOAT, + FLOAT32_4 = DXGI_FORMAT_R32G32B32A32_FLOAT, + + LAYOUT_FORMAT_COUNT +}; +using CPUConstantID = int; +using GPU_ConstantBufferSlotIndex = int; +using ConstantBufferMapping = std::pair; +//using FileTimeStamp = std::experimental::filesystem::file_time_type; + +//---------------------------------------------------------------------------------------------------------------- +// SHADER DATA/RESOURCE INTERFACE STRUCTS +//---------------------------------------------------------------------------------------------------------------- +struct ConstantBufferBinding +{ + EShaderStage shaderStage; + unsigned bufferSlot; + //ID3D12Buffer* data; + //bool dirty; +}; +struct TextureBinding +{ + EShaderStage shaderStage; + unsigned textureSlot; +}; +struct SamplerBinding +{ + EShaderStage shaderStage; + unsigned samplerSlot; + std::string name; // TODO: move this out +}; +struct InputLayout +{ + std::string semanticName; + ELayoutFormat format; +}; + + +struct ShaderMacro +{ + std::string name; + std::string value; +}; + +struct ShaderStageDesc +{ + std::string fileName; + std::vector macros; +}; + +struct ShaderDesc +{ + using ShaderStageArr = std::array; + static ShaderStageArr CreateStageDescsFromShaderName(const char* shaderName, unsigned flagStages); + + std::string shaderName; + std::array stages; +}; + +struct ShaderLoadDesc +{ + ShaderLoadDesc() = default; + ShaderLoadDesc(const std::string& path, const std::string& cachePath_); + // : fullPath(path), cachePath(cachePath_) + //{ + // this->lastWriteTime = std::experimental::filesystem::last_write_time(fullPath); + // this->cacheLastWriteTime = std::experimental::filesystem::last_write_time(cachePath); + //} + std::string fullPath; + std::string cachePath; + FileTimeStamp lastWriteTime; + FileTimeStamp cacheLastWriteTime; +}; + + +class Shader +{ + friend class Renderer; + + using ShaderArray = std::array; + using ShaderTextureLookup = std::unordered_map; + using ShaderSamplerLookup = std::unordered_map; + using ShaderDirectoryLookup = std::unordered_map; + +public: + // STRUCTS/ENUMS + // + // Current limitations for Constant Buffers: + // - cbuffers with same names in different shaders (PS/VS/GS/...) + // - cbuffers with same names in the same shader (not tested) + //---------------------------------------------------------------------------------------------------------------- + union ShaderBlobs + { + struct + { + ID3D10Blob* vs; + ID3D10Blob* gs; + ID3D10Blob* ds; + ID3D10Blob* hs; + ID3D10Blob* ps; + ID3D10Blob* cs; + }; + ID3D10Blob* of[EShaderStage::NUM_SHADER_STAGES] = { nullptr }; + }; + union ShaderReflections + { + struct + { + ID3D12ShaderReflection* vsRefl; + ID3D12ShaderReflection* gsRefl; + ID3D12ShaderReflection* dsRefl; + ID3D12ShaderReflection* hsRefl; + ID3D12ShaderReflection* psRefl; + ID3D12ShaderReflection* csRefl; + }; + ID3D12ShaderReflection* of[EShaderStage::NUM_SHADER_STAGES] = { nullptr }; + }; + struct ConstantBufferLayout + { // information used to create GPU/CPU constant buffers + D3D11_SHADER_BUFFER_DESC desc; + std::vector variables; + std::vector types; + unsigned buffSize; + EShaderStage stage; + unsigned bufSlot; + }; + struct ShaderStages + { + ID3D12VertexShader* mVertexShader = nullptr; + ID3D12PixelShader* mPixelShader = nullptr; + ID3D12GeometryShader* mGeometryShader = nullptr; + ID3D12HullShader* mHullShader = nullptr; + ID3D12DomainShader* mDomainShader = nullptr; + ID3D12ComputeShader* mComputeShader = nullptr; + }; + +public: + //---------------------------------------------------------------------------------------------------------------- + // MEMBER INTERFACE + //---------------------------------------------------------------------------------------------------------------- + Shader(const ShaderDesc& desc); + Shader(const std::string& shaderFileName); + ~Shader(); + + bool Reload(ID3D12Device* device); + void ClearConstantBuffers(); + //void UpdateConstants(ID3D12DeviceContext* context); + + //---------------------------------------------------------------------------------------------------------------- + // GETTERS + //---------------------------------------------------------------------------------------------------------------- + const std::string& Name() const { return mName; } + inline ShaderID ID() const { return mID; } + + const std::vector& GetConstantBufferLayouts() const; + const std::vector& GetConstantBuffers() const; + + const TextureBinding& GetTextureBinding(const std::string& textureName) const; + const SamplerBinding& GetSamplerBinding(const std::string& samplerName) const; + bool HasTextureBinding(const std::string& textureName) const; + bool HasSamplerBinding(const std::string& samplerName) const; + + bool HasSourceFileBeenUpdated() const; + +private: + //---------------------------------------------------------------------------------------------------------------- + // STATIC PRIVATE INTERFACE + //---------------------------------------------------------------------------------------------------------------- + // Compiles shader from source file with the given shader macros + // + static bool CompileFromSource( + const std::string& pathToFile + , const EShaderStage& type + , ID3D10Blob *& ref_pBob + , std::string& outErrMsg + , const std::vector& macros); + + // Reads in cached binary from %APPDATA%/VQEngine/ShaderCache folder into ID3D10Blob + // + static ID3D10Blob * CompileFromCachedBinary(const std::string& cachedBinaryFilePath); + + // Writes out compiled ID3D10Blob into %APPDATA%/VQEngine/ShaderCache folder + // + static void CacheShaderBinary(const std::string& shaderCacheFileName, ID3D10Blob * pCompiledBinary); + + // example filePath: "rootPath/filename_vs.hlsl" + // ^^----- shaderTypeString + static EShaderStage GetShaderTypeFromSourceFilePath(const std::string& shaderFilePath); + + //---------------------------------------------------------------------------------------------------------------- + // UTILITY FUNCTIONS + //---------------------------------------------------------------------------------------------------------------- + void ReflectConstantBufferLayouts(ID3D12ShaderReflection * sRefl, EShaderStage type); + bool CompileShaders(ID3D12Device* device, const ShaderDesc& desc); + void SetReflections(const ShaderBlobs& blobs); + void CreateShaderStage(ID3D12Device* pDevice, EShaderStage stage, void* pBuffer, const size_t szShaderBinary); + void CheckSignatures(); + void LogConstantBufferLayouts() const; + void ReleaseResources(); + size_t GeneratePreprocessorDefinitionsHash(const std::vector& macros) const; + +private: + //---------------------------------------------------------------------------------------------------------------- + // DATA + //---------------------------------------------------------------------------------------------------------------- + ShaderID mID; + ShaderStages mStages; + + ShaderReflections mReflections; // shader reflections, temporary? + //ID3D12InputLayout* mpInputLayout = nullptr; + + std::string mName; + + std::vector mConstantBuffers; // https://msdn.microsoft.com/en-us/library/windows/desktop/bb509581(v=vs.85).aspx + std::vector m_CBLayouts; + std::vector m_constants;// currently redundant + //std::vector mCPUConstantBuffers; + + std::vector mTextureBindings; + std::vector mSamplerBindings; + + ShaderTextureLookup mShaderTextureLookup; + ShaderSamplerLookup mShaderSamplerLookup; + + ShaderDesc mDescriptor; // used for shader reloading + ShaderDirectoryLookup mDirectories; +}; +#endif \ No newline at end of file diff --git a/Source/Scenes/StressTestScene.cpp b/Source/Scenes/StressTestScene.cpp index 8e9aa87e..1e39ba0a 100644 --- a/Source/Scenes/StressTestScene.cpp +++ b/Source/Scenes/StressTestScene.cpp @@ -79,7 +79,7 @@ void StressTestScene::LoadScene(FSceneRepresentation& scene) FGameObjectRepresentation obj = {}; XMFLOAT3 pos = { 0, 0, 0 }; XMFLOAT3 axis = UpVector; - XMFLOAT3 scale = { 100, 100, 100 }; + XMFLOAT3 scale = { 500, 500, 500 }; obj.tf.SetPosition(pos); obj.tf.SetScale(scale); obj.BuiltinMeshName = "Cube"; From 28813379f01b6fcaf0b1ff2110cf9eaa815adfa8 Mon Sep 17 00:00:00 2001 From: Volkan Date: Thu, 10 Sep 2020 00:02:02 -0700 Subject: [PATCH 50/67] Fix object rotations on stresstest scene, reduce memory footprint of asset loader --- Data/EngineSettings.ini | 2 +- Data/Levels/StressTest.xml | 42 ++++++++++++++++-------------- Source/Application/AssetLoader.cpp | 2 ++ Source/Application/FileParser.cpp | 3 --- 4 files changed, 25 insertions(+), 24 deletions(-) diff --git a/Data/EngineSettings.ini b/Data/EngineSettings.ini index 07744e88..2a2e6ab6 100644 --- a/Data/EngineSettings.ini +++ b/Data/EngineSettings.ini @@ -13,7 +13,7 @@ Width=768 Height=432 DisplayMode=Windowed PreferredDisplay=0 -Scene=Sponza +Scene=StressTest DebugWindow=false DebugWindowWidth=450 diff --git a/Data/Levels/StressTest.xml b/Data/Levels/StressTest.xml index 3633f6d0..bb5ea3b8 100644 --- a/Data/Levels/StressTest.xml +++ b/Data/Levels/StressTest.xml @@ -46,33 +46,24 @@ + - -20 40 0 + 40 20 0 0 0 0 1 - 50 50 50 - - - Data/Models/FlightHelmet/glTF/FlightHelmet.gltf - FlightHelmet - - - - - 20 20 0 - 0 0 0 1 - 0.01 0.01 0.01 + 0.02 0.02 0.02 Data/Models/Sponza/glTF/Sponza.gltf Sponza - + + -60 20 0 - 0 0 0 1 + 0 180 0 1000 1000 1000 @@ -80,11 +71,10 @@ BoomBox - -40 20 0 - 0 0 0 1 + -90 0 0 10 10 10 @@ -103,10 +93,11 @@ Suzanne - + + - -60 40 0 + -60 50 0 0 0 0 1 8 8 8 @@ -118,7 +109,7 @@ - -40 40 0 + -40 50 0 0 0 0 1 1 1 1 @@ -127,6 +118,17 @@ Lantern + + + -20 40 0 + 0 0 0 1 + 50 50 50 + + + Data/Models/FlightHelmet/glTF/FlightHelmet.gltf + FlightHelmet + + diff --git a/Source/Application/AssetLoader.cpp b/Source/Application/AssetLoader.cpp index 6e72d29a..c5609ac8 100644 --- a/Source/Application/AssetLoader.cpp +++ b/Source/Application/AssetLoader.cpp @@ -182,6 +182,8 @@ AssetLoader::TextureLoadResults_t AssetLoader::StartLoadingTextures(LoadTaskID t // Currently mRenderer.CreateTextureFromFile() starts the texture uploads ///mRenderer.StartTextureUploads(); + mLookup_TextureLoadContext.erase(taskID); + return std::move(TextureLoadResults); } diff --git a/Source/Application/FileParser.cpp b/Source/Application/FileParser.cpp index da9a69f7..2436fed1 100644 --- a/Source/Application/FileParser.cpp +++ b/Source/Application/FileParser.cpp @@ -392,9 +392,6 @@ FSceneRepresentation VQEngine::ParseSceneFile(const std::string& SceneFile) //----------------------------------------------------------------- constexpr char* SCENE_FILES_DIRECTORY = "Data/Levels/"; //----------------------------------------------------------------- - // std::vector SceneRepresentations; - //const std::vector SceneFiles = DirectoryUtil::ListFilesInDirectory(SCENE_FILES_DIRECTORY, ".xml"); - //----------------------------------------------------------------- // parse vectors -------------------------------------------------- // e.g." 0.0 9 -1.0f" -> [0.0f, 9.0f, -1.0f] From 5c038a6dcc1a86e94d73add8430e87486ae78ecf Mon Sep 17 00:00:00 2001 From: Volkan Date: Thu, 10 Sep 2020 00:13:05 -0700 Subject: [PATCH 51/67] Fix environment map switching --- Source/Application/Platform.h | 2 +- Source/Application/VQEngine.h | 1 + Source/Application/VQEngine_Render.cpp | 2 +- Source/Application/VQEngine_Update.cpp | 22 ++++++++++++++++++---- 4 files changed, 21 insertions(+), 6 deletions(-) diff --git a/Source/Application/Platform.h b/Source/Application/Platform.h index f582f862..5711753f 100644 --- a/Source/Application/Platform.h +++ b/Source/Application/Platform.h @@ -66,4 +66,4 @@ LRESULT CALLBACK WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam); template static inline T CircularIncrement(T currVal, T maxVal) { return (currVal + 1) % maxVal; } -template static inline T CircularDecrement(T currVal, T maxVal) { return currVal == 0 ? maxVal : currVal - 1; } \ No newline at end of file +template static inline T CircularDecrement(T currVal, T maxVal, T minVal = 0) { return currVal == minVal ? maxVal : currVal - 1; } \ No newline at end of file diff --git a/Source/Application/VQEngine.h b/Source/Application/VQEngine.h index 8566d816..742bdfbf 100644 --- a/Source/Application/VQEngine.h +++ b/Source/Application/VQEngine.h @@ -299,6 +299,7 @@ class VQEngine : public IWindowOwner std::atomic mNumRenderLoopsExecuted; std::atomic mNumUpdateLoopsExecuted; std::atomic mbLoadingLevel; + std::atomic mbLoadingEnvironmentMap; std::atomic mbMainWindowHDRTransitionInProgress; // see DispatchHDRSwapchainTransitionEvents() // system & settings diff --git a/Source/Application/VQEngine_Render.cpp b/Source/Application/VQEngine_Render.cpp index d2e1412e..addbede1 100644 --- a/Source/Application/VQEngine_Render.cpp +++ b/Source/Application/VQEngine_Render.cpp @@ -342,7 +342,7 @@ void VQEngine::RenderThread_RenderMainWindow() HRESULT hr = S_OK; FWindowRenderContext& ctx = mRenderer.GetWindowRenderContext(mpWinMain->GetHWND()); - hr = mbLoadingLevel + hr = mbLoadingLevel || mbLoadingEnvironmentMap ? RenderThread_RenderMainWindow_LoadingScreen(ctx) : RenderThread_RenderMainWindow_Scene(ctx); diff --git a/Source/Application/VQEngine_Update.cpp b/Source/Application/VQEngine_Update.cpp index 3b9f021b..bdcd388c 100644 --- a/Source/Application/VQEngine_Update.cpp +++ b/Source/Application/VQEngine_Update.cpp @@ -70,6 +70,7 @@ void VQEngine::UpdateThread_Main() void VQEngine::UpdateThread_Inititalize() { mNumUpdateLoopsExecuted.store(0); + mbLoadingEnvironmentMap.store(false); // busy lock until render thread is initialized while (!mbRenderThreadInitialized); @@ -116,7 +117,7 @@ void VQEngine::UpdateThread_UpdateAppState(const float dt) } - if (mbLoadingLevel) + if (mbLoadingLevel || mbLoadingEnvironmentMap) { // animate loading screen @@ -126,11 +127,24 @@ void VQEngine::UpdateThread_UpdateAppState(const float dt) const bool bLoadDone = NumActiveTasks == 0; if (bLoadDone) { - mpScene->OnLoadComplete(); + if (mbLoadingLevel) + { + mpScene->OnLoadComplete(); + } + // OnEnvMapLoaded = noop + WaitUntilRenderingFinishes(); Log::Info("Loading completed, starting scene simulation"); mAppState = EAppState::SIMULATING; - mbLoadingLevel.store(false); + + if (mbLoadingLevel) + { + mbLoadingLevel.store(false); + } + if (mbLoadingEnvironmentMap) + { + mbLoadingEnvironmentMap.store(false); + } } } @@ -366,7 +380,7 @@ void VQEngine::StartLoadingEnvironmentMap(int IndexEnvMap) { this->WaitUntilRenderingFinishes(); mAppState = EAppState::LOADING; - mbLoadingLevel = true; + mbLoadingEnvironmentMap = true; mWorkers_Load.AddTask([&, IndexEnvMap]() { LoadEnvironmentMap(mResourceNames.mEnvironmentMapPresetNames[IndexEnvMap]); From 8e73e3445041b49d04cd8c682df89f0a6a094ae3 Mon Sep 17 00:00:00 2001 From: Volkan Date: Thu, 10 Sep 2020 00:44:38 -0700 Subject: [PATCH 52/67] Rotation loading screens --- Source/Application/VQEngine.h | 9 ++++- Source/Application/VQEngine_Render.cpp | 2 +- Source/Application/VQEngine_Update.cpp | 50 +++++++++++++++++++++++--- Source/Renderer/Renderer.cpp | 2 +- 4 files changed, 55 insertions(+), 8 deletions(-) diff --git a/Source/Application/VQEngine.h b/Source/Application/VQEngine.h index 742bdfbf..a3ca40bd 100644 --- a/Source/Application/VQEngine.h +++ b/Source/Application/VQEngine.h @@ -46,7 +46,14 @@ struct FLoadingScreenData { std::array SwapChainClearColor; - SRV_ID SRVLoadingScreen = INVALID_ID; + + int SelectedLoadingScreenSRVIndex = INVALID_ID; + std::mutex Mtx; + std::vector SRVs; + + SRV_ID GetSelectedLoadingScreenSRV_ID() const; + void RotateLoadingScreenImage(); + // TODO: animation resources }; diff --git a/Source/Application/VQEngine_Render.cpp b/Source/Application/VQEngine_Render.cpp index addbede1..9164173a 100644 --- a/Source/Application/VQEngine_Render.cpp +++ b/Source/Application/VQEngine_Render.cpp @@ -528,7 +528,7 @@ HRESULT VQEngine::RenderThread_RenderMainWindow_LoadingScreen(FWindowRenderConte pCmd->SetGraphicsRootSignature(mRenderer.GetRootSignature(1)); pCmd->SetDescriptorHeaps(_countof(ppHeaps), ppHeaps); - pCmd->SetGraphicsRootDescriptorTable(0, mRenderer.GetShaderResourceView(mLoadingScreenData.SRVLoadingScreen).GetGPUDescHandle()); + pCmd->SetGraphicsRootDescriptorTable(0, mRenderer.GetShaderResourceView(mLoadingScreenData.GetSelectedLoadingScreenSRV_ID()).GetGPUDescHandle()); pCmd->RSSetViewports(1, &viewport); pCmd->RSSetScissorRects(1, &scissorsRect); diff --git a/Source/Application/VQEngine_Update.cpp b/Source/Application/VQEngine_Update.cpp index bdcd388c..5b8688e5 100644 --- a/Source/Application/VQEngine_Update.cpp +++ b/Source/Application/VQEngine_Update.cpp @@ -113,7 +113,7 @@ void VQEngine::UpdateThread_UpdateAppState(const float dt) // set state mAppState = EAppState::LOADING;// not thread-safe - mbLoadingLevel.store(true); // thread-safe + } @@ -145,6 +145,8 @@ void VQEngine::UpdateThread_UpdateAppState(const float dt) { mbLoadingEnvironmentMap.store(false); } + + mLoadingScreenData.RotateLoadingScreenImage(); } } @@ -400,6 +402,7 @@ void VQEngine::StartLoadingScene(int IndexScene) mQueue_SceneLoad.push(mResourceNames.mSceneNames[IndexScene]); mAppState = INITIALIZING; + mbLoadingLevel.store(true); // thread-safe Log::Info("StartLoadingScene: %d", IndexScene); } @@ -536,17 +539,54 @@ void VQEngine::LoadEnvironmentMap(const std::string& EnvMapName) } +SRV_ID FLoadingScreenData::GetSelectedLoadingScreenSRV_ID() const +{ + assert(SelectedLoadingScreenSRVIndex < SRVs.size()); + return SRVs[SelectedLoadingScreenSRVIndex]; +} +void FLoadingScreenData::RotateLoadingScreenImage() +{ + SelectedLoadingScreenSRVIndex = (int)MathUtil::RandU(0, (int)SRVs.size()); +} void VQEngine::LoadLoadingScreenData() { FLoadingScreenData& data = mLoadingScreenData; data.SwapChainClearColor = { 0.0f, 0.2f, 0.4f, 1.0f }; + constexpr uint NUM_LOADING_SCREEN_BACKGROUNDS = 4; + srand(static_cast(time(NULL))); const std::string LoadingScreenTextureFileDirectory = "Data/Textures/LoadingScreen/"; - const std::string LoadingScreenTextureFilePath = LoadingScreenTextureFileDirectory + (std::to_string(MathUtil::RandU(0, 4)) + ".png"); - TextureID texID = mRenderer.CreateTextureFromFile(LoadingScreenTextureFilePath.c_str()); - SRV_ID srvID = mRenderer.CreateAndInitializeSRV(texID); - data.SRVLoadingScreen = srvID; + const size_t SelectedLoadingScreenIndex = MathUtil::RandU(0u, NUM_LOADING_SCREEN_BACKGROUNDS); + + // dispatch background workers for other + for (size_t i = 0; i < NUM_LOADING_SCREEN_BACKGROUNDS; ++i) + { + if (i == SelectedLoadingScreenIndex) + continue; // will be loaded on this thread + + const std::string LoadingScreenTextureFilePath = LoadingScreenTextureFileDirectory + (std::to_string(i) + ".png"); + + mWorkers_Load.AddTask([this, &data, LoadingScreenTextureFilePath]() + { + const TextureID texID = mRenderer.CreateTextureFromFile(LoadingScreenTextureFilePath.c_str()); + const SRV_ID srvID = mRenderer.CreateAndInitializeSRV(texID); + std::lock_guard lk(data.Mtx); + data.SRVs.push_back(srvID); + }); + + } + + // load the selected loading screen image + { + const std::string LoadingScreenTextureFilePath = LoadingScreenTextureFileDirectory + (std::to_string(SelectedLoadingScreenIndex) + ".png"); + TextureID texID = mRenderer.CreateTextureFromFile(LoadingScreenTextureFilePath.c_str()); + SRV_ID srvID = mRenderer.CreateAndInitializeSRV(texID); + std::lock_guard lk(data.Mtx); + data.SRVs.push_back(srvID); + data.SelectedLoadingScreenSRVIndex = data.SRVs.size() - 1; + } + } diff --git a/Source/Renderer/Renderer.cpp b/Source/Renderer/Renderer.cpp index 426ea656..2f8014a6 100644 --- a/Source/Renderer/Renderer.cpp +++ b/Source/Renderer/Renderer.cpp @@ -870,7 +870,7 @@ void VQRenderer::LoadDefaultResources() textureDesc.Flags = D3D12_RESOURCE_FLAG_NONE; } - // programmatically generated texture + // programmatically generated textures { std::vector texture = Texture::GenerateTexture_Checkerboard(sizeX); TextureID texID = this->CreateTexture("Checkerboard", textureDesc, D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE, texture.data()); From 603dbe2a5c227cc4f43aeb918ec3707802970968 Mon Sep 17 00:00:00 2001 From: Volkan Date: Mon, 14 Sep 2020 10:58:42 -0700 Subject: [PATCH 53/67] Bump CBV_SRV_UAV descriptor counts --- Source/Renderer/Renderer.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Source/Renderer/Renderer.cpp b/Source/Renderer/Renderer.cpp index 2f8014a6..5e624de6 100644 --- a/Source/Renderer/Renderer.cpp +++ b/Source/Renderer/Renderer.cpp @@ -368,9 +368,9 @@ void VQRenderer::InitializeHeaps() const uint32 UPLOAD_HEAP_SIZE = 513 * MEGABYTE; // TODO: from RendererSettings.ini mHeapUpload.Create(pDevice, UPLOAD_HEAP_SIZE, this->mGFXQueue.pQueue); - constexpr uint32 NumDescsCBV = 10; - constexpr uint32 NumDescsSRV = 1000; - constexpr uint32 NumDescsUAV = 10; + constexpr uint32 NumDescsCBV = 100; + constexpr uint32 NumDescsSRV = 3800; + constexpr uint32 NumDescsUAV = 100; constexpr bool bCPUVisible = false; mHeapCBV_SRV_UAV.Create(pDevice, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV, NumDescsCBV + NumDescsSRV + NumDescsUAV, bCPUVisible); From a0ab4ade2350cb1ffec3808452d71eb4408ed195 Mon Sep 17 00:00:00 2001 From: Volkan Date: Mon, 14 Sep 2020 11:12:08 -0700 Subject: [PATCH 54/67] Fix environment map camera FoV not being the same as the main view FoV --- Source/Application/VQEngine_Render.cpp | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/Source/Application/VQEngine_Render.cpp b/Source/Application/VQEngine_Render.cpp index 9164173a..1069f56f 100644 --- a/Source/Application/VQEngine_Render.cpp +++ b/Source/Application/VQEngine_Render.cpp @@ -770,20 +770,15 @@ void VQEngine::RenderSceneColor(FWindowRenderContext& ctx, const FSceneView& Sce ID3D12DescriptorHeap* ppHeaps[] = { mRenderer.GetDescHeap(EResourceHeapType::CBV_SRV_UAV_HEAP) }; Camera skyCam = mpScene->GetActiveCamera().Clone(); -#if 1 FCameraParameters p = {}; p.bInitializeCameraController = false; p.ProjectionParams = skyCam.GetProjectionParameters(); p.ProjectionParams.bPerspectiveProjection = true; - p.ProjectionParams.FieldOfView = 45; + p.ProjectionParams.FieldOfView = p.ProjectionParams.FieldOfView * RAD2DEG; // TODO: remove the need for this conversion p.x = p.y = p.z = 0; p.Yaw = skyCam.GetYaw() * RAD2DEG; p.Pitch = skyCam.GetPitch() * RAD2DEG; skyCam.InitializeCamera(p); -#else - skyCam.SetPosition(0,0,0); - skyCam.UpdateViewMatrix(); -#endif D3D12_GPU_VIRTUAL_ADDRESS cbAddr = {}; FFrameConstantBuffer * pConstBuffer = {}; From 8646e9e6c052a13ecbccd448d3881d40e79b7f01 Mon Sep 17 00:00:00 2001 From: Volkan Date: Mon, 14 Sep 2020 11:41:56 -0700 Subject: [PATCH 55/67] Fix warning --- Source/Application/VQEngine_Update.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Source/Application/VQEngine_Update.cpp b/Source/Application/VQEngine_Update.cpp index 5b8688e5..9cf9b43b 100644 --- a/Source/Application/VQEngine_Update.cpp +++ b/Source/Application/VQEngine_Update.cpp @@ -585,7 +585,7 @@ void VQEngine::LoadLoadingScreenData() SRV_ID srvID = mRenderer.CreateAndInitializeSRV(texID); std::lock_guard lk(data.Mtx); data.SRVs.push_back(srvID); - data.SelectedLoadingScreenSRVIndex = data.SRVs.size() - 1; + data.SelectedLoadingScreenSRVIndex = static_cast(data.SRVs.size() - 1); } } From 7b49ccff9d117c9ea3bfed218ba02fc5398b9352 Mon Sep 17 00:00:00 2001 From: Volkan Date: Mon, 14 Sep 2020 17:55:18 -0700 Subject: [PATCH 56/67] Fix starving threads w/ low thread-count systems by separating model and texture load worker pool and adjust loading-time worker count --- Source/Application/AssetLoader.cpp | 22 ++++++++++++++-------- Source/Application/AssetLoader.h | 11 ++++++----- Source/Application/Scene.cpp | 2 +- Source/Application/VQEngine.h | 3 ++- Source/Application/VQEngine_Main.cpp | 16 ++++++++++------ Source/Application/VQEngine_Update.cpp | 8 ++++---- 6 files changed, 37 insertions(+), 25 deletions(-) diff --git a/Source/Application/AssetLoader.cpp b/Source/Application/AssetLoader.cpp index c5609ac8..52a61a92 100644 --- a/Source/Application/AssetLoader.cpp +++ b/Source/Application/AssetLoader.cpp @@ -43,6 +43,12 @@ AssetLoader::LoadTaskID AssetLoader::GenerateLoadTaskID() return id; } +AssetLoader::AssetLoader(ThreadPool& WorkerThreads_Model, ThreadPool& WorkerThreads_Texture, VQRenderer& renderer) + : mWorkers_ModelLoad(WorkerThreads_Model) + , mWorkers_TextureLoad(WorkerThreads_Texture) + , mRenderer(renderer) +{} + //---------------------------------------------------------------------------------------------------------------- // ASSET LOADER //---------------------------------------------------------------------------------------------------------------- @@ -81,13 +87,13 @@ AssetLoader::ModelLoadResults_t AssetLoader::StartLoadingModels(Scene* pScene) mUniqueModelPaths.insert(ModelPath); // check whether Exit signal is given to the app before dispatching workers - if (mWorkers.IsExiting()) + if (mWorkers_ModelLoad.IsExiting() || mWorkers_TextureLoad.IsExiting()) { break; } - // start loading - modelLoadResult = std::move(mWorkers.AddTask([=]() + // start loading the model + modelLoadResult = std::move(mWorkers_ModelLoad.AddTask([=]() { return ModelLoadParams.pfnImportModel(pScene, this, pRenderer, ModelLoadParams.ModelPath, ModelLoadParams.ModelName); })); @@ -147,13 +153,13 @@ AssetLoader::TextureLoadResults_t AssetLoader::StartLoadingTextures(LoadTaskID t : EProceduralTextures::NUM_PROCEDURAL_TEXTURES; // check whether Exit signal is given to the app before dispatching workers - if (mWorkers.IsExiting()) + if (mWorkers_TextureLoad.IsExiting()) { break; } // dispatch worker thread - std::shared_future texLoadResult = std::move(mWorkers.AddTask([this, TexLoadParams, ProcTex]() + std::shared_future texLoadResult = std::move(mWorkers_TextureLoad.AddTask([this, TexLoadParams, ProcTex]() { const bool IS_PROCEDURAL = ProcTex != EProceduralTextures::NUM_PROCEDURAL_TEXTURES; if (IS_PROCEDURAL) @@ -248,7 +254,7 @@ void AssetLoader::FMaterialTextureAssignments::DoAssignments(Scene* pScene, VQRe const MaterialID& matID = it->first; TextureLoadResult_t& result = it->second; - if (mWorkers.IsExiting()) + if (mWorkersThreads.IsExiting()) break; assert(result.texLoadResult.valid()); @@ -287,7 +293,7 @@ void AssetLoader::FMaterialTextureAssignments::WaitForTextureLoads() const TextureLoadResult_t& result = it->second; assert(result.texLoadResult.valid()); - if (mWorkers.IsExiting()) + if (mWorkersThreads.IsExiting()) break; result.texLoadResult.wait(); @@ -359,7 +365,7 @@ ModelID AssetLoader::ImportModel(Scene* pScene, AssetLoader* pAssetLoader, VQRen Log::Info(" [%.2fs] ReadFile=%s ", fTimeReadFile, objFilePath.c_str()); // parse scene and initialize model data - FMaterialTextureAssignments MaterialTextureAssignments(pAssetLoader->mWorkers); + FMaterialTextureAssignments MaterialTextureAssignments(pAssetLoader->mWorkers_TextureLoad); Model::Data data = ProcessAssimpNode(pAiScene->mRootNode, pAiScene, modelDirectory, pAssetLoader, pScene, pRenderer, MaterialTextureAssignments, taskID); pRenderer->UploadVertexAndIndexBufferHeaps(); // load VB/IBs diff --git a/Source/Application/AssetLoader.h b/Source/Application/AssetLoader.h index 6b5a4025..0b0d3159 100644 --- a/Source/Application/AssetLoader.h +++ b/Source/Application/AssetLoader.h @@ -80,11 +80,11 @@ class AssetLoader }; struct FMaterialTextureAssignments { - FMaterialTextureAssignments(const ThreadPool& workers) : mWorkers(workers) {} + FMaterialTextureAssignments(const ThreadPool& workers) : mWorkersThreads(workers) {} void DoAssignments(Scene* pScene, VQRenderer* pRenderer); void WaitForTextureLoads(); - const ThreadPool& mWorkers; // to check if pool IsExiting() + const ThreadPool& mWorkersThreads; // to check if pool IsExiting() std::vector mAssignments; TextureLoadResults_t mTextureLoadResults; }; @@ -92,8 +92,8 @@ class AssetLoader using LoadTaskID = int; static LoadTaskID GenerateLoadTaskID(); - AssetLoader(ThreadPool& WorkerThreads, VQRenderer& renderer): mWorkers(WorkerThreads), mRenderer(renderer){} - inline const ThreadPool& GetThreadPool() const { return mWorkers; } + AssetLoader(ThreadPool& WorkerThreads_Model, ThreadPool& WorkerThreads_Texture, VQRenderer& renderer); + inline const ThreadPool& GetThreadPool_TextureLoad() const { return mWorkers_TextureLoad; } void QueueModelLoad(GameObject* pObject, const std::string& ModelPath, const std::string& ModelName); ModelLoadResults_t StartLoadingModels(Scene* pScene); @@ -106,7 +106,8 @@ class AssetLoader private: - ThreadPool& mWorkers; + ThreadPool& mWorkers_ModelLoad; + ThreadPool& mWorkers_TextureLoad; VQRenderer& mRenderer; template struct FLoadTaskContext diff --git a/Source/Application/Scene.cpp b/Source/Application/Scene.cpp index a07edaa9..cf221934 100644 --- a/Source/Application/Scene.cpp +++ b/Source/Application/Scene.cpp @@ -135,7 +135,7 @@ Scene::Scene(VQEngine& engine, int NumFrameBuffers, const Input& input, const st , mResourceNames(engine.GetResourceNames()) , mAssetLoader(engine.GetAssetLoader()) , mRenderer(renderer) - , mMaterialAssignments(engine.GetAssetLoader().GetThreadPool()) + , mMaterialAssignments(engine.GetAssetLoader().GetThreadPool_TextureLoad()) {} void Scene::Update(float dt, int FRAME_DATA_INDEX) diff --git a/Source/Application/VQEngine.h b/Source/Application/VQEngine.h index a3ca40bd..0791f79b 100644 --- a/Source/Application/VQEngine.h +++ b/Source/Application/VQEngine.h @@ -261,7 +261,8 @@ class VQEngine : public IWindowOwner std::thread mUpdateThread; ThreadPool mWorkers_Update; ThreadPool mWorkers_Render; - ThreadPool mWorkers_Load; + ThreadPool mWorkers_ModelLoading; + ThreadPool mWorkers_TextureLoading; // sync std::atomic mbStopAllThreads; diff --git a/Source/Application/VQEngine_Main.cpp b/Source/Application/VQEngine_Main.cpp index eac2932a..4788659f 100644 --- a/Source/Application/VQEngine_Main.cpp +++ b/Source/Application/VQEngine_Main.cpp @@ -37,7 +37,7 @@ void ReportSystemInfo(const VQSystemInfo::FSystemInfo& i, bool bDetailed = false } #endif VQEngine::VQEngine() - : mAssetLoader(mWorkers_Load, mRenderer) + : mAssetLoader(mWorkers_ModelLoading, mWorkers_TextureLoading, mRenderer) {} void VQEngine::MainThread_Tick() @@ -290,23 +290,27 @@ void VQEngine::InitializeThreads() const int NUM_SWAPCHAIN_BACKBUFFERS = mSettings.gfx.bUseTripleBuffering ? 3 : 2; const size_t HWThreads = ThreadPool::sHardwareThreadCount; const size_t HWCores = HWThreads / 2; - const size_t NumWorkers = HWCores - 2; // reserve 2 cores for (Update + Render) + Main threads + const size_t NumRuntimeWorkers = HWCores - 2; // reserve 2 cores for Update + Render threads + const size_t NumLoadtimeWorkers = HWThreads; mpSemUpdate.reset(new Semaphore(NUM_SWAPCHAIN_BACKBUFFERS, NUM_SWAPCHAIN_BACKBUFFERS)); mpSemRender.reset(new Semaphore(0 , NUM_SWAPCHAIN_BACKBUFFERS)); mbRenderThreadInitialized.store(false); mbStopAllThreads.store(false); - mWorkers_Load.Initialize(NumWorkers, "LoadWorkers"); + + mWorkers_ModelLoading.Initialize(NumLoadtimeWorkers, "LoadWorkers_Model"); + mWorkers_TextureLoading.Initialize(NumLoadtimeWorkers, "LoadWorkers_Texture"); mRenderThread = std::thread(&VQEngine::RenderThread_Main, this); mUpdateThread = std::thread(&VQEngine::UpdateThread_Main, this); - mWorkers_Update.Initialize(NumWorkers, "UpdateWorkers"); - mWorkers_Render.Initialize(NumWorkers, "RenderWorkers"); + mWorkers_Update.Initialize(NumRuntimeWorkers, "UpdateWorkers"); + mWorkers_Render.Initialize(NumRuntimeWorkers, "RenderWorkers"); } void VQEngine::ExitThreads() { - mWorkers_Load.Exit(); + mWorkers_ModelLoading.Exit(); + mWorkers_TextureLoading.Exit(); mbStopAllThreads.store(true); mRenderThread.join(); mUpdateThread.join(); diff --git a/Source/Application/VQEngine_Update.cpp b/Source/Application/VQEngine_Update.cpp index 9cf9b43b..1c9733cf 100644 --- a/Source/Application/VQEngine_Update.cpp +++ b/Source/Application/VQEngine_Update.cpp @@ -123,7 +123,7 @@ void VQEngine::UpdateThread_UpdateAppState(const float dt) // check if loading is done - const int NumActiveTasks = mWorkers_Load.GetNumActiveTasks(); + const int NumActiveTasks = mWorkers_ModelLoading.GetNumActiveTasks() + mWorkers_TextureLoading.GetNumActiveTasks(); const bool bLoadDone = NumActiveTasks == 0; if (bLoadDone) { @@ -383,7 +383,7 @@ void VQEngine::StartLoadingEnvironmentMap(int IndexEnvMap) this->WaitUntilRenderingFinishes(); mAppState = EAppState::LOADING; mbLoadingEnvironmentMap = true; - mWorkers_Load.AddTask([&, IndexEnvMap]() + mWorkers_TextureLoading.AddTask([&, IndexEnvMap]() { LoadEnvironmentMap(mResourceNames.mEnvironmentMapPresetNames[IndexEnvMap]); }); @@ -498,7 +498,7 @@ void VQEngine::Load_SceneData_Dispatch() if (!SceneRep.EnvironmentMapPreset.empty()) { - mWorkers_Load.AddTask([=]() { LoadEnvironmentMap(SceneRep.EnvironmentMapPreset); }); + mWorkers_TextureLoading.AddTask([=]() { LoadEnvironmentMap(SceneRep.EnvironmentMapPreset); }); } } @@ -568,7 +568,7 @@ void VQEngine::LoadLoadingScreenData() const std::string LoadingScreenTextureFilePath = LoadingScreenTextureFileDirectory + (std::to_string(i) + ".png"); - mWorkers_Load.AddTask([this, &data, LoadingScreenTextureFilePath]() + mWorkers_TextureLoading.AddTask([this, &data, LoadingScreenTextureFilePath]() { const TextureID texID = mRenderer.CreateTextureFromFile(LoadingScreenTextureFilePath.c_str()); const SRV_ID srvID = mRenderer.CreateAndInitializeSRV(texID); From e27e196de744a066fb4a241e773dc0e4394a7ab7 Mon Sep 17 00:00:00 2001 From: Volkan Date: Mon, 14 Sep 2020 19:09:12 -0700 Subject: [PATCH 57/67] Add DPI awareness --- Source/Application/Main.cpp | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/Source/Application/Main.cpp b/Source/Application/Main.cpp index 9e463778..ba4db388 100644 --- a/Source/Application/Main.cpp +++ b/Source/Application/Main.cpp @@ -16,9 +16,12 @@ // // Contact: volkanilbeyli@gmail.com +#include +#include +#pragma comment(lib, "shcore.lib") + #include #include -#include #include #include @@ -29,7 +32,6 @@ #include "Platform.h" #include "VQEngine.h" - void ParseCommandLineParameters(FStartupParameters& refStartupParams, PSTR pScmdl) { const std::string StrCmdLineParams = pScmdl; @@ -170,6 +172,8 @@ void ParseCommandLineParameters(FStartupParameters& refStartupParams, PSTR pScmd int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInst, PSTR pScmdl, int iCmdShow) { + SetProcessDpiAwareness(PROCESS_PER_MONITOR_DPI_AWARE); + FStartupParameters StartupParameters = {}; StartupParameters.hExeInstance = hInst; StartupParameters.iCmdShow = iCmdShow; From 672b1dd7dabe6814a31514020582069ded3e37cd Mon Sep 17 00:00:00 2001 From: Volkan Date: Mon, 14 Sep 2020 19:21:03 -0700 Subject: [PATCH 58/67] Fix out-of-sync env map and scene views --- Source/Application/AssetLoader.h | 1 - Source/Application/Scene.cpp | 3 ++- Source/Application/Scene.h | 2 ++ Source/Application/VQEngine_Render.cpp | 4 ++-- 4 files changed, 6 insertions(+), 4 deletions(-) diff --git a/Source/Application/AssetLoader.h b/Source/Application/AssetLoader.h index 0b0d3159..f8f53e2b 100644 --- a/Source/Application/AssetLoader.h +++ b/Source/Application/AssetLoader.h @@ -105,7 +105,6 @@ class AssetLoader static ModelID ImportModel(Scene* pScene, AssetLoader* pAssetLoader, VQRenderer* pRenderer, const std::string& objFilePath, std::string ModelName = "NONE"); private: - ThreadPool& mWorkers_ModelLoad; ThreadPool& mWorkers_TextureLoad; VQRenderer& mRenderer; diff --git a/Source/Application/Scene.cpp b/Source/Application/Scene.cpp index cf221934..ed15e930 100644 --- a/Source/Application/Scene.cpp +++ b/Source/Application/Scene.cpp @@ -165,7 +165,8 @@ void Scene::PostUpdate(int FRAME_DATA_INDEX, int FRAME_DATA_NEXT_INDEX) SceneView.viewInverse = cam.GetViewInverseMatrix(); SceneView.viewProj = SceneView.view * SceneView.proj; SceneView.cameraPosition = XMLoadFloat3(&camPos); - + SceneView.MainViewCameraYaw = cam.GetYaw(); + SceneView.MainViewCameraPitch = cam.GetPitch(); // TODO: compute visibility diff --git a/Source/Application/Scene.h b/Source/Application/Scene.h index d4a4d248..38aebd2d 100644 --- a/Source/Application/Scene.h +++ b/Source/Application/Scene.h @@ -96,6 +96,8 @@ struct FSceneView DirectX::XMMATRIX projInverse; DirectX::XMMATRIX directionalLightProjection; DirectX::XMVECTOR cameraPosition; + float MainViewCameraYaw = 0.0f; + float MainViewCameraPitch = 0.0f; //bool bIsPBRLightingUsed; //bool bIsDeferredRendering; //bool bIsIBLEnabled; diff --git a/Source/Application/VQEngine_Render.cpp b/Source/Application/VQEngine_Render.cpp index 1069f56f..946f0849 100644 --- a/Source/Application/VQEngine_Render.cpp +++ b/Source/Application/VQEngine_Render.cpp @@ -776,8 +776,8 @@ void VQEngine::RenderSceneColor(FWindowRenderContext& ctx, const FSceneView& Sce p.ProjectionParams.bPerspectiveProjection = true; p.ProjectionParams.FieldOfView = p.ProjectionParams.FieldOfView * RAD2DEG; // TODO: remove the need for this conversion p.x = p.y = p.z = 0; - p.Yaw = skyCam.GetYaw() * RAD2DEG; - p.Pitch = skyCam.GetPitch() * RAD2DEG; + p.Yaw = SceneView.MainViewCameraYaw * RAD2DEG; + p.Pitch = SceneView.MainViewCameraPitch * RAD2DEG; skyCam.InitializeCamera(p); D3D12_GPU_VIRTUAL_ADDRESS cbAddr = {}; From bc952c87a5332a54e5ccb5763b442f39dd862999 Mon Sep 17 00:00:00 2001 From: Volkan Date: Mon, 14 Sep 2020 19:38:52 -0700 Subject: [PATCH 59/67] remove unintended files --- Source/Renderer/Shader.cpp | 900 ------------------------------------- Source/Renderer/Shader.h | 289 ------------ 2 files changed, 1189 deletions(-) delete mode 100644 Source/Renderer/Shader.cpp delete mode 100644 Source/Renderer/Shader.h diff --git a/Source/Renderer/Shader.cpp b/Source/Renderer/Shader.cpp deleted file mode 100644 index f1e9ccd6..00000000 --- a/Source/Renderer/Shader.cpp +++ /dev/null @@ -1,900 +0,0 @@ -// VQEngine | DirectX11 Renderer -// Copyright(C) 2018 - Volkan Ilbeyli -// -// This program is free software : you can redistribute it and / or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// This program is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with this program.If not, see . -// -// Contact: volkanilbeyli@gmail.com - -#include "Shader.h" -#include "Renderer.h" - -#if 0 -#include "Utilities/Log.h" -#include "Utilities/utils.h" -#include "Utilities/PerfTimer.h" -#include "Application/Application.h" - -#include -#include -#include -#include - -//------------------------------------------------------------------------------------------------------------- -// CONSTANTS & STATICS -//------------------------------------------------------------------------------------------------------------- -static const std::unordered_map SHADER_COMPILER_VERSION_LOOKUP = -{ - { EShaderStage::VS, "vs_5_0" }, - { EShaderStage::GS, "gs_5_0" }, - { EShaderStage::DS, "ds_5_0" }, - { EShaderStage::HS, "hs_5_0" }, - { EShaderStage::PS, "ps_5_0" }, - { EShaderStage::CS, "cs_5_0" }, -}; -static const std::unordered_map SHADER_ENTRY_POINT_LOOKUP = -{ - { EShaderStage::VS, "VSMain" }, - { EShaderStage::GS, "GSMain" }, - { EShaderStage::DS, "DSMain" }, - { EShaderStage::HS, "HSMain" }, - { EShaderStage::PS, "PSMain" }, - { EShaderStage::CS, "CSMain" }, -}; - -ID3DInclude* const SHADER_INCLUDE_HANDLER = D3D_COMPILE_STANDARD_FILE_INCLUDE; // use default include handler for using #include in shader files - -#if defined( _DEBUG ) || defined ( FORCE_DEBUG ) -const UINT SHADER_COMPILE_FLAGS = D3DCOMPILE_ENABLE_STRICTNESS | D3DCOMPILE_DEBUG | D3DCOMPILE_SKIP_OPTIMIZATION; -#else -const UINT SHADER_COMPILE_FLAGS = D3DCOMPILE_ENABLE_STRICTNESS; -#endif - - - -#ifdef _WIN64 -#define CALLING_CONVENTION __cdecl -#else // _WIN32 -#define CALLING_CONVENTION __stdcall -#endif - -static void(CALLING_CONVENTION ID3D11DeviceContext:: *SetShaderConstants[EShaderStage::COUNT]) -(UINT StartSlot, UINT NumBuffers, ID3D11Buffer *const *ppConstantBuffers) = -{ - &ID3D11DeviceContext::VSSetConstantBuffers, - &ID3D11DeviceContext::GSSetConstantBuffers, - &ID3D11DeviceContext::DSSetConstantBuffers, - &ID3D11DeviceContext::HSSetConstantBuffers, - &ID3D11DeviceContext::PSSetConstantBuffers, - &ID3D11DeviceContext::CSSetConstantBuffers, -}; - -static std::unordered_map s_ShaderTypeStrLookup = -{ - {"vs", EShaderStage::VS}, - {"gs", EShaderStage::GS}, - {"ds", EShaderStage::DS}, - {"hs", EShaderStage::HS}, - {"cs", EShaderStage::CS}, - {"ps", EShaderStage::PS} -}; - - -//------------------------------------------------------------------------------------------------------------- -// STATIC FUNCTIONS -//------------------------------------------------------------------------------------------------------------- -std::string GetCompileError(ID3D10Blob*& errorMessage, const std::string& shdPath) -{ - if (errorMessage) - { - char* compileErrors = (char*)errorMessage->GetBufferPointer(); - size_t bufferSize = errorMessage->GetBufferSize(); - - std::stringstream ss; - for (unsigned int i = 0; i < bufferSize; ++i) - { - ss << compileErrors[i]; - } - errorMessage->Release(); - return ss.str(); - } - else - { - Log::Error(shdPath); - return ("Error: " + shdPath); - } -} - -static std::string GetIncludeFileName(const std::string& line) -{ - const std::string str_search = "#include \""; - const size_t foundPos = line.find(str_search); - if (foundPos != std::string::npos) - { - std::string quotedFileName = line.substr(foundPos + strlen("#include "), line.size() - foundPos);// +str_search.size() - 1); - return quotedFileName.substr(1, quotedFileName.size() - 2); - } - return std::string(); -} - -static bool AreIncludesDirty(const std::string& srcPath, const std::string& cachePath) -{ - - const std::string ShaderSourceDir = DirectoryUtil::GetFolderPath(srcPath); - const std::string ShaderCacheDir = DirectoryUtil::GetFolderPath(cachePath); - - std::stack includeStack; - includeStack.push(srcPath); - while (!includeStack.empty()) - { - const std::string includeFilePath = includeStack.top(); - includeStack.pop(); - std::ifstream src = std::ifstream(includeFilePath.c_str()); - if (!src.good()) - { - Log::Error("[ShaderCompile] Cannot open source file: %s", includeFilePath.c_str()); - continue; - } - - std::string line; - while (getline(src, line)) - { - const std::string includeFileName = GetIncludeFileName(line); - if (includeFileName.empty()) continue; - - const std::string includeSourcePath = ShaderSourceDir + includeFileName; - const std::string includeCachePath = ShaderCacheDir + includeFileName; - - if (DirectoryUtil::IsFileNewer(includeSourcePath, cachePath)) - return true; - includeStack.push(includeSourcePath); - } - src.close(); - } - return false; -} - -bool IsCacheDirty(const std::string& sourcePath, const std::string& cachePath) -{ - if (!DirectoryUtil::FileExists(cachePath)) return true; - - return DirectoryUtil::IsFileNewer(sourcePath, cachePath) || AreIncludesDirty(sourcePath, cachePath); -} - - -bool Shader::CompileFromSource(const std::string& pathToFile, const EShaderStage& type, ID3D10Blob *& ref_pBob, std::string& errMsg, const std::vector& macros) -{ - const StrUtil::UnicodeString Path = pathToFile; - const WCHAR* PathStr = Path.GetUnicodePtr(); - ID3D10Blob* errorMessage = nullptr; - - int i = 0; - std::vector d3dMacros(macros.size() + 1); - std::for_each(RANGE(macros), [&](const ShaderMacro& macro) - { - d3dMacros[i++] = D3D10_SHADER_MACRO({ macro.name.c_str(), macro.value.c_str() }); - }); - d3dMacros[i] = { NULL, NULL }; - - if (FAILED(D3DCompileFromFile( - PathStr, - d3dMacros.data(), - SHADER_INCLUDE_HANDLER, - SHADER_ENTRY_POINT_LOOKUP.at(type), - SHADER_COMPILER_VERSION_LOOKUP.at(type), - SHADER_COMPILE_FLAGS, - 0, - &ref_pBob, - &errorMessage))) - { - - errMsg = GetCompileError(errorMessage, pathToFile); - return false; - } - return true; -} - -ID3D10Blob * Shader::CompileFromCachedBinary(const std::string & cachedBinaryFilePath) -{ - std::ifstream cache(cachedBinaryFilePath, std::ios::in | std::ios::binary | std::ios::ate); - const size_t shaderBinarySize = cache.tellg(); - void* pBuffer = calloc(1, shaderBinarySize); - cache.seekg(0); - cache.read(reinterpret_cast(pBuffer), shaderBinarySize); - cache.close(); - - ID3D10Blob* pBlob = { nullptr }; - D3DCreateBlob(shaderBinarySize, &pBlob); - memcpy(pBlob->GetBufferPointer(), pBuffer, shaderBinarySize); - free(pBuffer); - - return pBlob; -} - -void Shader::CacheShaderBinary(const std::string& shaderCacheFileName, ID3D10Blob * pCompiledBinary) -{ - const size_t shaderBinarySize = pCompiledBinary->GetBufferSize(); - - char* pBuffer = reinterpret_cast(pCompiledBinary->GetBufferPointer()); - std::ofstream cache(shaderCacheFileName, std::ios::out | std::ios::binary); - cache.write(pBuffer, shaderBinarySize); - cache.close(); -} - -EShaderStage Shader::GetShaderTypeFromSourceFilePath(const std::string & shaderFilePath) -{ - const std::string sourceFileName = DirectoryUtil::GetFileNameWithoutExtension(shaderFilePath); - const std::string shaderTypeStr = { *(sourceFileName.rbegin() + 1), *sourceFileName.rbegin() }; - return s_ShaderTypeStrLookup.at(shaderTypeStr); -} - - -//------------------------------------------------------------------------------------------------------------- -// PUBLIC INTERFACE -//------------------------------------------------------------------------------------------------------------- -const std::vector& Shader::GetConstantBufferLayouts() const { return m_CBLayouts; } -const std::vector& Shader::GetConstantBuffers() const { return mConstantBuffers; } -const TextureBinding& Shader::GetTextureBinding(const std::string& textureName) const { return mTextureBindings[mShaderTextureLookup.at(textureName)]; } -const SamplerBinding& Shader::GetSamplerBinding(const std::string& samplerName) const { return mSamplerBindings[mShaderSamplerLookup.at(samplerName)]; } -bool Shader::HasTextureBinding(const std::string& textureName) const { return mShaderTextureLookup.find(textureName) != mShaderTextureLookup.end(); } -bool Shader::HasSamplerBinding(const std::string& samplerName) const { return mShaderSamplerLookup.find(samplerName) != mShaderSamplerLookup.end(); } - -Shader::Shader(const std::string& shaderFileName) - : mName(shaderFileName) - , mID(-1) -{} - -Shader::Shader(const ShaderDesc& desc) - : mName(desc.shaderName) - , mDescriptor(desc) - , mID(-1) -{} - -Shader::~Shader(void) -{ -#if _DEBUG - //Log::Info("Shader dtor: %s", m_name.c_str()); -#endif - - // todo: this really could use smart pointers... - - // release constants - ReleaseResources(); -} -void Shader::ReleaseResources() -{ - for (ConstantBufferBinding& cbuf : mConstantBuffers) - { - if (cbuf.data) - { - cbuf.data->Release(); - cbuf.data = nullptr; - } - } - mConstantBuffers.clear(); - - for (CPUConstant cbuf : mCPUConstantBuffers) - { - if (cbuf._data) - { - delete cbuf._data; - cbuf._data = nullptr; - } - } - mCPUConstantBuffers.clear(); - - - if (mpInputLayout) - { - mpInputLayout->Release(); - mpInputLayout = nullptr; - } - - if (mStages.mPixelShader) - { - mStages.mPixelShader->Release(); - mStages.mPixelShader = nullptr; - } - - if (mStages.mVertexShader) - { - mStages.mVertexShader->Release(); - mStages.mVertexShader = nullptr; - } - - if (mStages.mComputeShader) - { - mStages.mComputeShader->Release(); - mStages.mComputeShader = nullptr; - } - - if (mStages.mGeometryShader) - { - mStages.mGeometryShader->Release(); - mStages.mGeometryShader = nullptr; - } - - for (unsigned type = EShaderStage::VS; type < EShaderStage::COUNT; ++type) - { - if (mReflections.of[type]) - { - mReflections.of[type]->Release(); - mReflections.of[type] = nullptr; - } - } - - m_CBLayouts.clear(); - m_constants.clear(); - mTextureBindings.clear(); - mSamplerBindings.clear(); - mShaderTextureLookup.clear(); - mShaderSamplerLookup.clear(); -} - - - - -size_t Shader::GeneratePreprocessorDefinitionsHash(const std::vector& macros) const -{ - if (macros.empty()) return 0; - std::string concatenatedMacros; - for (const ShaderMacro& macro : macros) - concatenatedMacros += macro.name + macro.value; - return std::hash()(concatenatedMacros); -} - -bool Shader::Reload(ID3D11Device* device) -{ - Shader copy(this->mDescriptor); - copy.mID = this->mID; - ReleaseResources(); - this->mID = copy.mID; - return CompileShaders(device, copy.mDescriptor); -} - -bool Shader::HasSourceFileBeenUpdated() const -{ - bool bUpdated = false; - for (EShaderStage stage = EShaderStage::VS; stage < EShaderStage::COUNT; stage = (EShaderStage)(stage + 1)) - { - if (mDirectories.find(stage) != mDirectories.end()) - { - const std::string& path = mDirectories.at(stage).fullPath; - const std::string& cachePath = mDirectories.at(stage).cachePath; - bUpdated |= mDirectories.at(stage).lastWriteTime < std::experimental::filesystem::last_write_time(path); - - if (!bUpdated) // check include files only when source is not updated - { - bUpdated |= AreIncludesDirty(path, cachePath); - } - } - } - return bUpdated; -} - -void Shader::ClearConstantBuffers() -{ - for (ConstantBufferBinding& cBuffer : mConstantBuffers) - { - cBuffer.dirty = true; - } -} - -void Shader::UpdateConstants(ID3D11DeviceContext* context) -{ - for (unsigned i = 0; i < mConstantBuffers.size(); ++i) - { - ConstantBufferBinding& CB = mConstantBuffers[i]; - if (CB.dirty) // if the CPU-side buffer is updated - { - ID3D11Buffer* data = CB.data; - D3D11_MAPPED_SUBRESOURCE mappedResource; - - // Map sub-resource to GPU - update contents - discard the sub-resource - context->Map(data, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); - char* bufferPos = static_cast(mappedResource.pData); // char* so we can advance the pointer - for (const ConstantBufferMapping& indexIDPair : m_constants) - { - if (indexIDPair.first != i) - { - continue; - } - - const int slotIndex = indexIDPair.first; - const CPUConstantID c_id = indexIDPair.second; - assert(c_id < mCPUConstantBuffers.size()); - CPUConstant& c = mCPUConstantBuffers[c_id]; - memcpy(bufferPos, c._data, c._size); - bufferPos += c._size; - } - context->Unmap(data, 0); - - // TODO: research update sub-resource (Setting constant buffer can be done once in setting the shader) - - // call XSSetConstantBuffers() from array using ShaderType enum - (context->*SetShaderConstants[CB.shaderStage])(CB.bufferSlot, 1, &data); - CB.dirty = false; - } - } -} - - - - -//------------------------------------------------------------------------------------------------------------- -// UTILITY FUNCTIONS -//------------------------------------------------------------------------------------------------------------- -bool Shader::CompileShaders(ID3D11Device* device, const ShaderDesc& desc) -{ - constexpr const char * SHADER_BINARY_EXTENSION = ".bin"; - mDescriptor = desc; - HRESULT result; - ShaderBlobs blobs; - bool bPrinted = false; - - PerfTimer timer; - timer.Start(); - - // COMPILE SHADER STAGES - //---------------------------------------------------------------------------- - for (const ShaderStageDesc& stageDesc : desc.stages) - { - if (stageDesc.fileName.empty()) - continue; - - // stage.macros - const std::string sourceFilePath = std::string(Renderer::sShaderRoot + stageDesc.fileName); - - const EShaderStage stage = GetShaderTypeFromSourceFilePath(sourceFilePath); - - // USE SHADER CACHE - // - const size_t ShaderHash = GeneratePreprocessorDefinitionsHash(stageDesc.macros); - const std::string cacheFileName = stageDesc.macros.empty() - ? DirectoryUtil::GetFileNameFromPath(sourceFilePath) + SHADER_BINARY_EXTENSION - : DirectoryUtil::GetFileNameFromPath(sourceFilePath) + "_" + std::to_string(ShaderHash) + SHADER_BINARY_EXTENSION; - const std::string cacheFilePath = Application::s_ShaderCacheDirectory + "\\" + cacheFileName; - const bool bUseCachedShaders = - DirectoryUtil::FileExists(cacheFilePath) - && !IsCacheDirty(sourceFilePath, cacheFilePath); - //--------------------------------------------------------------------------------- - if (!bPrinted) // quick status print here - { - const char* pMsgLoad = bUseCachedShaders ? "Loading cached shader binaries" : "Compiling shader from source"; - Log::Info("\t%s %s...", pMsgLoad, mName.c_str()); - bPrinted = true; - } - //--------------------------------------------------------------------------------- - if (bUseCachedShaders) - { - blobs.of[stage] = CompileFromCachedBinary(cacheFilePath); - } - else - { - std::string errMsg; - ID3D10Blob* pBlob; - if (CompileFromSource(sourceFilePath, stage, pBlob, errMsg, stageDesc.macros)) - { - blobs.of[stage] = pBlob; - CacheShaderBinary(cacheFilePath, blobs.of[stage]); - } - else - { - Log::Error(errMsg); - return false; - } - } - - CreateShaderStage(device, stage, blobs.of[stage]->GetBufferPointer(), blobs.of[stage]->GetBufferSize()); - SetReflections(blobs); - //CheckSignatures(); - - mDirectories[stage] = ShaderLoadDesc(sourceFilePath, cacheFilePath); - } - - // INPUT LAYOUT (VS) - //--------------------------------------------------------------------------- - // src: https://stackoverflow.com/questions/42388979/directx-11-vertex-shader-reflection - // setup the layout of the data that goes into the shader - // - if(mReflections.vsRefl) - { - - D3D11_SHADER_DESC shaderDesc = {}; - mReflections.vsRefl->GetDesc(&shaderDesc); - std::vector inputLayout(shaderDesc.InputParameters); - - D3D_PRIMITIVE primitiveDesc = shaderDesc.InputPrimitive; - - for (unsigned i = 0; i < shaderDesc.InputParameters; ++i) - { - D3D11_SIGNATURE_PARAMETER_DESC paramDesc; - mReflections.vsRefl->GetInputParameterDesc(i, ¶mDesc); - - // fill out input element desc - D3D11_INPUT_ELEMENT_DESC elementDesc; - elementDesc.SemanticName = paramDesc.SemanticName; - elementDesc.SemanticIndex = paramDesc.SemanticIndex; - elementDesc.InputSlot = 0; - elementDesc.AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT; - elementDesc.InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA; - elementDesc.InstanceDataStepRate = 0; - - // determine DXGI format - if (paramDesc.Mask == 1) - { - if (paramDesc.ComponentType == D3D_REGISTER_COMPONENT_UINT32) elementDesc.Format = DXGI_FORMAT_R32_UINT; - else if (paramDesc.ComponentType == D3D_REGISTER_COMPONENT_SINT32) elementDesc.Format = DXGI_FORMAT_R32_SINT; - else if (paramDesc.ComponentType == D3D_REGISTER_COMPONENT_FLOAT32) elementDesc.Format = DXGI_FORMAT_R32_FLOAT; - } - else if (paramDesc.Mask <= 3) - { - if (paramDesc.ComponentType == D3D_REGISTER_COMPONENT_UINT32) elementDesc.Format = DXGI_FORMAT_R32G32_UINT; - else if (paramDesc.ComponentType == D3D_REGISTER_COMPONENT_SINT32) elementDesc.Format = DXGI_FORMAT_R32G32_SINT; - else if (paramDesc.ComponentType == D3D_REGISTER_COMPONENT_FLOAT32) elementDesc.Format = DXGI_FORMAT_R32G32_FLOAT; - } - else if (paramDesc.Mask <= 7) - { - if (paramDesc.ComponentType == D3D_REGISTER_COMPONENT_UINT32) elementDesc.Format = DXGI_FORMAT_R32G32B32_UINT; - else if (paramDesc.ComponentType == D3D_REGISTER_COMPONENT_SINT32) elementDesc.Format = DXGI_FORMAT_R32G32B32_SINT; - else if (paramDesc.ComponentType == D3D_REGISTER_COMPONENT_FLOAT32) elementDesc.Format = DXGI_FORMAT_R32G32B32_FLOAT; - } - else if (paramDesc.Mask <= 15) - { - if (paramDesc.ComponentType == D3D_REGISTER_COMPONENT_UINT32) elementDesc.Format = DXGI_FORMAT_R32G32B32A32_UINT; - else if (paramDesc.ComponentType == D3D_REGISTER_COMPONENT_SINT32) elementDesc.Format = DXGI_FORMAT_R32G32B32A32_SINT; - else if (paramDesc.ComponentType == D3D_REGISTER_COMPONENT_FLOAT32) elementDesc.Format = DXGI_FORMAT_R32G32B32A32_FLOAT; - } - - inputLayout[i] = elementDesc; //save element desc - } - - // Try to create Input Layout - const auto* pData = inputLayout.data(); - if (pData) - { - result = device->CreateInputLayout( - pData, - shaderDesc.InputParameters, - blobs.vs->GetBufferPointer(), - blobs.vs->GetBufferSize(), - &mpInputLayout); - - if (FAILED(result)) - { - OutputDebugString("Error creating input layout"); - return false; - } - } - } - - // CONSTANT BUFFERS - //--------------------------------------------------------------------------- - // Obtain cbuffer layout information - for (EShaderStage type = EShaderStage::VS; type < EShaderStage::COUNT; type = (EShaderStage)(type + 1)) - { - if (mReflections.of[type]) - { - ReflectConstantBufferLayouts(mReflections.of[type], type); - } - } - - // Create CPU & GPU constant buffers - // CPU CBuffers - int constantBufferSlot = 0; - for (const ConstantBufferLayout& cbLayout : m_CBLayouts) - { - std::vector cpuBuffers; - for (D3D11_SHADER_VARIABLE_DESC varDesc : cbLayout.variables) - { - CPUConstant c; - CPUConstantID c_id = static_cast(mCPUConstantBuffers.size()); - - c._name = varDesc.Name; - c._size = varDesc.Size; - c._data = new char[c._size]; - memset(c._data, 0, c._size); - m_constants.push_back(std::make_pair(constantBufferSlot, c_id)); - mCPUConstantBuffers.push_back(c); - } - ++constantBufferSlot; - } - - // GPU CBuffers - D3D11_BUFFER_DESC cBufferDesc; - cBufferDesc.Usage = D3D11_USAGE_DYNAMIC; - cBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; - cBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; - cBufferDesc.MiscFlags = 0; - cBufferDesc.StructureByteStride = 0; - for (const ConstantBufferLayout& cbLayout : m_CBLayouts) - { - ConstantBufferBinding cBuffer; - cBufferDesc.ByteWidth = cbLayout.desc.Size; - if (FAILED(device->CreateBuffer(&cBufferDesc, NULL, &cBuffer.data))) - { - OutputDebugString("Error creating constant buffer"); - return false; - } - cBuffer.dirty = true; - cBuffer.shaderStage = cbLayout.stage; - cBuffer.bufferSlot = cbLayout.bufSlot; - mConstantBuffers.push_back(cBuffer); - } - - - // TEXTURES & SAMPLERS - //--------------------------------------------------------------------------- - for (int shaderStage = 0; shaderStage < EShaderStage::COUNT; ++shaderStage) - { - unsigned texSlot = 0; unsigned smpSlot = 0; - unsigned uavSlot = 0; - auto& sRefl = mReflections.of[shaderStage]; - if (sRefl) - { - D3D11_SHADER_DESC desc = {}; - sRefl->GetDesc(&desc); - - for (unsigned i = 0; i < desc.BoundResources; ++i) - { - D3D11_SHADER_INPUT_BIND_DESC shdInpDesc; - sRefl->GetResourceBindingDesc(i, &shdInpDesc); - - switch (shdInpDesc.Type) - { - case D3D_SIT_SAMPLER: - { - SamplerBinding smp; - smp.shaderStage = static_cast(shaderStage); - smp.samplerSlot = smpSlot++; - mSamplerBindings.push_back(smp); - mShaderSamplerLookup[shdInpDesc.Name] = static_cast(mSamplerBindings.size() - 1); - } break; - - case D3D_SIT_TEXTURE: - { - TextureBinding tex; - tex.shaderStage = static_cast(shaderStage); - tex.textureSlot = texSlot++; - mTextureBindings.push_back(tex); - mShaderTextureLookup[shdInpDesc.Name] = static_cast(mTextureBindings.size() - 1); - } break; - - case D3D_SIT_UAV_RWTYPED: - { - TextureBinding tex; - tex.shaderStage = static_cast(shaderStage); - tex.textureSlot = uavSlot++; - mTextureBindings.push_back(tex); - mShaderTextureLookup[shdInpDesc.Name] = static_cast(mTextureBindings.size() - 1); - } break; - - case D3D_SIT_CBUFFER: break; - - - default: - Log::Warning("Unhandled shader input bind type in shader reflection"); - break; - - } // switch shader input type - } // bound resource - } // sRefl - } // shaderStage - - // release blobs - for (unsigned type = EShaderStage::VS; type < EShaderStage::COUNT; ++type) - { - if (blobs.of[type]) - blobs.of[type]->Release(); - } - - return true; -} - -void Shader::CreateShaderStage(ID3D11Device* pDevice, EShaderStage stage, void* pBuffer, const size_t szShaderBinary) -{ - HRESULT result = {}; - const char* msg = ""; - switch (stage) - { - case EShaderStage::VS: - if (FAILED(pDevice->CreateVertexShader(pBuffer, szShaderBinary, NULL, &mStages.mVertexShader))) - { - msg = "Error creating vertex shader program"; - } - break; - case EShaderStage::PS: - if (FAILED(pDevice->CreatePixelShader(pBuffer, szShaderBinary, NULL, &mStages.mPixelShader))) - { - msg = "Error creating pixel shader program"; - } - break; - case EShaderStage::GS: - if (FAILED(pDevice->CreateGeometryShader(pBuffer, szShaderBinary, NULL, &mStages.mGeometryShader))) - { - msg = "Error creating pixel geometry program"; - } - break; - case EShaderStage::CS: - if (FAILED(pDevice->CreateComputeShader(pBuffer, szShaderBinary, NULL, &mStages.mComputeShader))) - { - msg = "Error creating compute shader program"; - } - break; - } - - if (FAILED(result)) - { - OutputDebugString(msg); - assert(false); - } -} - -void Shader::SetReflections(const ShaderBlobs& blobs) -{ - for(unsigned type = EShaderStage::VS; type < EShaderStage::COUNT; ++type) - { - if (blobs.of[type]) - { - void** ppBuffer = reinterpret_cast(&this->mReflections.of[type]); - if (FAILED(D3DReflect(blobs.of[type]->GetBufferPointer(), blobs.of[type]->GetBufferSize(), IID_ID3D11ShaderReflection, ppBuffer))) - { - Log::Error("Cannot get vertex shader reflection"); - assert(false); - } - } - } -} - -void Shader::CheckSignatures() -{ -#if 0 - // get shader description --> input/output parameters - std::vector VSISignDescs, VSOSignDescs, PSISignDescs, PSOSignDescs; - D3D11_SHADER_DESC VSDesc; - m_vsRefl->GetDesc(&VSDesc); - for (unsigned i = 0; i < VSDesc.InputParameters; ++i) - { - D3D11_SIGNATURE_PARAMETER_DESC input_desc; - m_vsRefl->GetInputParameterDesc(i, &input_desc); - VSISignDescs.push_back(input_desc); - } - - for (unsigned i = 0; i < VSDesc.OutputParameters; ++i) - { - D3D11_SIGNATURE_PARAMETER_DESC output_desc; - m_vsRefl->GetInputParameterDesc(i, &output_desc); - VSOSignDescs.push_back(output_desc); - } - - - D3D11_SHADER_DESC PSDesc; - m_psRefl->GetDesc(&PSDesc); - for (unsigned i = 0; i < PSDesc.InputParameters; ++i) - { - D3D11_SIGNATURE_PARAMETER_DESC input_desc; - m_psRefl->GetInputParameterDesc(i, &input_desc); - PSISignDescs.push_back(input_desc); - } - - for (unsigned i = 0; i < PSDesc.OutputParameters; ++i) - { - D3D11_SIGNATURE_PARAMETER_DESC output_desc; - m_psRefl->GetInputParameterDesc(i, &output_desc); - PSOSignDescs.push_back(output_desc); - } - - // check VS-PS signature compatibility | wont be necessary when its 1 file. - // THIS IS TEMPORARY - if (VSOSignDescs.size() != PSISignDescs.size()) - { - OutputDebugString("Error: Incompatible shader input/output signatures (sizes don't match)\n"); - assert(false); - } - else - { - for (size_t i = 0; i < VSOSignDescs.size(); ++i) - { - // TODO: order matters, semantic slot doesn't. check order - ; - } - } -#endif - assert(false); // todo: refactor this -} - - -void Shader::LogConstantBufferLayouts() const -{ - char inputTable[2048]; - sprintf_s(inputTable, "\n%s ConstantBuffers: -----\n", this->mName.c_str()); - std::for_each(m_constants.begin(), m_constants.end(), [&](const ConstantBufferMapping& cMapping) { - char entry[32]; - sprintf_s(entry, "(%d, %d)\t- %s\n", cMapping.first, cMapping.second, mCPUConstantBuffers[cMapping.second]._name.c_str()); - strcat_s(inputTable, entry); - }); - strcat_s(inputTable, "-----\n"); - Log::Info(std::string(inputTable)); -} - -void Shader::ReflectConstantBufferLayouts(ID3D11ShaderReflection* sRefl, EShaderStage type) -{ - D3D11_SHADER_DESC desc; - sRefl->GetDesc(&desc); - - unsigned bufSlot = 0; - for (unsigned i = 0; i < desc.ConstantBuffers; ++i) - { - ConstantBufferLayout bufferLayout; - bufferLayout.buffSize = 0; - ID3D11ShaderReflectionConstantBuffer* pCBuffer = sRefl->GetConstantBufferByIndex(i); - pCBuffer->GetDesc(&bufferLayout.desc); - - // load desc of each variable for binding on buffer later on - for (unsigned j = 0; j < bufferLayout.desc.Variables; ++j) - { - // get variable and type descriptions - ID3D11ShaderReflectionVariable* pVariable = pCBuffer->GetVariableByIndex(j); - D3D11_SHADER_VARIABLE_DESC varDesc; - pVariable->GetDesc(&varDesc); - bufferLayout.variables.push_back(varDesc); - - ID3D11ShaderReflectionType* pType = pVariable->GetType(); - D3D11_SHADER_TYPE_DESC typeDesc; - pType->GetDesc(&typeDesc); - bufferLayout.types.push_back(typeDesc); - - // accumulate buffer size - bufferLayout.buffSize += varDesc.Size; - } - bufferLayout.stage = type; - bufferLayout.bufSlot = bufSlot; - ++bufSlot; - m_CBLayouts.push_back(bufferLayout); - } -} - - - -std::array ShaderDesc::CreateStageDescsFromShaderName(const char* pShaderName, unsigned flagStages) -{ - const std::string shaderName = pShaderName; - std::array descs; - int idx = 0; - if (flagStages & SHADER_STAGE_VS) - { - descs[idx++] = ShaderStageDesc{ shaderName + "_vs.hlsl", {} }; - } - if (flagStages & SHADER_STAGE_GS) - { - descs[idx++] = ShaderStageDesc{ shaderName + "_gs.hlsl", {} }; - } - if (flagStages & SHADER_STAGE_DS) - { - descs[idx++] = ShaderStageDesc{ shaderName + "_ds.hlsl", {} }; - } - if (flagStages & SHADER_STAGE_HS) - { - descs[idx++] = ShaderStageDesc{ shaderName + "_hs.hlsl", {} }; - } - if (flagStages & SHADER_STAGE_PS) - { - descs[idx++] = ShaderStageDesc{ shaderName + "_ps.hlsl", {} }; - } - if (flagStages & SHADER_STAGE_CS) - { - descs[idx++] = ShaderStageDesc{ shaderName + "_cs.hlsl", {} }; - } - return descs; -} -#endif \ No newline at end of file diff --git a/Source/Renderer/Shader.h b/Source/Renderer/Shader.h deleted file mode 100644 index 20c24d10..00000000 --- a/Source/Renderer/Shader.h +++ /dev/null @@ -1,289 +0,0 @@ -// VQEngine | DirectX11 Renderer -// Copyright(C) 2018 - Volkan Ilbeyli -// -// This program is free software : you can redistribute it and / or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, either version 3 of the License, or -// (at your option) any later version. -// -// This program is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the -// GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License -// along with this program.If not, see . -// -// Contact: volkanilbeyli@gmail.com - -#pragma once - -#include "../Application/Types.h" - -#include - -#include -#include -#include -#include -#include -#include - - -enum EShaderStageFlags : unsigned -{ - SHADER_STAGE_NONE = 0x00000000, - SHADER_STAGE_VS = 0x00000001, - SHADER_STAGE_GS = 0x00000002, - SHADER_STAGE_DS = 0x00000004, - SHADER_STAGE_HS = 0x00000008, - SHADER_STAGE_PS = 0x00000010, - SHADER_STAGE_ALL_GRAPHICS = 0X0000001F, - SHADER_STAGE_CS = 0x00000020, - - SHADER_STAGE_COUNT = 6 -}; -enum EShaderStage : unsigned // array-index enum mapping -{ // used to map **SetShaderConstant(); function in Renderer::Apply() - VS = 0, - GS, - DS, - HS, - PS, - CS, - - NUM_SHADER_STAGES -}; - -#if 0 -enum ELayoutFormat -{ - FLOAT32_2 = DXGI_FORMAT_R32G32_FLOAT, - FLOAT32_3 = DXGI_FORMAT_R32G32B32_FLOAT, - FLOAT32_4 = DXGI_FORMAT_R32G32B32A32_FLOAT, - - LAYOUT_FORMAT_COUNT -}; -using CPUConstantID = int; -using GPU_ConstantBufferSlotIndex = int; -using ConstantBufferMapping = std::pair; -//using FileTimeStamp = std::experimental::filesystem::file_time_type; - -//---------------------------------------------------------------------------------------------------------------- -// SHADER DATA/RESOURCE INTERFACE STRUCTS -//---------------------------------------------------------------------------------------------------------------- -struct ConstantBufferBinding -{ - EShaderStage shaderStage; - unsigned bufferSlot; - //ID3D12Buffer* data; - //bool dirty; -}; -struct TextureBinding -{ - EShaderStage shaderStage; - unsigned textureSlot; -}; -struct SamplerBinding -{ - EShaderStage shaderStage; - unsigned samplerSlot; - std::string name; // TODO: move this out -}; -struct InputLayout -{ - std::string semanticName; - ELayoutFormat format; -}; - - -struct ShaderMacro -{ - std::string name; - std::string value; -}; - -struct ShaderStageDesc -{ - std::string fileName; - std::vector macros; -}; - -struct ShaderDesc -{ - using ShaderStageArr = std::array; - static ShaderStageArr CreateStageDescsFromShaderName(const char* shaderName, unsigned flagStages); - - std::string shaderName; - std::array stages; -}; - -struct ShaderLoadDesc -{ - ShaderLoadDesc() = default; - ShaderLoadDesc(const std::string& path, const std::string& cachePath_); - // : fullPath(path), cachePath(cachePath_) - //{ - // this->lastWriteTime = std::experimental::filesystem::last_write_time(fullPath); - // this->cacheLastWriteTime = std::experimental::filesystem::last_write_time(cachePath); - //} - std::string fullPath; - std::string cachePath; - FileTimeStamp lastWriteTime; - FileTimeStamp cacheLastWriteTime; -}; - - -class Shader -{ - friend class Renderer; - - using ShaderArray = std::array; - using ShaderTextureLookup = std::unordered_map; - using ShaderSamplerLookup = std::unordered_map; - using ShaderDirectoryLookup = std::unordered_map; - -public: - // STRUCTS/ENUMS - // - // Current limitations for Constant Buffers: - // - cbuffers with same names in different shaders (PS/VS/GS/...) - // - cbuffers with same names in the same shader (not tested) - //---------------------------------------------------------------------------------------------------------------- - union ShaderBlobs - { - struct - { - ID3D10Blob* vs; - ID3D10Blob* gs; - ID3D10Blob* ds; - ID3D10Blob* hs; - ID3D10Blob* ps; - ID3D10Blob* cs; - }; - ID3D10Blob* of[EShaderStage::NUM_SHADER_STAGES] = { nullptr }; - }; - union ShaderReflections - { - struct - { - ID3D12ShaderReflection* vsRefl; - ID3D12ShaderReflection* gsRefl; - ID3D12ShaderReflection* dsRefl; - ID3D12ShaderReflection* hsRefl; - ID3D12ShaderReflection* psRefl; - ID3D12ShaderReflection* csRefl; - }; - ID3D12ShaderReflection* of[EShaderStage::NUM_SHADER_STAGES] = { nullptr }; - }; - struct ConstantBufferLayout - { // information used to create GPU/CPU constant buffers - D3D11_SHADER_BUFFER_DESC desc; - std::vector variables; - std::vector types; - unsigned buffSize; - EShaderStage stage; - unsigned bufSlot; - }; - struct ShaderStages - { - ID3D12VertexShader* mVertexShader = nullptr; - ID3D12PixelShader* mPixelShader = nullptr; - ID3D12GeometryShader* mGeometryShader = nullptr; - ID3D12HullShader* mHullShader = nullptr; - ID3D12DomainShader* mDomainShader = nullptr; - ID3D12ComputeShader* mComputeShader = nullptr; - }; - -public: - //---------------------------------------------------------------------------------------------------------------- - // MEMBER INTERFACE - //---------------------------------------------------------------------------------------------------------------- - Shader(const ShaderDesc& desc); - Shader(const std::string& shaderFileName); - ~Shader(); - - bool Reload(ID3D12Device* device); - void ClearConstantBuffers(); - //void UpdateConstants(ID3D12DeviceContext* context); - - //---------------------------------------------------------------------------------------------------------------- - // GETTERS - //---------------------------------------------------------------------------------------------------------------- - const std::string& Name() const { return mName; } - inline ShaderID ID() const { return mID; } - - const std::vector& GetConstantBufferLayouts() const; - const std::vector& GetConstantBuffers() const; - - const TextureBinding& GetTextureBinding(const std::string& textureName) const; - const SamplerBinding& GetSamplerBinding(const std::string& samplerName) const; - bool HasTextureBinding(const std::string& textureName) const; - bool HasSamplerBinding(const std::string& samplerName) const; - - bool HasSourceFileBeenUpdated() const; - -private: - //---------------------------------------------------------------------------------------------------------------- - // STATIC PRIVATE INTERFACE - //---------------------------------------------------------------------------------------------------------------- - // Compiles shader from source file with the given shader macros - // - static bool CompileFromSource( - const std::string& pathToFile - , const EShaderStage& type - , ID3D10Blob *& ref_pBob - , std::string& outErrMsg - , const std::vector& macros); - - // Reads in cached binary from %APPDATA%/VQEngine/ShaderCache folder into ID3D10Blob - // - static ID3D10Blob * CompileFromCachedBinary(const std::string& cachedBinaryFilePath); - - // Writes out compiled ID3D10Blob into %APPDATA%/VQEngine/ShaderCache folder - // - static void CacheShaderBinary(const std::string& shaderCacheFileName, ID3D10Blob * pCompiledBinary); - - // example filePath: "rootPath/filename_vs.hlsl" - // ^^----- shaderTypeString - static EShaderStage GetShaderTypeFromSourceFilePath(const std::string& shaderFilePath); - - //---------------------------------------------------------------------------------------------------------------- - // UTILITY FUNCTIONS - //---------------------------------------------------------------------------------------------------------------- - void ReflectConstantBufferLayouts(ID3D12ShaderReflection * sRefl, EShaderStage type); - bool CompileShaders(ID3D12Device* device, const ShaderDesc& desc); - void SetReflections(const ShaderBlobs& blobs); - void CreateShaderStage(ID3D12Device* pDevice, EShaderStage stage, void* pBuffer, const size_t szShaderBinary); - void CheckSignatures(); - void LogConstantBufferLayouts() const; - void ReleaseResources(); - size_t GeneratePreprocessorDefinitionsHash(const std::vector& macros) const; - -private: - //---------------------------------------------------------------------------------------------------------------- - // DATA - //---------------------------------------------------------------------------------------------------------------- - ShaderID mID; - ShaderStages mStages; - - ShaderReflections mReflections; // shader reflections, temporary? - //ID3D12InputLayout* mpInputLayout = nullptr; - - std::string mName; - - std::vector mConstantBuffers; // https://msdn.microsoft.com/en-us/library/windows/desktop/bb509581(v=vs.85).aspx - std::vector m_CBLayouts; - std::vector m_constants;// currently redundant - //std::vector mCPUConstantBuffers; - - std::vector mTextureBindings; - std::vector mSamplerBindings; - - ShaderTextureLookup mShaderTextureLookup; - ShaderSamplerLookup mShaderSamplerLookup; - - ShaderDesc mDescriptor; // used for shader reloading - ShaderDirectoryLookup mDirectories; -}; -#endif \ No newline at end of file From 7e90165c5738894c4ecb775a7ae8cacb4e507cc6 Mon Sep 17 00:00:00 2001 From: Volkan Date: Mon, 14 Sep 2020 20:15:45 -0700 Subject: [PATCH 60/67] Update readme screenshot (Add gif) + update CMakelists to move assimp to Libs and VQ code outside Libs --- CMakeLists.txt | 17 +++++++++-------- README.md | 17 ++++++++++++++++- 2 files changed, 25 insertions(+), 9 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index a44f0596..417366de 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -157,14 +157,15 @@ endforeach( OUTPUTCONFIG CMAKE_CONFIGURATION_TYPES ) set_property(TARGET ${PROJECT_NAME} PROPERTY CXX_STANDARD 17) set_property(GLOBAL PROPERTY USE_FOLDERS ON) -set_target_properties(assimp PROPERTIES FOLDER assimp) -set_target_properties(IrrXML PROPERTIES FOLDER assimp) -set_target_properties(uninstall PROPERTIES FOLDER assimp) -set_target_properties(UpdateAssimpLibsDebugSymbolsAndDLLs PROPERTIES FOLDER assimp) -set_target_properties(zlibstatic PROPERTIES FOLDER assimp) - -set_target_properties(VQRenderer PROPERTIES FOLDER Libs) -set_target_properties(VQUtils PROPERTIES FOLDER Libs) + +set_target_properties(assimp PROPERTIES FOLDER Libs/assimp) +set_target_properties(IrrXML PROPERTIES FOLDER Libs/assimp) +set_target_properties(uninstall PROPERTIES FOLDER Libs/assimp) +set_target_properties(UpdateAssimpLibsDebugSymbolsAndDLLs PROPERTIES FOLDER Libs/assimp) +set_target_properties(zlibstatic PROPERTIES FOLDER Libs/assimp) + +#set_target_properties(VQRenderer PROPERTIES FOLDER Libs) +#set_target_properties(VQUtils PROPERTIES FOLDER Libs) set_target_properties(D3D12MA PROPERTIES FOLDER Libs) # Make sure the compiler can find include files for the libraries diff --git a/README.md b/README.md index 9681a032..7558de91 100644 --- a/README.md +++ b/README.md @@ -9,6 +9,14 @@ VQE is **VQEngine**: A DX12 rewrite of [VQEngine-Vanilla](https://github.com/vil HDRI Environment Map Rendering

+ +![](https://im7.ezgif.com/tmp/ezgif-7-2e3c537ed34e.gif){: class="center"; } + + +

+Scenes & glTF Model Loading +

+ # Features - Multi-threaded architecture @@ -17,6 +25,7 @@ VQE is **VQEngine**: A DX12 rewrite of [VQEngine-Vanilla](https://github.com/vil - HDR Environment Maps from [HDRI Haven](https://hdrihaven.com/) - HDR display support ![](Screenshots/HDRDisplay.jpg) + - [glTF](https://en.wikipedia.org/wiki/GlTF) [2.0](https://github.com/KhronosGroup/glTF/tree/master/specification/2.0) model loading using [assimp](https://github.com/assimp/assimp) - Multiple windows on multiple monitors - Physically-based Rendering (WIP) - Real-time and offline Ray Tracing (WIP) @@ -52,7 +61,11 @@ Make sure to have installed - [Visual C++ 2019 Redistributiable (x64)](https://support.microsoft.com/en-us/help/2977003/the-latest-supported-visual-c-downloads) - A DX12-capable GPU -Run `VQE.exe`. +Double click `VQE.exe`. + +Or, if you're using a terminal, +- `VQE.exe -LogConsole` for logging displayed on a console +- `VQE.exe -LogFile="FileName.txt"` to write out to a file. ## Controls @@ -60,11 +73,13 @@ Run `VQE.exe`. | :--: | :-- | | **WASD+EQ** | Camera Movement | | **Page Up/Down** | Change Environment Map | +| **1-4** | Change Scenes
**1**: Environment Map Scene
**2**: Sponza
**3**: Geometry Test Scene
**4**: Stress Test Scene | | **V** | Toggle VSync | | **M** | Toggle MSAA | | **Alt+Enter** | Toggle Fullscreen | | **Spacebar** | Toggle Cube Animation | | **Mouse Buttons** | Rotate Cube | +| **Shift+R** | Reload level | | **Esc** | Release mouse | From 1d82663a38ce6e020fa6f933250df63d10bff698 Mon Sep 17 00:00:00 2001 From: Volkan Date: Mon, 14 Sep 2020 20:21:52 -0700 Subject: [PATCH 61/67] update readme: fix screenshot --- README.md | 15 ++++++--------- Screenshots/HelloModelLoading.png | Bin 0 -> 2405742 bytes 2 files changed, 6 insertions(+), 9 deletions(-) create mode 100644 Screenshots/HelloModelLoading.png diff --git a/README.md b/README.md index 7558de91..afeb578e 100644 --- a/README.md +++ b/README.md @@ -9,12 +9,10 @@ VQE is **VQEngine**: A DX12 rewrite of [VQEngine-Vanilla](https://github.com/vil HDRI Environment Map Rendering

- -![](https://im7.ezgif.com/tmp/ezgif-7-2e3c537ed34e.gif){: class="center"; } - +![](Screenshots/HelloModelLoading.png)

-Scenes & glTF Model Loading +Data-driven (XML) Scenes & glTF Model Loading

# Features @@ -71,15 +69,14 @@ Or, if you're using a terminal, | Key | | | :--: | :-- | -| **WASD+EQ** | Camera Movement | +| **WASD+EQ** | Camera movement | | **Page Up/Down** | Change Environment Map | -| **1-4** | Change Scenes
**1**: Environment Map Scene
**2**: Sponza
**3**: Geometry Test Scene
**4**: Stress Test Scene | +| **1-4** | Change scenes
**1** - *Environment Map Scene*
**2** - *Sponza*
**3** - *Geometry Test Scene*
**4** - *Stress Test Scene* | +| **Shift+R** | Reload level | +| **C** | Change scene camera | | **V** | Toggle VSync | | **M** | Toggle MSAA | | **Alt+Enter** | Toggle Fullscreen | -| **Spacebar** | Toggle Cube Animation | -| **Mouse Buttons** | Rotate Cube | -| **Shift+R** | Reload level | | **Esc** | Release mouse | diff --git a/Screenshots/HelloModelLoading.png b/Screenshots/HelloModelLoading.png new file mode 100644 index 0000000000000000000000000000000000000000..c3e559d065b415d267998208799cb03a32e191ec GIT binary patch literal 2405742 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ϓIbS@ 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 z z`~cW_{o3sidD+}7d6VFM0JHu(6|QF|`vcJ+s_4;w$Ak>#LH(DMT>{8k zB*qy9`~m>`Sg%Pi<(9SC%lwPbq1N+9lJ{Za@1)Aj@q(kU=Ud%=(xc%x%7pfQ=lk+G z?G{G&)D|NpD;Si86x+3v9uz<8%m3*=KCc)2J>Yu)wSdT&h1zWIbCrY<^@ErR_Tk+Z zQ!))~cjjJ)bvfHH)G@6Pe4xcgtTRk=Hq#l>s^aA4y_9^ALBxSYk3oN_Tjlmtr_QBK zZQDm0lbVMAoG6I+!l;f3SS)CMoBcF8Z_gl9J%*$r-|io{CaEhF>8l}@op`-bIMiYz zb|E<}>rEAWC1j|fds9_TbKlwhS_RX(_P1%qrYcAUL(@ZOe@5MLk?um0f+soNuQW{M zwrxfC8r3ior-LP@sh9e&QBVtYO>zb|?Y>$e+b5yK-WNf4)>JW|1iI9UX1*eZu=Rl5 zU5d#a(p#GyF`)*`%_$Xa&sN+Ob z4Zo#9NFMI>Dbb(nh7r$mMlOl1SWqq$<9U8(xHI>%mi$M+WQCy!^djP-t!h?8i4JFF z$2+7I0NW=?Ob95Q$rQ+rIJqHyW8am%^VDAYOE{5V&dR*`0i4PAz@puM-J|49_o&u) z`oHtT+@JZu=WR*t)4nj>s?|uKhq;$_2waHY?EdL2DjKeou;%o=jz??#LV;j zV8_S2E#${x=j)Y8Z-FJq~X(@luYJ^Xf2i zZf(r14CSjnESgc`^n1iyfxu_~dn}d)|~Q#S;oDli)U&28TDHx%!@83 zMpru)dNI|JkhlzSUr~_Bh9yi>@h~Xts3A8Y*q7rXb30dmt3tP6xGrkMsbcALuKL52 z!`AVdS7#vYRsXHVXhJ7vv-jFqQ|to|)fmOg84lsc-2KmD#w{cDg<%Q2xG4ze9U(eLp^-ReBzBS*pNr!ut${E6j6)FGNQ6J#A#NrrT zPyW6Unk{Fp3}6%T=82f|@Yop2{WU$EShtG5FJwy*34n!03RhrXoLW-CdyPo}&H^n7 zkeC-sCoYdixiSF+L3KXB=E|B0VYClCru^+z`%HH67Ce6F)es zwRm*4C40Z1G#)2#D4KcaRC+GSu#L%ovs)lB#6@yZ5Vy(M=z1CN(@?2{t%$+$65hV{j;j`2DmqWxq%^ zc@x+}{)B5JtTZ;Gd3`=|SVcFfyP^dkzz-rf9CNbU5Mm>mr4po=LP}>+cQXjP=?Do= z%l*ELYgNY6*K1ykn$Ms7%sWZw?$Y&w$oxAVti7tJr>&njPCn7sR^-Rn0LKPOz3N#P ztyx{H*O40zBcsbeBu5i_M2u~ueas{4!w=KcRxqT4Vu*CpSv-VtDpgGWYh~xnRjk0T z=sr$hq7EAnF4m94(q%*794#7u-R6+s@GUWQyUTXZTI3)ZiJ^nHx_P*1zExpZtQWaW z0X2mH{X+)E)b{sXGp`I&P!D#lC95|uhf>Q1^w;RUgeUYlVl3g=@ zYK-+dceyagiMFml!m;o~DZDKo2uqPuH$vX(?~{F#05lx(g>viys{hm76nXInZOs2yY}I8x#(7 zNw#$s4s$#>M%s?;QvnNFSogkJUyHWRO7x50i{#Ou@2iGM!7jj~d~S7N#{H`3oM!yj zMTbZEXPh{CvQTXij?3Y6Y{|O(A=*hd=PZ!9FNqcVP_~`WrT%F#Fe(j+*M})C( zhDiKOrGbgkLU7M_qwaG9+Hs=wew-!^e`k*+2@;$Qg^V?y=ydk-lAR{eEha~cjN_V$ zL0G*}?=)#}F9-uWL4&d~$2&7R8vAEwZwcs5ApbuuL49Kih0>2~qz2nU&Nl$nZl|sy z0Io3ge?`RPyv*~vF}1#i|9w+HUvff(-1&O5gX;(DlO>9+;k?-!0tq%Hr#MB}SaTXy z!O~-SUqp^~ojgr7;?^qOx+2!4%Bc!I`1)zFDiR#~wrM3x&tVVjD@(U8)RSHzTFpZ? zU7L@@U$MO+JY;Y;;OPrHb@YqS=r^8Pz05s-{!Zw9Gc0nZjaOm5Rp$xE_3K=(notk( z-x%4qbup-SED67yFr-eoj13&ouMA&Iw7fM=$?F0Q%>s0t2#;8KgA__2sUVO7Cc;xTf< zAPtkm(Wse>Jziu&Nz*O92hQ$+UN_%3XHXZc?v_Mi${iFZvw*KmttXB=gEs~&L>9{=o8X9Dc zg8Xt=rQDNXo4>Nm9_@%lCrPWGQOk%ye>R=dqPHM!VBnpwq;~O?#?e>-1Z# zrr~%*`-VYmU~uHdgA?AavAP8MGE1}+fIB3G8D(i&!V;=X|1=*SWXyibJM}jbG!l&K zr@WcvToXz|wJTggiW9SXr1Nk7btebYx>f3g`M~VJTm3l74Q|TN=!!ZeF^wVNv}Je) zuo46GAN47Wvm%~akYY0~*uL+TLd;HVrz`V{xq-VG+h>9g{z+N8Y$3Z{fY)(8tPFBS z>{Ic1|7csT86!`l>ydRB3R?pmE0s*p4~o$c!WhX+=JKbi_`Hh@2JZ~{?!J;YFf(9c z`>Eo$ET}6~M6Jx$A8;%?h-T+aMV#mN5^CG^;p*J=oTh1YxswHS}547 zxa6iyH%UX6S)4{~7jjL|SnBKHom%QUY#hvfTzK_~Dd4%xY&k~)!Q&p%<4*g&suGR@ z&1j)04EGJ_o{rlg;LB_{h8~((AtAN;a|+=Tj>tXN@XDX%v-<6RlCsS+%EscPCk}G% zlgIB%@^*9&0p!eaUQj>NJv5qJY*uFxqvBlJwEdyc=Dn~qPY*431Pj34+RyQAJ_C|? zdexhCl@8BKZpi4)B)xu};x_>(SIkGorR|ya`oQc?&&K-ilhYmxGPN@N0s_q|Rl|ZO z`wv2sDTAHv_wSzn96l49K6eU9D5_pJip0nbGXqBTC-oYL4+Rv`{-(`9RFU}Sp!oI+ zNA!B$#3lSyk$PYMgy8&>|FWf|Uo^gM_fLBgb<>_`3%iXgu8jhK6qu0yeN4W{KYVXt zp}7VmH8>vzr3T6 zp2;Qh%VHrB-&QF#d-*L(S%ojUZ{+#L8pQpln8t<Eb4S5ZrA~NOgY`$OG#;x6);cR_M{^RRGzXoTh+hvf=o#Og&52*0+Iw)E$dz}R9 z`Aosi)$o^|SoV8d?pf?%Q=^6*-_$TjyNFV)3{yr!leYuC76CPlE+T*ukN2;v7kn`z z>M%vN(h^(Ts>8<N_L1YQMj&h%cSd)ScGdL0brILT@?7M9rBVylyoSi9Jw@ZYZ6-x{@1Abb;w0 zX+)Li(@WGj)n02U`=s=EeQpb7r0mGyz@bN<->;T+p1+hMU5h-bpc-KqgpW@Dn_R#+ zj@ctOWAu%&f$SbvP=ccR(+znnI_RxIm$B&p1quNpSghg&0~X_zsf+D&I(62IehxQf zt6;BO!i!N^RSZs@%J8}luaR!E-YiQpm7_Kib6x1RFUZX(h`q3(CV+D31C6Ranq3`mvZD-g|Q za$_ICEkOc*EBilZM!^H@bEN|C!?mA+USY=&bhFfFSbIxdQA{SrVoQI<;k2r%agV!5 z|1OazaAX2+LfTGDg4Ng|zcpkrE<1X^1Zj*?-{h@Ly?v@9TtX%TLbp=oml|yE?^xp9 z?1ES2@qVyB^6xuI`ZX{_JE8R~r0-cDH}X#@Xjz z^|kAl#}=>{EAZtMb>qBCc+`O|^`D>^Qg*IiWuSJtlfe zOj$VO&}q_834*{{L^3WcDz?8LvUno|x47{34szdBI&Kb>U*baaAttg~HGVt@Zk2N( z%QRRq1*7Kn7Ny#_%Y>FMe?~#bATLw3=2C;phW1{L+i9@PX|Ub(XU~`D)5$0dr|WXD zNy|s4$Ysw44`}vMqH_1+jS+{ThV9b+{aS_#XJ2HRkaC;Ro)N5~%?S!tE^{PS{LJfrNP6gp;u@iKOT$DJcz;8;J z-L+x>OQOFcPM<0*!K`Ku)!GakiqJC8zsKh!KXYCFrokK)x~C}k@27vHYrcdY&lhbQ z)&%5DMNsZ9)l4<+?EF}?^AO%@8l^Pz(@pJT$GpVbikV+J5T>JB#v>(+H| z5}f%nB&8%CKTV>2@L&l&NXl@j#X|9UbbLm~=$we{Xa7L>7xZZC9UIoy zo$lf17%S>cgnFYi_||t`KjkKt^Wr8)+d?^Gxot2Mrjh=H72xm!f?k7TW#y*(AdBZ_l1_El1( z!X(azq7{RePqu$PW2*@EA-)60NR!5Uy)}A-Y)Eg>tv`+5aGse-;KcJ{b6ZF_n_^qH zv)4()UlP;3bALIlXnTI1A10vJZw4GiD+81l6X+_v!*UZU=pf&I|5io2x0opsgD>1i zbSC`Z+DVX`TY`vI*qZwARueQESDx7S5L-05#q*Hh?%mGV$eTkX_65k!ZSIiQf3|f| zA;FQbW|(z5B*-r)7#z-fMbjYzPD>EP3-*SGBGd4Ztojw}MkwlSC2{)i9YLU1Gvgvn zHD*CXy#9QdM0{Q&sfFIW^SqHND@C9=$n&?g&vJu?pj?D_!h!+&wTYVMM%U@D%U&|} zUS*rA>7U0Y6B@c1U%R-q65Pw;+-d*`>@k^ErMon>W_70qlL6km+sj-p0#?m8N zwtMR0wvJ^#H2U01G`&;JkzX#Iq2)v26XcM_->=d9(7Irm+xVq*JaR#@fok0L zNsCf!==mpf*p?RG2ln@&+dDgj7=cF(^%)$qLeVPE^`A8_z|^j|`c2%`;X9-8EU_qQ z$~nt2LXs5ayNUxN%_+)PuJ($Rt_AlAyF3%_X0!I#%6vwN7VQWdwl)l|-o||16QPA}DHXxAw!f9>ooyzi zJNjkWW@2`hBPi~+n@j-82Zhtir*%o-cf5jr>g|CsD08=!A7cQ9BR*5{t=tOt#9?$u zB!MOK8ctBm#;H8fXQ4RjN-l154ZpQ8jzN0)z-c6*U0Q%X(s%C7o{FM!e;plU$Hc|u znze_{XMaaK6Gv$=tLILSEx{h2)AB6-<@5sOx6*{cPY2g7?WUGG;F}eMXWfgn(#ZX^l%My?1Afi=DIY z_sRrGegVg?jRA0pKM#&|Vh|iHz5Vdk%OBUp%)!OyCAq1Y%R8Soam6r#V^tpVOn=-{ z7U+TcD|LqBQ!;FY`|BXvj0yp<Xqx@5{dXR^@!~Ehh2m)r_ser=iFx2)+&R zS~*!brVWApxQ@=~EqkJ*!#eL2Q!Tq|jGaNM$C$*M+xMG@^1V^or=#C_QSDdlb^$oz zTZ3C2g_T_3nh{@@3z#af%TvVm|GJ^lLqPVV3>7Rf8`Fligx{{R_n>q*wu4M+` z%GZ-xwAt?~qnKO=`QnCyJoevyQb&iQSGVujZoo*;;YYEb-{c6rO4)G}P;kR`uZ#ZV zm)pRs($?hB&A9kZH-;X~p%s^y(N-lFbMf4T!iTP$l8W`<=5|i`6}jA3RYPztRxAJ9)Y*Eu~dql?88R>Zi6yduDR4#4oW6hU;gvPG{ zeP(VhYlo>mF^;2;S2*Zv(S5(nbpER$t}wH{B8^^~UJ75Lg(Go1A8U_B*x}i0!t39w z$1aJUzixq#KW{n*k}6Y+inu*yZT{Af$2B!I2mSm$dl7J~ITZEoZZU@7zxO+3ayThd zzIyY8kdct#wRMf&Gd?Gh^NdK*dK2Usj`qKOp)vC~gY*S8bxM+CQnM)MxzI$;^19SJ zi=6b6Z_Go}(@IzFbqUoKg1pLui&8_{ooYj)a{JcdwqF?uhzJVj0uZ9Io{QK!2gYUJ@rS-?Tz>5 z|8z`Cqswm}lvUUU%_X_{Gj;e6*JqpAJ9`rXKZqmK#l5{0Moh`h=H0Hdlo^P=%ugUzPJ!{2MIzV7vne~ zu)po3n>W!N1MiMSoBt^eUs=e5Fa5#?Q4w?yAMNqk+3b@OhYlOnn-g?&H+z51=nXxU zLHixNXA^oUh8*%&>s${dC1S3gPY67aFFuOxUoy*Sh|OY>$*HJG=~TB;5qKhUo**g8 zsf$u+$XY=Xb?zRoF^Uc|FP*CKC#H!bA1i$(9I*EEzFo~5t=evZg|i0S5gF-Q8vn$Y-9&~ zzv9&k)HB{cYBKXZSNs(72ASI+B)#tB>w-`DfNEp)ihiFc64rg0cIP9LKXS;>7@U}&_#Ma1j%lz3dFJ(ymU0R74vcmm z2xd1@djAacWWuz}kG@!CY^B`V6ytNBVeRphiCo+);qM;(35l+(55|}M6+dUjCL}z@ z9^`&|ikBP%xJ+Yf5}gvB{^Z!kWUCOvHXR*5HOCQW#5bG;NV%SH_VU9iD~P8$P%71L z9w8ar-mMQti*w+4_go~rdL{GL)%>e|2j~!~fQ&yflChG!GaqbVg!b2i`prlT*)ye3 zHUh6WxXoO{u!t2MUEOWL75rvg8Z^Nm8zyF@*mFHP>Si)FgkDgm{Ejf#=rgTc+M8OUBRD!$6`V`g;aAFi>qS_xYG(E(@WSQJ zU7V&bnNO9kUD21mC#NTCuRW6qhf!F*Yz!A)q}kZrQx)?x!DAj$8DR2eB2fR0Hd}{F zFV*j!?=7|^?40Ta1enA(-+ZyO>}ikf#7H||_NWBL-~dd1B6QGy_}w@@Npe)DX^iLF z>2VX&bL-@5R1fB4QF8i2%(Uf!%Jdjn0oBO0moXh@6Ncjx|5j(^k!ItFc%jS&=xoAf za$JK~aRw{H){H!v?ygxS)UGc_m0gClxR;!_OckY*iHqqvT8D_Hbk#jG(_%nuG^9D=6cNJ>t7xw+XWgqr* zPm^yTp+K*0n@jxGhqH>8hG7RA|>h7$M7#E|JjalxgsOzVSOQ1f0A#?4e?Hu)~6&$n@JYYaUm zvn3;NVx`2h{`xw4o`&{;+T@!mmCnI-IiI$Atk~=A_hu=nXiIX;Cq{g~CY91#q`Nao zrYZ`;QzPajx)IoHL@wX{9kwC-_1a2ryQY(eZo=~TL5HhCX%Sz0uHVNx%?B{blx06k zExm-)kTR2r361oRS0dyXaJ0k{54-69q3SE6qTZvmhb{>b>6TPN5TqGO+Ckz-J0Kzq zh=g&A z^ckzCIa4my8raVggc__ih@eJ_V1K#Ye@Jf-c^Qttiyx!jRH?kE3M#L9R9P7^T1)|A zyWSdaaiUD2ZrjC9@xQYS33UR8W02Y4cW+tRU5AuERlFCE=bVa8A@GMJ=qMAJsk&M_ zHl^R-0MYZQO4aMY#8BjWSo|3T!pPZDVdho&x+SsOr&}cK{dThjl!D|bxFS6MPSt5B zHBnH?S?@ZW?L1XhYu+f-58vhB{9Kk9>mhZRM1)7c68^&t+(7w%yFPrT`yk}Mg3!9? zAtfaxU5q)aX>kF@#^pe98NC436v0nKvX37tpC2r`q0RrY3RvE10bto|y%<(PmOB@M zSMJjL;sV40OOWUKz~C4d89m}0)ji7g!}am#$~frmOIi8@$TK%)OXm~4-rP$TN(*@w z4`T*i%0pdgsti40dHIsyr1XEZRVHxM^K{l=uxvf{p+0XcErOi!@@`~Jeo0BBQ-L_* z?DQE_ODyN5c|4ku4V(aK#sJGko0??eKH&qUUfb>QlXqixM1C%6Sajg<;cVl!npX+P z%h-VFCTNJ>ccGaf_ZS&}TVOrB9X5LSla&-nc z^jN%vjl9~qhi5JI(!)C9xV-m%(`omI_!zv+=0{3~c>gBn#i89IA3IzB6~8Vt!E&N} zsu1S;T810+4WSA$F=DjDy0yZhj(O?nf=4-i(~x!e_I2tn)XF%+y4*<#*RKdrlTnzSc1nC zIRUn*eLMg-Aon#W2!E5s_3xM{N2D2-8tlD)n#MsGu%!I#tzc}QctltLYi%sBa=QnB z0;}%OJPax4HB|vzL8>rTi_Ov=_OX-I(_U zU*|StLDA5(rKiKv2USFxvXStqE5EQQ{2S)VYx~Xjb=l^#=k94n7YslU}nb5M(|q zU7DJjDvaRmD_^iKOHlrZN>LIwVa(V!Njkn{d=iLtf2~~P*HlLgi#jDa4Z)VRl{}M` ze>)Rt3YkGKhqa??99i{-bw)`tmomP@C4e!LHmtbBEgdXj5tDY<8MlviGpU>1tNIOJ z(=BK`BrPTDH=xi>M8B3%dRPIE?;Ee2PH#FmIx<(&tf;7csIXJ0+en7JG|JA=dK+jg zALP;Z6RxUAT&;|yEDZ-V6UrtNM$rSp$V#7SB%gry`Bgf3V?=J;Rq&3vnnSIuZDCer znXLBxEZba1yPE3LMFrOZl%Ipe50t`aMZxKFB+4J+3=wQK{0g;ur54L*;SIoiP zT@{Ynfik8003=`!3;K}2$iyTYkW$+n|B{RZH&h{pNkU3W1DGWKa0c8E@_1IlO>%FZ z5XvW^O6`}yrZ=;sFaEc0->hM<&=z-RPw*d_@uIz{re^9t&~O1C866i7&r^)sdXu5~ ztH;tq(O2-F>l%zY6R8W;nX?XCLT)YtM%hKIM3*f+?-hq8`N2Z&D`B<4ehxK*S^Vxot`$*)erzaQj~z3`@8M>y*OT@7HkA(kyu4hYVehx^@`; zbV_h>sm;nu!4Foc?U}52?;%Z6JN&DJm-`beoA_lN3L!R0W9{`WVtNihl^{yi9`*Ab zl&x8ww+z{t80^iP0Y_la(ACwAut*2E==pimp3N7)DCo2~#DosE(<6EJFa6l25B2H7 z^!m5-?aw!C-oQ+^l~Xf-Qb4y71YVGva>QP5>$fY|T5K9k(>$bScP|iZkIBxmC%n^gm67=X z)0L&@!$+xrw!m_*`Ly0%weCURtF&ciuccv3e9!r7mEfaMW?cTpgp5cv>`qBd3yIva zfnA((+W0I{q;Mw9@B`LxCKjgBIjaN=E3N`ak?t2lG`p3pi;SJ&{bSPX>hkNn*aP<@ zU95iLUoZ(xix?a&65nkXtMug~G2q&1cMtXOBkSZoT+* zKm>U4ksm7Y@)YNH&ePA$=iM|F@jE4fi4|M{_GL;2Sw~p7 zxWpfT_mSOKRA3zM#mfarC<*CMi*yU-Hjy8YG>urjc_jeJ`1h5J{`@HiB+X3t2mXZ} z1gcJ5V5g-=zyNSL{Qp;!U%_JU+uGzq&u<vI8Zxy}{Cunv8Wh6RFB*DD_eTXKn# zAE!(QPvtrm;R8E+yQaZH%eH0-(Siie5r%xlMjG$0Qm6= z2J3T_zMvJC_+@b^IJ%&^hp5tXS=NeE<1E;?dSX*jlxfhaagN^85)qbGns!cV_htEK zv00u@bpH6_T|8p657&}P41<9G3^bnNy-i$B7~<5-Th-X`EF<13GC%j2U8dRFKZ$uh z%bTkU7NAP_Nkw7Y1eIv?jd^4cj3JR}@Jan9i2fpJl*G#noUKY;pZdME^)>n{R{R-2 zKZ(kyn%fg_6L`+j^Db>=PZwybbH5y4G|p&FdpmLVEIo;tVf*XCK3`WmmcYHags{;y zRq{L#HSowD2`Ti4RaA;g$!B%F5McR)+d7E2D=90P+0lVBGd;6bDdx8rIe2>YgR+QU zFpUz)y0dq%H@ZLcxXIH|vjp0dAyxwUy|=S@dbYmIi$-7hq0#DJXY>Uj?q0hD$Vcro z8*L-YvLsLwVt278uITFm&lNX;hm;V9sWltebWGj9S{r)@2i zSt=yCkv;_((9sPH zC?A!xB37GNy#@b*mdKJ8bQ1Vg8ZhK^cPnqQxc?n;0J`(|>&=jR_X6AZ6@L@tkX*gSP)R}vKW7ciWAV#lE{P(+bjYZK zqhEamFEzF{_6l8#%I0#p{uFF+`IASnl?@eL=}m9mem^fmHB?Ac_Z2*t(xG|vx(dNPT4@kUY^`z{;2yVnNu8`p)KV&p4GxNpy$A7|TS&2R7~lgPqg?9Ah8P*W zr7ab;?~lM3sc^;oevtkZQE|6sE@awZ{}v+Jo84UnSy>(brxJMwh<)hldUAZ}Jp?}d z%aQqIf9~i|>^Wz@X-xrwlX-c0Og%~fj3z=?yV8@-4e1FeD_)9N3d6Ry_H&h_l?_G1 z;UFRcoVejl-sq5b0Z_Jt4cyj%q+(x(bR&8O4~cBBmKOv3w#T_vi-k6MAH42W06qZ$ z?_Hv2($qOuUSeC5c^Gv&QPJ^>-|x2nDM@(BX~=#H5BqfYOqAGD<}~|wkvA6N^wNxv zk_)O*D4F|d8@jYgzk86g;2ku>u+w|6m)V_1-ZwR=npREy(X~pOEj>$5L;>aFLq&R3 zpv9#B_->xNcz(6U$=MgB_m2~}6F(V=>Fj0!I*XBMT3**Q0CnUIm(?Ip#n9*c7#J1> zJGB-I)5yjZJ%X!4Bq~%`rVkj^WkM-PH&(upj%o@$J$SKaIJzj?-LZkG?TKAM-#P825>tT1OuQah)^RU?QMkzsTb^$u-8KQ#$>7LC$S9}?^ z#>nz81+pe@4eTr;u=v$MB_&VGaO-pS!Q6DmGS2nXEGw&OqyUSpg#e(^lBmxK;mA~;*t6t-o|pQ4ZowRxi~vI5}iaxUKAI z1}O3&EnzVuQJzI)^uKp3VP#Oe1oh7RsHa;oZGHJOT#$t`YJq>|psD~jr$$s|>X?y^ zkMy#3eESj5fUIA7zrTYQja^$WqC!#;JMd$Lk%@WNcpXj-vw0Q86-;35VIJR)g4{yr zLM1hucquaXadkjhB6_Odwph8b&I&IFFMavXc@03ge4zbV+|~|VY*rl*TPWQ~KbeNP z;ESJUlL~5A0E!Q<;x#fIQFCS3S*@)9_T({tGhI*>g>|T-QN&mgFN<;f#*dxTN>lm@ zL8;l9Dchla#g>Tuybsb|mn#%5&4vzBbKFq&)p7h z)bIj zIM?L!O>0Y!6hObflx7t=t}9z2Y{qyZ&es`xl*9toAbDlaD2AkNHaRAYxq1E(?Jt6# zT%Y*;OUsZSO3k6svZUnXW5A^|rXDZ(ix(-(0)VZ9`vMRC?p-X{05ehIyMC>Bqva5S zqpd~M0ebfo$aqRLvj8TtT2gONMd{%Y#|psgw;T;Oj=3*AhmciXi_s#Uc@5rC?*y>! z`XbNLNlZ;eAkd5~qsjVw&kyEUp1m3Z;QsOksB=u!g7dFB5 zN&LRqKiebWbX$#nC@Nj6GV;ui`NhQ@5)V_CfA|=eW#Nw$9ZCehPL%_xZ>uV_Lo=?i04=!iT$)3(Ktz2{2<#6eb99Zd4q z;wq*WEG=%H=aJZ!V-@tyi^!a=`u;#tf3CBWIUT8^vkVM z^CM%$`x){AKbAN|r&TpS@Vcf-s3XTrU%#7sg=^u%p7(7FuYPJ6;xaMaA3;u z>C=NZ_W3&vDkaeLc+llci?nMal%+FU>V6b`NT-}GGp!D53=S49IL$X}3@7>);U#$h ztA@XggpynXsJ31hSR0vTf=w%YuTv|9VZTJee$!SbH+Lg`HSxD{)WVhsGjY2I!73Ko zact`b7x`QRO8_=oOb;W&{uKaZTNhn{5_TQ=`9||$0$hdv`=VBT-P{s1w!MLS6+__D zKaK9rk!Mq7Sy`LHr@wOWtlwc{W20sZYR?`3^*6Lp4;QF-2mu;F(NvKl5dlj*0dxfue0MvKG|tw(BXh`A;Cs9% z#-Pz=pMr-ZzFbG-ClsitQ!x|O5wpkLsAFxxe)xylbk~GoARmJ|=o;Fhk|T)XAXx72 zePQK)%iXhV+_4Ca^}M-2QC%?Gv0mU1=bY%a-p-Bs%zg!(l$@?qOZ3=qCj zZmtM(^K70w=d(hlo1UAVyq*q@Pd7bdJC&`x4z`%UW(6t~Pad6x2iX(_<-POCS&pxxOb+zE@ineo z$NrEo%gN*h-=Y=2hyqCD{1}PXnx}Oj9ufK$mnaOf`js`s?IGkwM7kN*&K;3wcEz{2 zF!}s|s@&WL_5cioy24+a84vK536@VC0GdY@SZyFIVqsx%y3~fV$>RA3T!#Wn=EksF3!($q(3A-|D_Npc5S=&G@JQ6N-Q1wgG^$ervC{ zoPZ@WMTFv$%iDlIuPkk3P{G%2BA5JCcXuTH2Ss^L*TR^UBigFTsb^*4z3l89?FQn# zM1Fm$eq7x^ldDv{*AX}#t1+_B&Byds@V9X5y+9E$QRRM;F%c;V^;H{YPCqvESKPyq zWwtyNR)`M;hFBZi59h(TwH4VVSLMr-o*`ewsOB#d%G&fRxuy@=V03M9X|Kg!LF8wJ zCoGCN?jj0%Vf94BZ=Is!?Ch~2wjw2?`maom-FQwsfkI0L+gLu_`1OaexFI^V&vjBb z`-S=+J4Q??QgsO53!lzg-26^e+h~$|N?(o0jr3{umd;DSSo}U29nFFWi(qF!`jbnG zLm?m&!{<{LmU{Cirae2PtWlr$@63qB-@4dPt)W1vm$Tr?7pB{Js9{&7`Ri{pD=r9O zvo_nBe>tkweH33-tST7J&aMVc_5(OJ1d_ysf_Rx0yK(7u;w`e5d+<; z$&2EKTS;lWCl^37SjITc%qD(C4SLYC>}O@oa~c_^WKVR#lG13i>b|HYrKT-)woI&h z7#XJIbX~%Xj18BLTcR+o)sGD~9&}=xEQpoJ)w9H4@GBhY1vm^Z6tS0-v_4wOX)029 zJC?p7GLLHEBch;8toq)W99#adyT6hVXn>&78i5lNhBF4qnR|nVM$ptX zYRaX0qu01)F7flpykNCXzcvl@KdW|0$jD!46z~h@Z0F2<1++_58R=|0A119QZtN@d9-t}KnE~N zRMlSJ@Z@?k8ctU(Z!bdQQB=8nrD`~xs4nS<{xrf+tEEm#Q1n%PBvfXq`c)5$Q))`L zqF6wT(ee5BrRPx;SHDN@{Sm;=m(P)~|D~D;Tzha{){MCe5`qcy2s8neE3B;JNTX$y z9B|YEei)_V7ftHGotPLv7;9I-LC5+6Fl&GA(*4H@QF{-W@6;u&jz|<*>`RzV+pGfG z>YR6Nj~(juNG89rGsnZr(=)#)_hS+O%dN##KV#7P>RtCtWW{3DpY3hB{T@2Nq{sDJ z78I5Fj}}n5&=8MnLlyPmNT|VrqNEu+BRUA}_d2+~U3#W598L4F=jEEcZKi>E z=MD~&U7UL77CH|DR_|OrT{?d9F-SqLuv(4#&iKUWKmatOBD|~3`?2ESKU(5nOXZm! zP!bjjq91S*S3d{mDzVFNxyMD)^+)0UGVUGi{mDA06*;!O!beK(JT|b#6MpOL=V>QT zIQjXzt;O|ASW+tex{EPGAs;AUZ;*8RDZb%Ve~?U0XUo2UUsp>&63cxK2|9V%BF z$_3oFGh&Mz`Qc5n<=KLSK=h^7;KEVe?J{P8WA9IKihfJ>coG+G`6^?aIAYy zP@W!*`T4SL%VPg)G|2E!Z|D2EGDwMTDPbF}aMnR1M}ew6ElCm#^{2r4C%vL4Xq^Jo z&+8ZKowkldpr(Gnq@C{p_r-aAfXVDe<4kdjdLCvqw>5o(t}^sEeD_nkae!90?CmGK zPe4E*A}RSJXFjzXK6Z3OzJmoS8`)5B^JQUmr!nv-|phB*KrarW?;y_#1os zci7*?{uV6*+}7py>0IxGh$o~u4l07jFAm>9rcYd4pP^7*e5Y&@f{cgJz!0agl}jmf zb-jq8aS;&%%vY;Ut*XZ)mrc&+@auSQ)70_PQ?{-w$@P+N0BQN{;uHJwLqL$vSXg+m zJ+vuaAV^QFBfXY43rC981Ja>PlSkmU{RKUwX5rMWXU~~P)bY9RI1&ddP#wBz53Z`5 z?s{@g$at!1-4}H1TLRpa>iJU|?{T~vqfpOe#p#H2+}N~kw*(W{-4d0lR{;zFR3~mf z2i9l@hcz9_S#;2kpVQo^?3)soT2BQ9hX7VR=L6l$f(ejo2sECVej9UoMfq6!R->qfv)R66Py?>Jr zGdN88Ir||;hxr$^hCs&LJD@5;eM-5=0Hr6^>`V$HF20TtpNZREGjhKA}3p zM*AJ$%Vu|UN}dE3;KEgs>w55j=%=b*Ek^t~z*`&?L0qIcozv=GpT+b87>c0|j**4; zZHNc}u-wYte)un0x#VVhJ+vai{4ZPZw5Fk)0s*mva^zu7tlGB*H+=*w zuL08oXM?IdFh$v8q&_sJj_Vjd9WnFcl=mxdL7zRRzMip3(*bllY0?Qkme;yM+Xs8O z&47L57EOU*`m$3q#dYh-9MvEseB{?5D4Yt(ldksD3@!*HN%9dSm5t&({8#&XZyebf zaOL6%l((U58+rTh>t(kH5uDf}tuQ#-_R}D1Agsb%IZfLikb<3m#Z-J&zT4G4^?(EO zwMxBB0e4lWJf5oi<(DUFRAY^vh5{Iy(taC?_Or8UgNwj{pqSD`d<~6zjh{GgLP5){ zZJ%{lhlu@xGO2$&531!a5%U>7t2se8L$svqNVcB!!;P@L;V5K(%1@L!QfKKRoG|pH zTiU2uHte3Wb8QFw;8#frY9=06F8f;k_oFR1OS><$jFg)o$;I;a;rxz;r1mgvrz`}e z8%GJc%LmHDJ?u~LX563^B6W3pUb$Nb(8_&j`@fx0kVlWtj;3`l5e+w|I{X><~?J0lJ_Fw(^%F>*|M;%6q_-pu-D<^KgcJ>tf zqtdI6THD#VFx~UNI@j;Qw+BW+YySy0YRHYv35!#PdxGDswP5Lz1ueN}o zlDEJA)~3L7Ak-T`VIRQWwet(VVLSr^%H-*#nat^+v7%A?_WEdzDpnYAV6O0~=SwdvEMV`}%|cZM6(U zI9&o}%6*d`77IGjW=X&cq7BJz`TFKlUY+#A^YBt!14oIo=9oDB04=ba( zc1IHpUmI1ScJzk=lCYrcy9f4;#H_fj6YFI$xV80}>tg(E;f4i{QP@vyQsP1VIc}mk zI_3Rm>lD31)hsIwlTt+$2U8BN^XJ+N@s>T0j?gfX#zlMn>k^clGqeA3qow8Cmb@5im0X-!l@} zBCVgN$c7?6hQjj$1AucCGtZtJS;yJzFMjn$%l^oT9luzUHN85(e6A;vpvID#HR>H3 zm6N$-blDVM(>}3#8a{5KuL!sVkL&ojk7b&Vc@xNdUAMGOcZXbv-RpU7lQ|ig{Tfqi z8*=s3^N3FKy($^M-n}h4-_SR!$hxcR6UFyie^$Byo}82>^EEgDoRv`$W;E{XrO59h zD)vp*aiS(TC=8XdD<&kVc~YTU+4xXVBYvE~@V2Ed&8C(08}|@T5*ZO$VNIN-d7!5Z zYW`fA<9HfLJ~B7X!$0t8Y;v1#F#ob6m2+l#Au}uMo}}I?X1tdbkldVv8Q#kcC>}q^ z0d)tO;M20R()KD@s}>1vtm=gzi)8Eh4wr49YWRvPiw!hVIY4mZn(b&<)qGNO?( zqm*p6S@tWC&~D-`nD(ctu4(9lIlOykgdPLb6EDCS&fgBZ)Jnirc1no`@oyd6GAQm6 z4spqqX$UtJmXg9mE>-T4PqRdHxte_IDx()7vy2Yst7#@Sf16TW6K_!du0CyPu+YM1 z_|t{eyoM>+FRt@1NW-LHaqG5oUBo{=?$Ehyq)m29#jgYwmV)N(1qD#25FOUx+M4S8 z=GXFpf}xY(7w2VVajWjXl~;~xSAYFq@y#bglf!qTw!~##{Q*LFc z%VrAWuH)sR*&xnGQ9bR_Gd7uv*%npBI*lZaJPPyuR44m{dp#RVSW8lGe&xk zpNb4$JXP>^xP#ha5P@6%@|K0ox5Aumq?kC}Lu#_oik*bM*%8RO?|C{;`cvJG`Pn!~ zCr`phM+viR0@*sxFT@7=h!9SN5MLl-*iXUzQu{|XrO8H(R6_1cI63epMrV#0?Y;}# zkGF>TDhoZ0wa6M@9P8o8++tDUN*f=2A>3=}#rr$(69|MkRa27JOK15G{3tmE@{lXV z718(L?DM_-Hz%9?K>A2TXk06Bn#Ufez`k5eR~`A_wM7aUp?s+r-3IC_RLi8QfP(4G zQ2bi6o8Y;Kbji9P(wXQU)^X)$E~`+#s1eqn)X(F)a+K22a~m9Ty>RQc(UphX3-Z3k zFBI-C)KY^CBN(c1!TbZM`2D+<0sV=xp3E-|>n30UmdkHE)XGfK1kYVoP%dCSVUf&C z3D=bL+boVlBqtObTzZ8iU2W+2RTo^IHsg9hSH5YjFu(W#tIn2+!=^cK)2&$x2A2|O zv$%)W1&#@NDjwT98!Xk+6YR~b>MWwLxrID3e>_nE@R9Y=-m(YckBI^E;labdg4^oG zVDk2Pk|-IzBRx4#RNg~nZw@rV_oaa}Yb3Lb(;pDDdKv|QpyoC>MnFIyX7Ruc-S*cw zq{>10b#Kq^(oYRQKlrMwH~FO-#nz|R5Oj@fsNusP@Md{UkOoH~-lP*I)d}m3njbYz z6!70K1&g!-G6;|HVWSpxp?PF?tYq!$-a_6^h?9YK4n;?*b|>EKq7nT?Br~w<_DZv9v?nVrv^n@ z^Q4Df5w#k>e zJ>MTHFmj{IK=~S=lA>+l)(6`&8J`w{iMHQB zKTAtX>%hoz191eSRFswfrHV{VnEV=|M5ZljMMc0k64uOzM zKSp_*S+}w5h``J3vIo9)JFa@HJ>SG&ll(CJ7U|EQ zW-Q^6R6y)C<+(=FGehY^Oa@JN&2pJhps<}rkvxdOTH50l;Ga2Jc%0LE?m`B3%yrpx5Zt?F4 zPRoy7jTFY%jSSHp)$8kd9&kesuxAtX^}x}Jfu=1}EQ*$Dd_uVe6}LWbxR|N(H1} zEjjFev5qmBu-n&X4vaf^%Pj3%YE4)#8d?{#$3{EG+I76&D}V zXhII20Ak2n9BA>TlSB`|W8$7Kzs922f;Y9f3ZNLi`6wOb+NcKwjvrpg0y3(>#ZG=< zuJun9nRyR-`ujRushI_#=G!~G&xDz?6u8u)9YU~Ei>{|}UbVaumOnCxGXh4VJ=APm z$P-}d8TsuHUEU{7N`5wS+DQoHr-6neT_iAAwo4!z_nW|6kXh|>h{7=mSE2)}vUy9p zjUqZ zFVMo`z12<|=9_z3!Wkt`y-HPgrwPIjKRLb#+;YLc9^?6ewR0*(3JB{hUv~w~c!#Q) z9qzM+xkhdM2=&D0Uokx4JQ}j$Co1B*G~`R(Dj#=~ynV>GZa3I`Av%t(Dh-)xYy5oL z<1-*M9jSe;aO_PBlzPJ%#_8uB{UN7ugui_HvxWmHM@ZEe(YI|umH-8;$J9ZPjMGW z!1imG(FmA0{P$p5vs5B$=cJn*oc_*M461WmTU(BQXRFxQSQF)8n6&sXAasoA$tw3v z(i2a~EK{|H*svYtP&xtzqBT3aOq2Wa3mcx_yiO%NfN(5#dd~C~k-$WB`Lc9 zK0d*PZmDkiB~imJff|{xS)GZ14i4M2Jg8F5jX0Lk;Kd8-gXj8M8eT&RN%1Es@d>l# zt-;mTlHy$R$K|@^(7Ki{-IsJD+UX4HpvaMpjdp?(rhd4fE1;I0g6GJo1rbf=Z3pWS zdoK!rGh&gquLmkWqkD$21S|F*7`-WUM;tq2v&zv6b++h80t)Z>aU}?l>^hFqWrw35 zP5tz>(+YG}%{%%TJ}^8i6%ifau+a94g80MVzC<9K)p~#hS@plkTFSOs4Uv$Ln7H)A zzSF#i69Svk0djc|a78}}4h|NPl^qHQS|xA!Lo(yufAHYO{EU(6`%41aWxQEwZT0(O z`#>fpCOQ;=YWvsWKL4C2>b(;s@e@5ixJl2IE^5f9N7@{~Aw?5f08G)o&-^ts8jGHR zcl2~k{4TNqW&&(=fQ+18JmeqJ8UsjPfX^KRh?N9lWwpf*b+9Bx21{VsqmNaN6wWI! zp>GuOSv!pm3n9U3$_CBhd!D86sFnxWg!kL|t}n+c^X|3w3+?UQiqUE-G77TGGUuo4 z=5Ko#`$JbUT6Z%};vX_`CXH?3W*Gm`-4n;R=?8+klE2g{wx!t)87!B{GQZs3`ShlyF*^s$zYg<{>}nhp>8vAOd+)LB7VH!mLEh<2EzI?g%3$SC zsmvz;yBf&U0_wrJ2;sDveM}(@H|NoCuWz0a9wnCJK&$Wf;dGY5cVg_h@%Q?t5WAxM zvFcS)5y5X?Sz2~EexiDRLiXcBO?CC(aXfN)*&O}7{qH#Ldzo?Ed2}Si9S3-YBqI<3 zhvdtr8GoQ~G9Fsd$JI4HDLFY6e(@LH90r50{bL;um&?bzZt~i*tqD7dii&@ysE#7+ zrI}r-a1QJ>5AWbifYq5k{X`tf1JHKr?@{9hsP`XnP&a8T^w9H<1Wh6`LhARre3QP= z=5|S>Zi|&9rZEEkFRUcS2Tqc#R|5srB@Hzklc`;CM^DOGNIbti$z)MK&-^eD>Lm zd-T9f1G`%1BRSSuc_161;Yv@YS0Y~Ed-qM6_HMOQ>P-Zj-ekn_5KI~gE;3G*A=DWTXqhwuec{DsjlK_{^2CQid zchC!pMT$na`}Z~+zb8&&XT%F#HWt~sT^S{935$x>F!m^lm6w$*i!0yQJJh~X5&~{j zav+nTlllaZ9vDylbxMbS`tpmkB_Bu-C7-S=pWY_Q*vsnT8DAcMjVJ1nkAZwzd9jc;1<5KNmc+ufW=pO{pAjACy z7tiNxH6T>;uv~g-Dk=4{L3Rb@aXhul%QQ8t_qYa-nK2aW7ueQ8 zC1d^vS^ji7c`XvJL}lab&z3ia$RfTRenAT(i?ynlQ>(8zvZy5K;T|1dJJT6`mItjO zEa}@oHZU~iG$f|ZDhG_SfEjFBssz7l;upV+Jc#5xnVwADGfom)NpEWTNB!5~*+jGe z!j{NS62`r!z@NN@kMK2#EjT z_`-mTEHx&=$6U|A?GD$)k*9REQX zLUnWYw7LJDNWU{jfJAsOK=P5-5c}PkCPd)R@Eq>Sez0YE)EAY`3`LUwQYK&{g;|#- zY#+R^TDJFajL<+STqM)8d_5X5r>ENmGN8us*Nh<_bWA*HMuDTv6sJ$>oJ-!afwr^3 z(7b4jbJC4d%ZsV#g^m4w=3~5>2x@XIwLLggsJU!y48JB`gC}=S9Tw8V{3-LkwhlG+Hbr zOjjGRe(9VzrFgv)^gAJR)X#_@I!Xgir7?wAJc_h%-JD*pUu^S=uVCOlroYeWInk0B z54Y`82G}j1aGoI8JzRxTMH1M+cf~M7yz1FLLa5(d`4*CbqW^F>+sliAZwux~hRsBI z%!<9uA$Mw}M@lhsmG`Q=G4I}N`zrYZ}%?GM9mHV@ySH?T*VKmotiv=8Vw&>6GP#^=avMT)mwEtG{ zL}EoUrD?-;Yk279@f;ldg*DT&vsqBowtmE)%~C5@h@EYe&*$c=?FawE>a`q1LDC?A z(fOvlIR0B+THrt*%Wr5%mc3lNvx#+Mzo+oUc8`>ozPxdET>N2*xejx#PERXW-EWK; zvQ;;JA(T@}|eqd$Mn%e+T0N4=D;g zV=SF=n3s3=sp*T7nN+aO^G@b$5w3*)0Jm3`d z4W7GGn*mC4m6u9JBz`ddt8nsH`P_7wT?IgdBWjHxn!LbQ*9R64$OPa7;*HUkFFXh? zg+}tz4^)X^?v>K{ljk`T^|yXt2V46#Li14ar#g)iMr9nO7Q#fnIj2T?ndk|h5StgV<2r0{KaE-@1* zGIK@6HgpGZYk9c|2`&LF)j}^>;~zc0&w3@mp9-vqX?)&I=zHZ}`7_w#O-VxXniT&v zY`SDFGSbcGV?2%H^}D20Ui&N`pth&I8KJz#|03c@N9E7FZAem-z2hWWg z{iv#{>iQ98P;5~=f&geW?Sd@VrZs@I?Jm=Ybn-lcrvMx#f7x=x0`GdM{SpJ*x8)oeTMRDuOjC)@JW|#xjx`S z0y|@zq$J0+>YM|DJ_b?|;q%;e1ZAr#=A`_v=Y&`* zIQ`m&xyO%6E{+w_Icfrs%L8Q~YYw@%ZKgi%e5u>ntMi-?gw$Nx=4dkyCd|2IL?Nd8 z*b#_N@G|{gbNNN)BSd=J;UR0@9h7MdZ|Lo4!sfG?c>I>&@Dbd(% z4f>Kq#e5&9ORrLrUV9vtN|XDSiWEKDS!k487Np%hUNro4jX%A6XqN2iCI<5@?qyGn z@2kA-VQ2b*ZLc{JZzDFDR~va7r^?~+n?9e8%F6s%pbstK%H1PTP#S~zd#2u={K$vi znqu12=``AXq-n6T03FiF-~=5v&M@yyPGX0>+wdMf-p+Bca|}1E?vyF-^Lgz7TaXQR znM9QeuKN7;^0BG&hpO0F%=gd?M@p;%5bqxLxA+8kTyIp8r5s`M#=;lm#Yz`Z`bm-` z+^0xO76(H}+|MK0fh?KOG7{Fe+XRB2*_a zn5|8!?;fgs@kZ*w*Lplu*1oO*^(ThJ9y2gt6Q$3*$4A_(JWepdGe|;Ci=V(re@v>N zQ4CuAsN_MX^%gk{j&e zv5-G7vyF%a>Aw!D9S{U|6h^vcM`f6F79N&e>xWzwNZnrQY{ibjw7-C0??NsLz<0m; zzljSX77}dn)u&jJr@UkPb4cnk=%nKQ@C4GrP%?Z1s%YX*@MF;fB_!?c=toYEQa-Xwsv}yGU}J_yleViaRUpD2E9txlTQ$FG z+}6}om-wySO`Bj&wK*D>r*(XS#YNF40|?yLX;a28)9W^BCvz7K9i!x-bNYU=lOk8x zi24#JbJ<$Y$|3;=aB-Jrc;albN%(x6(2o!6+fHuDFb~w&)M?tc2!U{=Cz&VSFB=o* zCEQE}vN%0fH?GuZRSu4k=YJ3|VhVa9PL}X@k0C(Rbco9U7YkG1QQgi?PVJNKfN}Z+ zbTfMsg8hq&1!jKzTGHdo`H_ghlD4J4G64knT?D25AB5?rzxM1>Wz^^L+n= z0~`)#m}}-$qu~rIYI`jAY)rW}=ezth-tohq1r>3h*XYr!YcuH^)RKBE>CH*q|yOaf8Lfl7ry!@8+QsPjm(|{iGwq7i22&qi=D4It+4f)W<`f&12HO9W>W=%po^EQovML#T0)r;J*HXap!n8|DH842bUiL_NrGx)naYUA@}% zLU?t-VcDQ+Mm34dEO*{KWxmN;_2aK~)f_<2b;On@=Cw6Fv8=`4a-~slb-YAlaKIM| zp+S-k@6mxsJpZ#OS%~^cJ3R_nB(b&PaM{X60fV^iWHG{?EVF1JZ+1c;=o^4;Vt)Lv zbGm)10F51P`UIdh!B0mhfNX1x!}ToShWGTu+y;fRxMj7TzNvfP`HFwkuvk`I>LXjB#hd@qwk2%v^PQgpv$ML%ZRf z)jN!tiS8v3U$eeVrpIwr8IfUI;~?^Va>$b=W@%Cwaflg6;7h!ra1PC&ft=U4XM+6| zqJ?(&nbeRC)lOAjio8sdD2ez=5VW6|37w++1hNltwou-n7IAj`TV{f-_}*&UHF`l;_wuGPxjZSRXnN7u6o`ZTH%MvNgo$Q*2X?Z1QOKz^|9{v)72F?6z^8#Hw;hHb)q(FPK88PPwl^8D0l8P>Bu1wyI$OIaHhZ0*H^!snV}Qys2Ob=IyU zpG$&J-DzelOYUu)QDxPe3oMFaxw2kpt%0j^*8PRS&&A~lco>3u>n5hP3-i(Q?}S6T z#|GA7g@U|3p&@(RHWqkbVBN-WgUE8)-FkDN-~vwkgUx?pn+B)dlgZ^}#-#)Mc58hC zmk0l=8@&H^DJlq`V_zKa(tK%Urbo9Od3mrCgjIi&0aei^{*cmBydOFMm3O?W%q3af$f{-`Iub@{QnP zNRc|`SqOvJlOv_f3-mHmlTL&t5chwQA99!;dh;EnoCq>=A3{EvRh68;(D0fUw^OMb z0S4orS@~X3M)eQDUmoSLGCTjQkJBUN_Ut~9SbC@`WW<^do0G~55}m5>SSjXRFnXhc z@bhmXFWHZ9!gdU8f-!8Y9qJo;xzuNK07$|=J{?h#30muAdK7brn%grbOJBp3wV-jVJH1nq&W-lbxn z%J`3|rts$zn^+g@MJ%MneN|+9xoKnWXW-X=6&;^>OG>a$8IIK4*P&85FhTDDGwz~sX+S7-{gjnBZe*jlrPH<^w|6JI7{c5O( z<7}bnS(@)R#QO!jMIBx^B=oKNRt%?g=?x7tx4J%O1sJT$q!>IgD~~P}E2^vIewz+k z#{(g|*HAMMxC=FMAa!(fDA3u{yFej$CdT>u-(}|w`M=6&xry5`?zfz&-{NNkL0jzJ z-rl-TAhc&3qe+u{$tc?T(aCRJIigN@2My>SnJAbU&|i{jLZsId8IThDQpL~!*Z576 zw?+8fG^nv=Y1h^{oTy1G*qah}lO`}#F9I*Y`9e1EHNapg9&v7wZ@IMg{<$-pP9CA@ zZ7Ys|%b>PghoU~(%{ti4v4KQ_DYsEwIOiMWVXJO9#vmct8tnJns4$L;M~GI2M}HJcLt=X0nW1pi&?aFpM`rqu-F z0_FOCfecm&8VKQU7L*6TB*JA>kZ!*Y6UPE$q@O*uX!ZTKX>}Yzg7kMPubS8+{akClnu9c!apqS*Jq#=)}a-> zMA2O-tx=hnickNxutS2>uWKo5J9{$BJCwpeFDi?;yD=TH9Z+Rwe%|}*Ufncl+E~qV zhYP1>ZOijFI)6hdfbKYkZ^&*}+gwN#V`^ipeW%kk!kt|KTw_KmQ#Zgpmv=r_h|6)wpWItUsphoT(nSjJ1GJ^U`WbJu z`-QS?KR6h#z3BhfI~s?B+et{m)oE{Z=udSx?sGU|Kt~U5Ad6KOLY) zN*oWZxzZ3{@RNo{d3CI?$Ro5*L8zfTLO4&Hh&l=~nvM|Ch7(bHigq|D!t=m%fhIkv zIVP!i)H^&pkel%;XBn<-n6o~VvDEO4qe5>>)cK=6oOS(?)yFx*K%zY!<3Rw~3dSrv zBMJGf{H)D=TAAh-gDd_s6SFj?^hlat9Ixe0$+uv|r#>#S7apwRiK9yh$8cHHKr1fl zE^MjuNll8>6!WLO7b;gTF1TzJOih4xYLJ9V+b{esPRmtWW?U1ef4sSP6my8^PZg1mQn2^GR^NR*sGy@kQI`N{R8- z6>%vpG>Z&FO_R3#u;f9Ew30>hMX`Rf?uQEpZd^^l79KQl8wJeuM~MeTWTBTPUDvUW zElnAM23T(VFKjrJF~-?nkj3nOBwgOy3tZ4#l_4W17x?qXEEjCi_u71{_%~0daKOJk za3Ey6aA-eF2GL4$@%v!39Rh>^IN7f9>ecsKjo#f%Oc==EK^R=)CB)RYInHQ=GBbB@jsv*}8mhWP)=R~>_6?~*%qkc|&WH*{&nj+Ty z(j|U73Tx1c<`*h79QEQ=K$=*oELzWttM~`wQFu9K1~2bTX~!fbOUD1^dK0gPnu&S; z@c1kvvYFah3zaMittSV;d!+7oS%3NC=}jHt3(kIjP_GZU{X z_Xmcg{CY-)^=wd1iK))HsP!bMf_v5+o9b@L?McbYD3Xix$pjIP-&LkV7`J52vxB_<{&-5*8i>8kn#4X_iJ7+&C`1xLfhpKK8P%vd9G<@#i_(?JS7b0<*`F>=`A0<)`xz zukLEf2fHYR&KEskf-KvJFrX0JOKTb~;GfV++y07R46tWMnWDrmu8hKUG)-aZ-Jf}9 z5E~^0q3B{77UYn3e-5t;BkD+ZyRQjN>P@$X;ZSt7gF6yeK8~ux0b>)7hESsk8#E z;){zv>7C5%&sQ^q672mD6H5Wf*5DSvEK!r}t_StkSS{j_fwxz`enn2eDEs61YB}hR zNdvLI5UcHzq{Gj2&nB`qvik7-{GITr7yd+YkMg=)I0d}U9Arhdrt159)i6`-6{GQQ z<|HqD!mksES7Wt8s*T01{La3bC(}78Iuv{#`&?pVO#AwHwo_`dlDWqx5?LOKsky)vR|A;0J#Lc38iFVfum6C#D z;1&kH?L~~7(;%@};1;OCx%}plgVtDKsR>ai8&%FN@&|4&SHBDsusF3zQV<<8?X@6vh9XgtS=BwOOc?57sl=1Lf(XAcXCLW&wmQsyMX zWvcHFQy%;djqL;c0mN5bJmS6#>a3~K;A4{9ZXA*WYqE7%_8C80h;gOoM;5}q@HV-0 zLoKo!gUURo1)4aByBL+CCG?cC;Y*)XyjWrM4C`8>Idv!MAzt@5K5MMC zr~$Exxu&G|1qM;4-oxRdRzrN?8U+&WvZ zXYnIIw%qyoMgir_?Vi*EP8D4m1yMWESHd8RXpPKF5Dc1Y-ZACUYwT_WBs@NBJC=(%slRAeYG3et8NwtaB%mWdRt<1h=`I1QnrY>hA&AuitenE6Qs;cQ1a3}5^Wqi zcfUafQmP$6zWhL(4w60g$zmNeGX9L}bqC_B&~uHGTwwh^k7bO!E~IGhr!_Q+i-g1p zf!t7{J zoQRbj+PGqozpExL`~=%fo5=A*uKSJlJx|Ejq*h+}cSeD$Cda?_Ned%&CW}qqr}0G& ze!M8uS1M5JR)kKsP3V_d8i-|Ta2OPOdiN(OuxQh52)JwfJMqw=}-4qEFBVr2IgS zw=YBE4>d`?Pn1;8^c8or-+`?bPYzwDK&QI>eRXM2{qiwaBcmIkpDV+flA?{7VHw3> zVijg3@x?`4{52py-^fEK%CQkp4OHs3FPXPpM)uCdO@PI}!Kb>WM&M}3jP;g7I-A{5 zN8>-ca=Bfvd0_bQ0G2_49^VK-JvS{~4#-#B{;^H;$;!SnCbv}82@R+wKDY3do7L-f z;yFAysewV_d!DoWQEm2fE%JU0MxXgJ%>}i{i&ECHU&gj!g&I1qn%5i@;l1&wSSQ7$AIA@9y|e{t!|Qyh{N_?$KBi zaY9>$qtAj@D$ z=-YdmIj?S}H@s=J2He59e@E-_vJr3(DS)Ab9v$}Og{e)7xR8y?IqV&P#X&Y%H5?tma_td8VBHM zkrwA*2*rDZw`Wr-__rC=5L^<4-qD9%v_74U-4`hX6LRla^n+|@IF1rF0*KF`X=1uI zJ>=K~l8k*bx*^}bNonhlr}qZ2Ji)e_dW2Aux)@jvWuq9+Ch z2#}()|Gi8fZ&GxQ_$IJ>dwP_mq&)s>Ha=iZK0$B*QIG4X$LxG-K;NAk!h!lyR!~ro z-)vOTAQbFlPFPO-bm^pMa|?|@z#z>IU>FnKYd+l*&znbS@0i%Uf?lY@1t4ULVvsq! zw|Y9?h#_>pDkD!rPuo!qqgxw*7&FEerdJ_B_J~zgNeK!kaTsw@>BTpr;S3)pN-CpV z6a&GaPp&{SpciLDk5q%Wz1(junyri_pRm1~#Be$CdPJ2@-YrjfCS|k)GCtfoDM|a$ zVwk~=<{JG<8*&dlU8zkAR`c+Y!*Nat1EybnP<;-X9=Uu>!EwSk~u98heiGIx`Fq8Mnc z<=VJx3kUmAXX89b%an8%_UmS^8ph`q2DnlLh)3otd!Fi?EawSw#M1>J?xwMeYBa>n zYQLo#yKn4XL@{*yp}ek4oP0ygADb9bc8|Yre`Z}SY%nY21*C<<0=AF_T)m?JBTBrj zs>MZmB;Mlxs)``P?J@Uhd)j1$rBLvJ`);bW!zwtUh5z;b&5H-tbBD{*q66`N%tCl| zwV<|^)*MIV|FFJAcU|@seySTV=luL!GuE06r;l!Dx_%D4{wTUvh!k8U7FA^Qe9)^1 zQ_GBeJ80(Rnr+>C*l3Qkwp3Zac~#mcM;lCeM*@h-C<#&G%d3DFYOH58A{<14Dvmms z@X{};Qc`pyulZD8#QDgd9v|T<3rEghMTa+vvSa2lh$jH;E@T3|5d?*b`8o^6fO`fO zx){+}7O&g2+W|Z$5s#^Vf072bu&yki8)787im%3;6fE-SRSSPIFu2k`Cx$$XF^%v( zum<*(YJ8#nV@(CC7@OA z9B#KhvuqF?(ji7przYHos9^ACZS%epXAOBV&oi3%Bnq|7rT1vrsF}B9n@$eTsLsKe z_)Za3d&h~~k;;KA3J)rEUra$3JV@a#bz@nJLuu$8&d53^`zCNR4w>?IDtg(B4T7iQ zI@5k|(c9GIzVQDrS6}uznGy#sFKctIUlW3RT+xkUaogM5gJA8tn!|U!Rj0pLI2^!s zpQTa=+?<-CC<9_ad^9kEyYJH7x{BT0IS&3;Wkhxk4h}#h2Abk?OUr^9v_?KlQ(E#2 z1xFF|>>ag~tk@yQZ*Q`7&1)&}xK*9UV!(!T?9T%y&(|HyE!W2^sJWV?r9S%iX=pVkvjsm#9zcl*sJ`QB4bWBP^MnldY)5 zN4>!bkQP~-{Zh-_FY4m=ebPXCUgeHZ+C9XYkPbZ`dJ{{&p>oy4L7; zpinpRooC!O1S59)@u#8XciK!X5*QxQ@BQA$rW;}J_7*YtYrTybX~&cQ$jC4dYr=xJ z!KP9`Ur$;nMtAsT8q0R)s3cNro~+p!_baY1;)QPTNpJT;_;5Rm^SUKgP33DM^oKIG zPkK|Kqmvay=g6zPSeGpQkp50VzB|FaE>0L1g8BuVD>=*73DZ;sd&Ogp_f0&-gtn@2 z;XhZH#Mj<=s_s$axM|{HTfs4m6WUjgU`3Y`fpDea54+Aq@5Fw9F;yPYvZqCqRK;#8 z58ByJLkZQZK6iR?NAvmPQDKXGrN~9Gh&%dPET2I@b(i}Mwsd=>;U%~SME!SgEe50& z=&8Scy)R}&ciH^kfc0lKu@oF>UP|ooa>aw;CxGz^)j*w{jZKB~ku4P#7~aw5Ubye? zpN5hea0%35-k4{w1L4d#>mX(dG&JgqY8a%)QvhWExhdL8md&h<^rVG{u#9@y);=R% z3@y|!P*dVn%31rfkXc>&$>M(Ip4k~kOQ*AhLBtT?%f>Wk6dp!d4y5CJw>@j(&8|$# z5UY{Uc(S8vyhNE@`8kd~%NW?f(z{6tY^vU*Z6!w(il8e8AOIVW6RLoP0uZO>bic_* z;BaF5h&m2wVHg=_?~-fWX|&Gz$Qh5_&nl#e&4=;^5BYX(?oNMHGbc$h##m z5zdDq-7-6^Ox27>NSMHspnxW?Xyg@C=^|;FgIb{aO~{8L;|R&R7CEOeAqz zpk}-3co;0mD7nAGa@0Yd7;sw1;ZlZb3HB%H-N}hzGt?Pxbm%&+lnbF3AWA-_?L)%z zI=n#?`C11F@K9uYDKH>Vy;SI$sj0B6YRMz~8*1L({X>ic+sov{F`IWNeWBG_YsDY_ zKE}Du{EQ6XZtJP}2VLqDjF)D##12$MNwmW-KVJip7c_D?j=|xLMWIn@3?b$3*Ny=2 zE%JvM8s~11V;jPn9G*E+G&|nAr*jg~ucJrqp?6tw=PYD0ibH-WJW))nco3N($AE~6 z^fraVS5rZR`Lkyf?V!T?snHB=ZHM>%6`6)c3BP-yW9C0AsIf-_oaVDn^PAftp6I_S zgGPWjZnekXKmV`F_9thqBfEPR0vIw+sBb6unVf*ulv^oKja3}v^yG`BnehD#%^_}J zxG7p}cqh;1HBrjyquQW@}~iBfpp$vrZvY@>(M{e|F=dMo+T5*#tTzLsz}Op0aK zs|0Vp2}!=SW7$0WE8Xhn8lV$A#6o1}<*Ik9JE|Pj*=?~$5%#6o)QW9Jp^M9(gFKA{ zZ8WfUK7$50HEv*ARYSW_`1s0I$xA|gWOX!OA z>P%STuFt{))uAxu`0ht>T#Yg6Ke+ZD;5f;y2#v=saMk75H1iC88_jZ#!CIo#_kvwY zRT-pRC--`b=A0iw%L{CPB7Fh|-TN$ebxS+~5rM%1C!)8IcO;W<`8fI)~yp4PO z7@5Y)@Ta{8uLF$7IfC0+)tqPQ2f1b^HTYj|d>s+&X>fMV9lB$X@Y6otr)+vX_2fK-UG&O^_fqAvYN&xwu0}ygO8%AB8NM{?>+S=}yRrz%2<86gwCfA1 zjnq`zZ?UaDCMA6%4_ob6v7}5jhrcx0IJNGVD<}wVcX2Wo3CG(4X&xvviW5yyp4BkGnhH8aE6Q(Z}+qlcj~91GdCV5*(Zx^nmz|Jq421a*!PdV=k40R8-g% z6=DGn3=sy=G`NFO7?T-CuC0mnabdWDeWc-AKgTS-PNysJHCC(9%jf>ZF~T4Ll$qDB-BtJt+}50MxDRH>9jPm zR_JyS;4L_RYF^Jrnv|^k1h-;3J-PgX^%}QqI&-ePKWp4JF1>N9N`knf^qw6?&2F0{ zsa(g~iSYK17B8Ld$h3GUe|e0(14T-BDtdQe}K|_gt!M>KimAoH;?6AFZUeva8~>{UnTf(w}&h(J9q#jLcoj1!cJ zIC!p2LxcqTCcw;MyR7kC!3;WgNpY1u-HaBrkNeR8{ zD27H;|G_MZrDAPJ;0x6VKQy!a=*-^qr$Aa%%FiqAQT2!k5RsfwC@^mj8xvwo%M*^Z z%lkulC^ef>&L@k5aB;sLjDe8_eL(}_&r*D??ca2GIfyo)&MF^J;)Ww1G!vlcY!6y( zh>%&hicj9RX7eYl>g}+3Pb&X*RIrBsy&s(Q`x~+=rM%{6uU#+7#U32QLQyZc3;f1@ zm0mqkxJbTwL^vSYzmn7F!f6>9Q}1LkEI7@f-|RrCEJ%z~MwuTZv$L~xps1a|qUoNf zc&Nq(JPVgG!ws6_QY;adL8p~L-h%vR98|x%RfzZrkFs589BeAZ3%+mqN zj(xyASyRYlFV>Gbt2!Ih@y{2lgkEZ%gH-EMhT(kxwten=hvg;%K?6`%DM$`wK|JYh z)`kd+-f%M=MS>c)Xcza+blo?u&){q(qCssDS_CApeN3_z(=#(BCJRGKV(|Z`x`6bW zm|Hnzuk#zz|8=kZGvQ2T>iYkr`E0ZD2RGL}L5eJBcQck#^bk~Ev%mGPLE>Gy^Z_>v zMH)4!p)LTuak=`n`A;)uKi8!4?8w;lSb?yDysB^8Gmdg)WkI$}gYfD!#Nn6pdB#_- zr&9w+9#_@nMr!C+$%9Un`sDkUwcpK|hqKp4BRlM`^y~VkYL5`Wgp`$)>@~=YzA0fg zN6>ArdsnlLDovaf4EMJh{&^z=WL$kx!GbM;^@661Ae*X|c6iTqC5i80(FAZu&IBA!0jTQur8AVtqdSS2uIGOK*mQVr0q1@D?z11WhGde|l zDo9oTz}6a@%{=)>9Nm%|xDiYN$z5dY>pcQrX=#-9U2b!LlTkAvwP>j`@5z|*k1Nn^ z;hR1xb%CWOD2-f7MM7RoY!7L+(~<2sDAWX`9v-)rE8g=Ew=?v!dVQYA+sjtC$j46i zv4soE_&t=hQ-V_prwA`kF}k_D7CJN&zVmV8Xk&cYZOusAMX}6)!e`AWc%f&*EZ2B^ zIzE8#;_E~#-(>8ta6O~{;Kn3au=i?#d&oH~u(E%jl0#!Mk3&g&aK`KmpRGl-6e!|~ z@pyyw8$=_os8P*d4ise6MFe8nlhfbHXA3M|{j$zK{4}CPOcW#HQ@I|UD9k3|uuS|e zHNBWGLgrNH3FPfxdHOrq_8k&-*jA1o!sH=QL=Z7r6avY#p+`V2NqSjZQBffzdH}|E z99cT%qn-a@8ww*b>Iqh43!tNcIJw)71~4?x(WF`;aiyxBL|qihl&{4qhQAq_!q75kZ|)t~=9XVN9&AJ1Bx0%vZhJPUIHI9wQ2(;x zlUPz5$nngdO7?$}sFps_KeBWwtP69RyRi|`$3QuH!WQt41x>4 z!?sF0qT1@QE#b*PFQ#Mr_Q&{X4VnqI8{=HxbOkG*17v!d%S}|e;k0`8^@rMan|||xeYj!RldzV0_Mp!*WcYeK+6V@9qo?|f(auji3|rZMm+6rRI$!Z zbB&B?1}G}Dk;hBPk=NAcf5IVKsMHhT)IS@eF+i;XnYks~zEouc)SfHVgqU?Iz_sc+Y+Jo3+C(z{{YgRv+x`W88lw9T@(Hm5Eb}12t4U z|HdKJjZT4BIpd9s%d|D?jZ8rtVmnFl;hO*!A}{_N1aT*!aS}naAf@34r4Y^jt)UmM zZZ<~Pd5yyno?ewxz~d*Mez*1y3#(q||4rW*+xeZ|pFfz6lN2s`G5M-GX(B+E>Qpem zL(^5!!gXt6MP0=@>ha@WE1=XU9c&x??|ML?0id0#C7?}HS zL@-14a!fX?kmVGK*zImr5N^&qA`~60Y*3iMm4I7X@l?@g@?bdeQ03XU+^^~v4}RK< zyH)!{e9B3m(~S;3i8Qq?4smGOV%1L(-jx-Vt21}4%Oa3>9p~t}gZ~r$+?6iKPM8@R zkxGfLbu2|To0RG8U0XIxVwx;DoU{A8t?M3$-A_d?4(G&}>wVTg6uJN#J|vWXr_EmC z=MbnJGK%#cHk47Ya12edRe1e@1kJvx*=6&>huWmPthqba=zKsFMp@G|U0^H99N?5> zEIf^oj=Neg3heb@T2zPyo;n!!*bHsT0=6u+tQ%g=R8 zbGOF&id`?KRtlgPLnAqfHoy)GF=(*U$kT9UPnm(k?zEJLqF1SN+DIwRBsrc?sV;qY z)V+I}je2qSJoN!KL&umOS0fGV>VR1eH7O-^c)paWQ zgQCwnivy%yN=Dpw?RY%_wc!cPi65;{1^=bzs1nV<$f6p?rY-7}a1G!RkMgBnISOh<@{jERg$i&wV)q=`Ju%5+$BPP=J6e;Wld7zM;2q^ zd9D}hzQzq;NZTiQNpMbmncTVpRIr@5bGVzGXw!tngG-fb8R99eiWaiw+o$}*osO@Y8DoGx9cWprVm&*Pu%b;l-24h zDxzFK7P%n)ja&j?wT;jxr@JrfWeL%KZ6ys0wAF}R&fy1xcx|k0ns1$e*{1M69gOUI6ShZ)~&;jURVTEnan-k z7;IP#Iq=x@O_KuV*)Zim$zRM~4@2>cen$v;Q{W)7Ox^DSo4*~CnYbRG?>E^ishAl} zn}=TJP!)B(8fhEe=j+fCS!{4g+5g5yQ8A*DT^2dt+pk$VrTHlNIy%aG!8|dB^N8Mk zI7$Yb+(F5C%|?#L^E<7=zfBOzLREZk9BRI>DA3`ORmsi~=kKHWxcRe!(cg93;Aznr z=I%FknxCbL<6%)od%d#Gc2&VZzM*v~Wljwo|JTzJ<=oC&lCi(AzQ8v6+>KQ7!uDW! z-0dwFMaRZ#t-|nh+;Ww zk8c?6ak+C%B(wXYO^i4+)blOZGtU!3pN}}OS$J3BACoLBiq$D$xe-8q;}cOsL*Rj| zDErRtwWgGrSC{ujpII6t#6L#4_bbF$>}J@D_NMkVLoBU&H2mdk15sN5eotV)2Ys(@&Wr8wK8F3RlO%3pp65*6ap z;#iX`r6aYCjScdj`T0LS{dMT*ra6A4TlGRiy}`e`qEhKO`h-qA>Q^lbA5o2bCm0Eb z-hyiFZ{>IpLvkjpjp_;M*f)sNh(htc92;mOf_6Pz_$s7bqlxy>a?5b7puYOoW9+FO zN$M7{!yVIRd%NAL^I8dD3;5ve{`Bq{4Qd-RX}>a~9yQSNK*pg*1N-V?nWyQK8=9*g zvm`2GY`=A-{36YNtQa3DfdwxsGF^K^9qAxfK3YugThB}?{ODxR^zqMb?93)`4=FkT zgy9f*LQW%OCaDHI3*@?8t=Z1g?`uOA_lsFW?X?sZ(gb)zxXMBy20KcoZ#HvT-|J*7 z39t?B)iOjEt+qGCjKo^>cbU}o5pDJemTl%TpVk?Q5lmYN6YR>hdpXBm<%njBz1QT6YxW*#XB7vCJrD^xQVy4p$k}%W<^E7a>$H&BJHqcKQ5= zZl2hh)y++CFjTMI`X9#T(NJ@vA_W=eE+;iJ0yjJ;nCnje&2<~AtGYbaW zM}3J!-PF_5W0m4L)Hyw#v@|m^lDd{xBM?PZ&3X{P4Kw;>Z*1(~E(#XZcbH5fQcRIRqg#O+x~U?;7n%XYpa04`Y4X9aSjgNq&X^3&GS(H`clzI2+K{=E=C?}CV67QAv-HOQ=KaZ zy)i#25;@^?PYz=9;X8_VE{O0yvS39^S+sQ2A>rlaQB!lq2|&O{aKRO_^X94|aBYWS`Qp*-@Ml zy{~XtgJ|?%QRgFoMjVX&+{lW_CHupplsIW*O}I`VT9hrIX!CuiedyoKjR!#WVLYes z22C8xR&#|pNlTS7;H&t_m-S3z;T*9RQ6`npiWktF#6JZB#5p4@-k8E63yVCGFnZgs z79~(_J&-zEi|^|yXl)5EkNSp0u%G4R!&?BP23Cjr?@$VZ+^324@y|m1%zzRmsURop z@(1Jg{UzsQ1Z-<5Gzfte)hYtZ%!e3`^iFhiYMB6}XOs&%+hD`3vBw2x&3veJnc1TSR zwK6@29`c$teWxVnumTD9LT~H`@EeXlprD2r$}aa?<*L8VJx=b~2_iqyT9qQ5?RxTM z?fl4*bzJw=5WxjCL_e!m@q5&#J%==;p2}9b{Fv6gcQm{E7G;V3YoomvfHGyC#r;;m z-O*&=nB$W!1~4OxmZ#;@=`)&WwxK) zsZG^ZHoV@A6H+HK$x0Y_xs~9nJd4@=^<1>MdVa8GOTfglnfFX<@Xe$ohhaTDm!C$!w#tPYzLj;Iva)v>6SI)4wGX8Ln?6 zWJSG*hMD7&ld3>!IUk2Q{dSj6cg9-HoNoN<*DOQ-2+{|4(XW5>n^D}#&;C%08~xi@ z7ajrGA`T2c5zK6hAYSFNjp(jdJmwABD{&f@)KcpN0cR@OA*wdnIXVAO5h>a*s|3jD z_7-_;ho^ua9=08|@&y9Du{;CDo_ewPhF7oZs|UMH%nT?qB@UbY83xvxK%RyTTP;O{ zYTNJmDVLV5l)TRJM=u^Hv12w`*zgwZI#CEEgEb zh;UkCTN`6`)+cc13wE7P0JlB^B0!{>GU|ADF|8^j=+Y;x!CO1x(ju)74 z`Gi4snRlxw``HIS*DPYzf+vbbB49Uvq&}I%(IO%1nOyyXXF4jW-ij#`68s(@HNQT3 z`d4A$AX3>XeiH0inQ5h67C}1vtgAnMWc0EZ$TM?SnC zt@q%Lrrqm$AsqSl+QUOci44CbgquNbuZu0T$3~1@?*p2Md}GP^p5S)D$(tP;^9GCy z;ev|upRWTvwN-};GQq1?0>+O`csIlR!rww_R%rWq5gXVm0T71_-*mr9|1)Ba=ds#X$X+pGx z#e>qexIw?#+v)FF{MJ}gY}*lMckYs zt2BSR%x)kOk(LGPYw`&*3jTsxwH5BLpu!H~JlC!zS1HAitkkOS^2@X;JHI_LSr7E8 ztrFOi&~{D6exfqC+%W84&tAc{nyV)(wo5KC?eX6lwi;t05{D9MLcYe=!Z%R#@@kbd z*l*l+EN%p-9Qw5~-?QtS&KUI?tPLz|Lh^O%UW7n3R4f$lrxTIx+hIIJVZSr=dwv8k zVd&}y%xjaQQ>|GbTFg9gL`_OBH6^B6ux@yILgHw|T+8AP?*xd$|FJCGaPMNV*VhZZd{V^~w{%PA86=`Ol7@G9 ztF5nsVaOV*@AogM&x#1XYO!6!X}`9P6GdLKfT1o*^kOsnJLFVAPsPH>C>2oSX9gqs z)lT2?b*uA^lP3cBY-8Tg-=QTe+-C>mS7N?F-3vZT7g)^4ANPSB9Hj#RxL5+LYQamV z+`OPIAj&rabOi9N1rIlvz**5ov&!o+))3YBM0aQ|%HHZ=A$q}9=DXjNEFRJH>k-3S zv-OuP{3yzqS8FW|z#jFS=9+~XMW!e>FE-=FV2`X)^nMZXx*y!CnATI`W1{k8a+wX# zC;h#CO{RzrxUQs_Ibm?ISG9VvfHLh&V%38_vcE-(F(4JqVz_-UnuP)955DA|tgVr9 z&5*(J4Zu7sTlIyvvTmkKiQSbqHGUe@Dk?w0O`B9F)-N^eG2AvOW!SutTE=-*#6h>Y zSNkVw&FHB8dSL9MpWGxl~`rgWF!1^P2D0^Hl+g*1}xcya$ zo&DCF?0&^+R8nOXE$cXWoSB-7j&RH!Wi_??QS-Q8o8ymHHtwzMH{|Jm64^pAx7-5{ zCYZ@eRgClkQew!=$+M2lC@bLo>siZYWhvhBkcu+f!ppJT^VH1(LWo2o31fo;TN={q zQpMk!2>9-ID^x45pUS%e-xNFgy)2GDs=cZPZ5m283+SIx4{?Sz$v=(N`59hu2L zs&9~g6=KJo@<;n67>WE0_`DqF#hO@C&h=zJ-N4uH{nde-JrU~%5weG8ku&slAwRK1 zbs{X+Bk=uA4&r{fY=%_KA77s#6x^I4EeFS1NlSx|=5Kni?2uTjTUvP%y&nksi3V8T z;TFu!gnSC3&TmExQO53o; zVLJ5DPcL!e>*2bVXRHsi;hMo?EH4r3!Z1Cf8VFWj{J~~v1nLz5I35>llnT@y({+w7 z!em=+B}F3Y>goesU3W8G1pmW(Nj!Og2|(p0#TRf_Ce3Ro;6Y4?{`v=;)ydAz{!I1Y z-`h!mg?5S`&Czf6))|WPd9i;*1-+o`fQ)_x04aD67*lRE|#u8Q2c~ zR$dGItv^C^LtO0$S=`K#=3-+7Vo5m~pMY$Q82icgU|ClUkbTI$Qd(zT4fw3353FhH z$?TEHOIGx^_31^5U{2?;?lRDOCDQE@tF5EcZS1ZEQNNHZeG>{SYME3K(co=VR+VgsOq$kV|IG;J?(A%42GjIkbrl{qu#pEEu-CAZltmYz7t6qg|gRu

3k-z)!tt`c?#+BS+3gWL!Y4;N`9`yf)5F3^`Cf! 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

)~NDgZ|Q!S7iw6)}k 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
=647AyP#5*qzVRxMWm?0n+-WXwL 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⋙yRLSi)@7Lvb}@5mG#(WTWOA3 zqF>UBEDs+&Mse?$b28fK;Te7Yk@@+MFJP*y+w04mleth;eHVM0C$Vo24vyM9N$R1a zeS?^p_u3dU&Njb&>lUUL+!&jfLPt;kpR8N;%uNCin)^R#eQ=R3(nb28PwZ2F`e5iH zU8IY2k^WlJ`|rPRZ^r2j%|CL&^CTyCkuK5?A$|Sz*XJ-#76~p)Q(VLuP{t&cDGQN# zuJoqxm1Qu_l(X(SAu1gZPWuJVeHWm+&k6QDR96ddb5!xP6$B_Ks0asfYsC9 zYyeM3W3{RDHPs2CtKx$B4jQ=?+*bwwTU#1YS5t+u!ksCI@pu_*)Ei57zUsq{Db(?O zQygs6BB{Ek#uvo`@ z3RZ05=O$gdzKZ2hIMO-;0j1PfaaRgqY6roL_i^RQXL$RqH%)!-sb4*X-~95Y_|>oe z9zXlpk1b^KZ+`O>6sGs(m!30~z-NB@6n^`gU*q}bp2Z6GOAiwQm469+S=JVR;#F z`|fdVbq|4S<{K6Z|KoKZSBuh+u^Z{%8N}pIH(V_!{f=>K7lv z@AH^l%l37zay}gZ@Vu_h>!w_vPMtVm9rWGm^t=q}|K9+D{9Z1r%20;??6-DKIYh8i z@8xsL_tdrZ*7VresGX_xlQM@$I)?H;`9Q;ANIq z;OOhGzhWS%>P~>5fK%0_;6Q~B7Qia7_0?B+4sGqXzx@@{FU{Wc5LK|9;8pc&^_TV* zh4HPYUuZyATm3os*W{@B@v}nvcF>s+ zPkvS~pnTE2ihC^Eg#zG3`u>w3u>Jl0C(aix()W|}$EHH-wzjm;U(OnEr-z_|^Ax66 zs(|`FGCFGK2-vHutwsGg+^6G$`m|pPfZ7Vu)5A!Cd-_~f7F5z7i2?$3Tta+cnj~P&pJ3`zcIs0=tFOxq9DuNZt*> zfZqau1_kDm=UasUcGUV50(jrT2uDrbPvUa6HAL|K^DF6!mvyi~6 z&TpLi#4KM2+xaKv|A&FEt@1HaUz*2Y?MJA~N7J^eKMdq=U z^4jNujzwME&LPhv$WP&dbAcJ#3i4Z99zxDPajptD!tcY#%yl^c;A|Jt(``tNHX$}x zi&(#u{_aDed=rB;2zA~=T%mxa4%o|meNy?WM7ZM?qCJ8E@0to=xTn�tXX1w?_(q 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

mgu*$m>2W>nm%jDnZXY^fZy5^`EV!YSTb8JV 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≦dS1 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 z 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

JE>Ee$lPk64`-^C~-=L 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 z\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 mcS1W#;Z86e^LC`&=Q>rgVq4A=i%)Gq8D1AO@ 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�-4iw5iNFLqXfv=^*F$eBkQh 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 #<79I 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

pDjxc z=xMa&y9_G{=3qDfm^phuI9h|?wUIVf?J9Y-sv5Q}73LfUxvj{wFKQDHeZ8pP2Xe9z z#mjRUDp46&hMCaqWQ}PJS%%=*RQH+mKFWH6SC9z5!Z_QJdKGgTi4zO0GIxD4KAI$^ zJ|G;pl)GV_4M%Ec-zphNm%WO)X^O_$m9RttH}$AinU9;HtM`k@lgdOj znMPylpp~SGjzK4>u%X*a&Q0z9vO_>Vc2HjYKkZ{?t}xVaxST z+_qk3M6r`~r^XrAV89O;!dCPvqcK7>K%Aer^g4+&-y9hgQaT%<>c7tOHNMNig3G7W zDp-(FuH2%Xq8X`na{Doi>ZCifD|O0ej(x4yVQ%kLve}h+!#JsHVWoGrx4Zd*MI4gv zh8}sfe0|Sh zf?u2u%~_X#<70ajUW7EM@L6`Z}0soGMO$3g<4qoi+zIQ_H1X&_t#+iYj=XzxrO@h!O51} zDA30|lrKquTt%OKy0pRZRxhI>*~-12Pgo%!#e8r{pxTWmlVH_5tCqEJ8(mL+*Z=1Zc(7lEoz)rkhBtxf)n_8?nAbj zsB0}P*Ol+ZdtjX_n=Df$7U9@B1u4)udBt0p_lubKx226toYjvfBq zcxQFZd+OL>IilDN2YcSnwe7wz_mE6id@i1dw|-7=Ye2g{3X{!aR##OYrO0eD6#$li zvkts00|`&yW1ir`#y`EbkQ;$&$u%jcojVXyf(Fk`=hQFl+H+26!Fj^hJa#W5Tklkn zB=_d8ZAov^KAcnSzEm>xuFbA+tF43=b3+bkRSNIGLXxb1!P30P71i}QnMJLYIo#4`9Am%r=gwRFc zZD2l7Ff|hSsjLbB@ZgVcud$PA`{$$L?lbx7gHuD4IR|RA;mV&&*mNg0&X^XVT5A}_b)YA21dmS-!8;g*QE1#5VtUP<`$GO3T z7e}NI{o0Yj2KRZ^#FNi(b+(M9#jQH_`ibBld@M8v(=tkEa;i~1G@%b{U&HbXBvdTr z!=M7AH_U?|6y_b+(mjj3kyY0oI*GpJB72rgPg*^VoM>KL4Q!h^)_zCBSC$Nf5CVYv zj6jKqXI@Vjo`La|TW6sh56_l}qJ)axeg*)&@sb|%Om9fNq+kX4rx9C+ck$mXz)M3o zhPVwTsP>=s;MAu_ZXZ$Z5eJR}RK~`?t2+sC8*TvRV4`?@EZW3qxQ#!Gbd3IeD}5_J z26P@&E0Qg@_CZkS@gM+qI8^Tl4dUrwi}NBcx$nsS4;#J?6p3?~TI*Ufg-P zNFNsL*lu=}AgWwk!)4{G8ca`le2140JhvZFU@N;jdD`@o=Z#KsLIssijk_vRwKVVh2H}p4S&Lk9ro`9*dO^po#2Y6W7)!wWgJYo=sPttQ z&gvtoJt00CjT#((2@@t#!<(KGq1eAWQPE`kI$CO5-tp9~;7hv}8e0WjcVWm;MywzS^d-d>He1QO>M z#Ucs*2#&7{PN>+!My;2`C{9-qo!c=P+W9sR98|SAVoW%$5b-d`Tx3w=q{jZCIT^=% z(q~5b^exz+1pZ;BnAGMyD@NVHQi@7qsk)DjYc_Kp5(~Pr+LNFpc>#4wsxU=|dUE4= zVlQ_O+L10gc`3l4xm_cye8FJ)O<2C|lYaAL$GOv#*Pe+_Gdoy}_MeYin}z@mZDS_e zUc;%8BqwLDpQ53ir{pDE7{LAEQfyjuI<{H8301MH;5xwoQ&^#!3sIg4ZVOL1DIMMH zz~ft27pJw)vr1H>$QA6IfTl;P{oZKz(pkQigWWW~HNDvt?Kr-@?@^biy?zmQli^N> zX8(~>oBEL&a_Ni@jz}uM|7S}@bT929%QUD!u?FD1XEYJH5IU?W_XI`htY|^cPi17T zhS$&9{6_zIi~R(g97K$OKaui8q?LCy^aj$T2b|UeX6sgcZgPI}Eh)|RZ9LdHi3mFf zC#mH2Znson4E(;OO5__nqT&ehR=v?O5t zgL7DH)~poDus(~E{x6};=KmGi+==(a;p(?@5S*Mm$$c1NDHXq8DhKGj}Df8R<`@6XP@xc8_#7^WgA7bm8`lUU^RW-!}=@RZYyHbEzkg zTu3obA!M5e3SkLw+p$v2SJ^2H0}CV{f;VOfeNpr_GWZIyR-%n=Uu1Sz$y2z}3E%;| zdadl?a{-_N;2o&o0sb>k6L1<|hZ!HYT5%l2Hv9*`k24)+`G<5N>|Oxo&mEOi#z(+RL~vk8-zjT7aUav*g-pgJj`i~ zi)jV@oSgH{gCsy?Q(W@gB_$p^6l?F&2=Rh*Kgg=eLQsnq&#h`a$L?ihs zTk831eYWa*>CDCHlOojrFy^jQu{@T2v8vUMJ)N1SeBE z4$#t7>D>R%gdQ~VA6nV*bdj%iR&N!pC_#G>Ej2^uO`h-J#hkKiY*RTQg#cKrW8jIa zab9A5;#*2cw6^DwZdm5kVY4r_gqs^xDWr{j`t(-%nw;Nt<=qF=5$jyE*rZKLJo9$278FYaSfVYJlmAC~?8{Ev?Xr7XPI zFOPLL=-CB@>Tu3ane%2wcgQhG0|R&-Q89JO^xl_gf6;nrR?6az3iFb*E*O;6%*%!# z!SK_RZ!EDmy0z;JRG4&#TL;cX`9)>4H9sGa_m_}V&=Q7nj(=~?cb|nLw5&WkVvHyI zfKE(%hk1rf(hucIdYMAc=j53eIzcY}Piv55z!N~LzBxFzGxI4(Z=^i<9J6$=j4>C@893JHRnGq#BqE^LwFe>YoIw3C#4gZti8n%ZG z>Zh>Rr)*V)0Y=*yif$6CSnk2n!s((Ae=58$uvLARxxJPDRJ97E;zDmf_Bca{8`b#n zRd{p9*5kq+2wCKed8PAQ9iSOvzSdO(@|s@5fJs0$s=(y6*A^xR2 z58VLkjTKGg)ONa_vV&7KMO$?Djb{-db*Xmaq+_os9#x6TPO{w&S^40rfgT-KGjSNw z_3%=*EcmNrMKjrG(Hd_oT4dZ0>BC=6JeEV}W^Jm{clF&yu3&fOm zzRyi!6T`;lYAbV%gWBJUcJ~a)`J8D3%{muTUZLORZ`=v1RB3jOQ*IW8QRYP)QPYKn z{#vlyyThWwX@cz4+5xeAz_oSl8vas@U6Mu&}U9b9wAXVMsflQ{5LbUdnSi`ZK#kXYv*fp zDdiV?fvaWI-n*VQ7LYvA)lSBs{Nk5ORjKu$8COL$V5)G&LYi^)oGtrz6ztEA)80;o zM_JQ1qDGmX=5(;y-8^?xyEfxqXa8_W_1s#J39RBc{t_0m=WP}`=C;AnoO>=Ow!EcD z)!lP(^?bLjLg^fuJ-x?knSuE`Fn#d$D8`FDyN+1zOV@wr3ZFKcFdbl*GS8Y;1O#?Y z{`J^+ZkA)*QOT#(3AU~cUSoz zFZXF)?1*bd8zw0(;Fc0Jge%D%Q38MuLQYoOZ89(nn0SBgh;J7>VxV=k%D-tt>%>f}lM|BU&CNW{*=L#O2ET%|oRVDNunchLPQ+^DCAhaZZIuuc3= z%kGRUI;jy$6WuL1aFW9f=And#4c&5XXkbC&rNwfhUD zqw%jRez3HrqWg?#K)0zeVr4yUuLto(^w_`Wy;B|+9-}e5j6W+s7%G0W`&eD;3N86{ z7Z+wKpm`B?_e8hB!lmpKf%|q94)+A#x7tE31H1b`Q=q)?+u=CS6zwYLEZ}!b>R(>` zLoB7Xn(`R%vaL_x>w&kx3qj^3Ceof;c1)w}#ov~d-05;Mc(*P*wM?cu^7*x6_C2TbC(nl- z7{b<}hrZwsu9~F9%9mU?FJJr9%vq;L7x{V=0@fR+ECdXQ3Ru2h&t(`lZ$~gitegv- z>`n`JC2)C3j!3=wShhI4=~q0weHMYw z6tL9Qh47P)D4sCni@&O1-O_37}+NLmy{%*~oa1R<&HQZE@SjKOmpGMvrV9vJ&iZMtl>sn|Pk8R|mG{tS zOvh!q7tnS>d}u`*EhVO)ZI(MdeQ_pP2D} zc#+CqTl=j;6LJPe@VZmYu8un;t|K={QN&M=|FrXJe zXxZsdq;ow7!bq$r0MU9}2_XZ7fG6bMNT0~0o;z%dvfJt6s=IZsiUH37(G63K0+00I zqHv1PseA4zln&wU2owNw*n#)^;rL`v{gJ+QLI&Wfb+Q~D;{1UtugRxB;_&TVjg{)% zepcNIssapo6HZXRyG=_Wj1lbb;Zj z`_BffM6OO}zS-CpgXvdHsYv2EZs zW^bqcW?%{FZDmg()1n5cJDXsf*4Yk8Eg_V>ng10V3mm$f*}u}=1y-$#^I%-Ti&TWo z9-}Y~R$8K>1xs#u^~>+}icMT+P1O@5=HFMqQ1{^|tC@2OA-w#&d0 zp@Z8fLl0XEFW!bR^H;!AO`_nQ*2{D3VT(ugfSc5xRIZ)&YeD;~5qB1S`upNqEyj`+ z=qbb=m?UvvUpS|EqkmU2J6q4hxSv)dDy_9MA}SH&qEmTfzoLHQYS->?l=Eoj$zU@dF%W0V z$Fc3bHTR5i8b1dot~Z?egE#4>ND};mPM0Ol>`A@AP9-vtSbP*!lz^oWKNsmAgO~!y);M|ZwfLcl| zed~JKiduh4?T>kJlnKoA_+Sy4IeF}Yf&yu2AnfZ-MSJ+h@$AbJ6};=dcQ4Ryz+%4F zCw%rH<_{gqSmJFX{i>uAI@1%{=r#ZlLlIhY99;?~G^LQc~?EDL!5!~{^d^;oyktlQtThj2c4?q~QQ3+H5FINs6 z$7^GL4qe@3$CEX00I$2Q_$@tneho7d+Vo^S=;G~h|JXZ3NJje=vEv=U_+_Rv_6^iEK_hXhiRd=hWE`!ov$xBCcrDF&a{-F>sHR#iM8TfIT^lhutC9GH#OSK> ztMt3Z(dDYTg<#3Cg#bQMTARIJOq}M@hELIq0@l?6pT{tsec}pO#C#=t;!@C*Cg%eyer(>N*Xq} z;ioIIJ{J@8q3V<)_-^X+6poT`Y)^qtPtGNCmg(FBtJnGtb? zU5?JW>^i3-$~7jCQnXA?0`7NASJ?%gB&|FfY6TsX z=j$Y%x&>RGTv5p_8S3{Ue943{DZ|M3RxlVVni9G<{a-D-y#Ld}GY-EaDk@6f+S=+n zRQrFJcNkcBE_eF(!PHvg<)-FM!{%$>|7(6P?G^7Y?*Fl`592cJJN&sxJu}|jot-)^ z7C*oJp8b=ALgr_Uf354adY1N9Dzd`vEf9ASardpP{ypCDGH*hTJwAa^Jj&EQbYRCe z<9HAsz~$-FFQ8;lJ>Eb;FwyL71puj677Zu?a#|?9c35?)z5@FT!_@gpD;jvd!M5RZ zMCMKH`|rLv0& z9;fsm-uKq}x58aG`O&A{gdfbkm3|180xg!SI6y4F>cH^ACXfjN(y>*VsKRPDrW7(< zHWzBC2gO!c%_H1IJBmQo%Fa&jHzpi;qbM=~4sjDp;{g|UZ3x&Zzd?Z$CH+PuB52y> zHJ44rHhEYAFH+SY($$X%{@O|H-|{Dj((Em+rS7{3^-LEq1&9HN(RR+}WUu|mG86ZA z%_m&sSs}=NdE@GIp#2P;ACAqRYLVsy_J`A^rMpA?559;G>kO=I_=BlZR=v+T zx0rCWVZ~ktS6-Ez_DN;$nUm;I0B;l3)ER#Nwen^Wj35g*&f^MsCw#`8+E|XTjoPbJ z3{g1-LNU-vqDV(q-%@;@(5b3)_hY}BM&)HbRY;G6oJuyAqG7B)^Vy#O<-jV&-)tn_ zzvGlls1LJXL**stEkLNdv~AE5D5|RK{2}D1KreOzvKBi9h$*3e=$hU(*y+>3=TF>$^zJ)Dl zkC&?;(w<6CW5Rl>K!>K`@Pu(HdIqL%oX*HXxDz%(o`CgfwlGzvhqzg7Z#6p~5Covg zGkg8Pv37b@3(w|OSfQu`L(np;s{P!<(?mKVp^uJGI7=IH9dDG zI(}5QdR>Co(uSWSFezTs$4>Aot2nVXK7n-KNb2@81_l!%Dkgo|{h)|kvMbX{x@|2J z5U#X+pLL+an9G|N$WCxI7z?DeTDLKe1rJ89ze9AzlCeqSa!Xn8c>pa?b7N#bS9XNfNk8Yr`nBToMTJhf%I5WR()-a(NM{jQ8hl2Syq2oB%kleKgT6cqo-03 zZ53r5lfcBG6bAlDgrO_Wu1sb_gqC9V=kcf-* zOLpt3K3tfhyO^6hMK7IB>&0wDRe37081|TQ<0)nXWFu;H>172mg|4AxE8ki3_1cXTSpDb*K^3pH8O8MHFQ8T2H5w79Y||E?OC5aRXFrEXT} zK^XCA%&kokmu5;SrW{&V$U&O-McOecnYT=Qu%c}I;BsI*6i*CzP$Y|Q2t zBw}lj9~at4kdv{-55zY&W>t2b&;qTDfzGQ++ozQey)KQa+lruVBvlsMYZtS%+E(8| zvbuJc3a_bKrgeoK{L}{s^&e|{J6vpSHBwm|w2-qiki#u?CsJCQuy`~0GhwxJC2>9+ zm5Jpa(AMdz0A-fXOY(DA9L%R^ngkR`>U6H!>Au$g>`;~-s^}4)6OiAiYS=zX6hLO+ zCQZ$et_NK!DjIA#6_Mpfm-<`b2Om3S$WR;FiKm={m5>fwyc_nZogsQ*S!gSz8wq^) zQ__;`%KMwE5j}GqzpBgS2I#Mo$l@)ApD`hbQDdgSV})Ac-eSn~?JkR1U2#N$O#Qbw z4REoZUU_Y-@ZigOY~t?tm@(Y%C8F}sdi(HI-#(qil|Xh&dqTUuF{_%Aq3T{Vz`l%S zP0659dB(6$4C>@)6VznOMjzaQdn!S9(PV- zH&0he%S>!<*J|gT3fZ}{JhgO9t(~c##fY)9QQa0`7btc8s=iUlP?$+~G+>!dY1DfB z3a;z)+{hl;(NR&q2MY-5$>qGv%=GAR8nen@<2oATRa(=2FRO%dj(B^Min*&Jp%l@% zKjQ4GjaLJcc9?IBRaic+o~FmSRmN=&gCFhBfR_ZV_~4CfQf9>x2}vC3>8mL7XPw#; zqNXg(*uGy6WiRz677(i=i4yJ!D|cr_a}ycgtiDo%t@g`$v>VZ5t}DKs2??T9zpuvK zrDeqRDe-QdJp{H6rsd6z_i{8()pk~E6!*e3ZCr=Ttl+jNrJVELe|8u_c5|u#B5)RH z&E_h^OzL4iVQW=l^vzn8xF)DZZIvofXXnH86)l~$|KETws~H^~^<%ME{~gFL|4$(Q zNWD_+um2(DoJnIj{R*WCW7GdjR)^l3MF-%Re7J6M=w^|PrRAsg2=03RZy9ZO7rV*z z(HkxJ&JE-REpbV<5B>o0I#|>KYInFea&O@M_%ELbOOznfHT zg#R0gKOR-kAD-pQUExPF5TZ(t!$PEQ_W{&Ev7l6yx2@u)giLz!H3JtuAj=hn>EXIo zEtE?^Z!C}it|K0tI8i~p?;KfEzhM0wY4t{Y(An~6X}Fc!)b`$Tc3JL&!%KApIFBKu zOa5@0TDWxx40ZfmTRpf^6kAn0(sGw=M+{8iqqh>IA947vbVHP< zgR3gbyTh^S_(O4GU)D0RA96)rlUPq@IC1+5TthhdV+}XP(UC(l%c2$i0t7K~*wtEyq|Jl~0xun&+5bL#7w?qx!?m8)J2w8ouBpEYsUG&_?1+C`_dn1w z-1eVafqvckKZLf63KSDoZp`{URaCxc6XT(}nDq1(yOQ40v9m6B?Bwod2%u7;l+9)V*9;{?15!b@6%KKKA}Y*Mq0fCLQ)pm;JpdC z3wZ#!MG%%}LTlxf4cC8U052zf_5=`kM~_6?D^-^t)Ga#={4HV$e*8NqAAiy#fdA?f zYJ?v0+-`72KEBjHUopnb6wuIK=zP?Wcm>KrEG3K134Y}{{AmZ~V7DkU4m=avtL6^6 z>R2?g7$tN$70%|xA8-)eHFFryhQtpAG{L-YaR#HM+S?5S3|NVflA!HB!JCc6@Q=Gj za*4uXWjL()xsUCT7q8&}o-EyDmCJ7(37X%!et$CzY`5Pes7sN|Z+#5!)GJ*fFI{8T z{B1EqW}yL(fQqJ-N3(D4&stDBnC%0Afr{R@WeBxy9%x0)Pg=m5F}@uWQE}exRr?dk zK9N+UL|03vxpennrs0isZ#C_^(RD?kLKDBJynebSQZNr;{$E!iy0;|)Is<#f!g^IP zQBP?XuLHgTJZYSYXcvIvdfCDfz2gp{L*%2LLjLHiL#aNO#3(;$oA&NHUzzwbiwV9k zK@>&|5gr%0xq5BZSZeav)f&KuS*S+Iuing^b20!SZtU*j?%mKdJ;C{-bo;2T(9KzA zV25y702eVltbOAUMf8)biabs-RG}o9B7+*BH3M{S7U9u1y8Q{a&*%Xf;;2gOSoA>a z7^z};2ny(F@6r~0A+~=rlD;{LndU8+w9q&rz(P@( zM-hll!{J#+scBkXOe{sI8;Z<&nvyd6$62WI?1&d|qJ8pdocOYFlQ(_HIL#VvR_!3G zy(^V(PLz6n%ck~$pxrB4L0IBqBt#=@Lp3vBrvn6}( z!j&uB2q#F!T;%&(Sbd1~&`p9md(u=z2)6zs>vmU$f*_CQ(tA}im9d~SSAv{stZ#zO z9$d4KzC0^k-b=>p-Kwfq8R0&!DP}p}KDFU%5N4Ga@bL+}&O<&lsP*zTpt?c>`g42+ zGZEIGg{IT&$B_P=FEm_d#6xFsEwn7Z67?6S2=Ob!x6-+*0G`3yx z=WWNld6<V;!~J6t z8p5de7fS3Ytoc zvy{Ia<%;-Jk&PSHOuUd%L>8qK1cL?UFsbztt)Zd57b@%T!PD$23`vnmg|B1cht&7S zxM6#u!vDtccRg++{r&wbwkuHE6?vKebFqJ$nmRvLkK6x%TKSino};$FWR7g}y)iW2 zAKBli_ut>-p6o5|^yTK}dWDA8YQf>lMMXul;#RL=@GjSH-^>GeJdUG%ZQhe& z)o%*#7kLGHy$77m(+fRO2c!T)fVTH%?=H~HzX`?b@xECy(onl5ms=?^*Cem3XnCPA z#=!_OeBD(}W#+t_thax%hJ64OF=_$O7byUhkJ|c;l-&(J=O}P{si6450S#&LZef5i zQ~#VYup1Q4A8$7s%89>bG9h(%Vlmrl7`(w>cGtLW@thtiFfwhWwhH|ucG$wfNckcw z;d2fMy+A4puqB!UP=~iBFV@)~7)!5Lyet6$JkV$8ipVWRUegxKxELq!&pmFbMS^LJ zH*@*M&8UL*4@_X$Y^=JDh6n}njVBg(oadwj)Ymj;5}h9&w<5^j8(tA6Sav0z-{Hrd zKpZU80NiyzK%tO-T@G;GQo#gfGcJpy-UE9H@WO8LIl1+!Bdwg9Xgb$u0;#jLW!?ap zGO>h9*$1TW042_(Y^taEX5nzv64fX5l2z(5&0fOF?g^~^V!`B@`Nlrr%J|cU$a`#c zf_05+EEF+j)@|9Jz>B}CAVt`g2b*R!&;4u}X*XV=wOJcu1s`l52ZX(_T_%k|_+NS~ z^JMo4BW)A#q5V(gIHt(T#B)`o#=nQYGJZtCjB_t znEdtYM@<-3wgkq1SA@&zkqiF|`ZZ~X+_OA)jitlja{f=m-*Ay|(8F?KL|I_zsn9nS zJRm3IMnz-f39iMy*I44l#|xCZ{qTUZ$IO!o+jnycPLHcy*{GC=DFWPn;6epY%>D(5 zGlka60HRicdji=!K>i6&Pq&ZDCjc+Vdi4T7->BhFK>p#T{KBiq6x(sZvq!|N`DS#I zB#9@X9oX#Fg5WL8F6R~p@cTtw-(2(jA0qbeJ0SV}4Pg&WPXdHzLBZD{=>4{z8$YNr z4D&XWdbGc}rW;bzEF##Rw#Wr+)5W@5@AT`i#>d}iJSmoFIV3K@mofU1Z2r852~ael z7BqV}Iek+H?4_Zd^@I?CQ~|b;8WJ)SdPdX-RFe>VclL}g`27S}oPQ!al>OVPN|Kys zibRB_=l>FRxLtUcBg0p7&3v>ixolSgjvS*TjPx6|+u$}7U8&ZwK%KI;S&J&|i7-i}5 zXm8{gQXZr%|HK(eoh5cXESJo% z_slOLM@N|E4pNREg@(!&4FJ^n>q`m2AE{Yxp%zoFok1^b-%R>RS-tHTlA%QH|4dQ& zyuRXxtLTrwChfGieeI9i2};QJ(`3m;fxbWEbAPOa51el`%d~sz(WR1Hak6N#{riZQ z%agjD_pS{3^z-I5Qe0SXFyWMr1>jrsQ&f$XZF8bm@Wc1iuxXbu=l@66x&Jf$|Nnm* zL*!6GB9u_XG$H4eqJvY(`B)6)RLyy_O)B+5$T`OjsGNt%XKb{y_+hDI1>1 zP~VzfW!UOq+R0ipPS!K-?FStLHcuMQ81QY?!D>3dcY7u@s-bo$jo(bwBc~*#7?Di9 z$qWfr2zjd&^MEVvqIKqhqiuz*a2nCDL<_aP^SmjnVRRxx^^qPj&3v$GaPAROMDMjs zi%IGa9zrOdGU^;>?oIAF;he*j-o|bY1uhNCjrKTu<^>0wwThgz!tRZwQ->({u&yl- z)I_ZadSce^QDfCuDWpftzHD%q{gy-9@WsryeL#k-A)ok7uh9<;XK%!l{qn;}#z^}v zXXnUgvPe0nYFhumOkMwSERB46V!NvSORr^3;Khc&vN^y}U^nBrnJ*Q|;SNh3}mCKtS zo!h2v`*mu1XMp@-grBH~M0qf}U3#Tt-_u~>y)fu!&|=cJMLUQuwSA0I#8D&;$jb14 z5|^w@a-7gDANGBl@RHQY0N5T zxkd3Y9{5EJZq96%wm8>`j z=7_km?24+@o3)EGf)1AvZfU)BbAQ*r-_7Zm{hPJlGk@&_+iKPcQoSk+UL`XuS&Ul@-#Uo(MI@xGOmOoV!u2o`N2OD5 zcw%a!vV>%!A7}XrP=u?B7%HLpa*uqvaSyx-NU!&wj@>7>#oCL)pjgpOFeCa+?_*LjJ%3EH$dH)HCc$NWm7!+GXuE6ZM*u-N+e`+#BLGQf zExiqKp8+|54Zg`YQCd?guEDZK&UO_?Gj0LufEPBu=g|$L_j!&1*B`pq-5Vs8{;qo? z$P#-dHl0!+(Ej{&`&k_gO-IT@K&_T`nhK1b>%Lqwi2<+3<|Xt>@R5#Z3OEP@kNW}h zKZAb3VkE18ct<%IdmwD<5mM8a@Rr6MCHzngfXywQ#I)Y+{5p6BAy*E9^8L!yBz*|4 zkN{kVZvw)A3jBxDyysQ&pFNI^>5k8>N^PN3;yP@_vzxlsUk-U$V*f$@xsBl^@jk7u zQ_EMgikDT0@>SIkGLY5WjZ5h`GzB^Mz*d*{xA&h5QCBRO6R&f#C zaq8~3`7sqYv78xe0DuxV0lgx)awtqitdRg6RV7<`zApW!?)p&G*Z-#>LZVUpYXBw6 z(Ou?|R8>#D2W0X7KiM7XHZR#B}f2<>ww65BjOz5w?{$Sh+c;h1%HOm`XJ6Jzo zsa;8=2I#WEb6~l5yB)_laJTI*abMO7R1ubg`V*xW&~xIL8${|IZ=SwjMWWf2&i}ns@N0o^`+McKLT>5A&===^sD1kN6RVGwKPaD0_!cA2k zTEgb+n8;;-HUS2ST@6E23qLcjJL`WT)dj{#3g@Ra(hUJASsvSJ*z2vEIdLn^b~_`e z`d*sPhmz&JZPi~lul>|P6M;*s_tk_mN89LjGi@Db_3b76YpM$UzMyPaY5kpuHG|f} z4)O$QC`$Y~#D9)O-MGe-vaf(&iIgS8EHQ5w;uI^bk&-zYhI=#C+t6JbM)?ICk3<3q zpIFDW(!R^v{;4OXyUkE#N;KbOAS&&Z$fc@{et>*|-Hr?T&*KA4Hk`m!(S8`r?3L|p z6Yd1~$R<8t`FOM1q)5Y!Tp{Z4%m`Djns-m%;o*|yW~=ayA0gecdq>XW=Q(uoZdi&! z=3=04@H@SBNe@1JIRX||C0f~B*jw=_C14R8 zdseRMVbsaMvh{`>|A6mZaMWRg#Dd_5^x)Zg2Y9^pU^;(ESHNpw$3i3bnyfiK*n16W zSv!KZ2Un?sTfWhHDgBFNOpZJ(SC^)E#^{V>z6V)5(1m4wu9q1*B+X}0jzlgcv8R9H6l?b@m;$7`wpPt}v-#Bt`bIVi>A>-lCWaJdVJ59SDtY=Yqtp3) z(XN|Y?q|eFmKWD{g}4A>U`Av67(sS2d1dwQ%^k{cg@oPml;u)tu0ncDcJ2IH%--Vq zy`Z0zmI-duwH&d5gEh8=w#Hgvj>LE09Dmu3H#unr*VwzNFi#4DCS>B0Yid;vgNS&0|a}S}J;EMwzDlZvj`Ytt=_``R)oZG`x4SChcDV%}!6y&9<4h%aCfsPgtamB-7sX$>_cJHco-$PW(?nviUcq#md zzV7j>!q|VBy5DHn27TLI%#z0c^~l}TBNXML)#g59s+s@#>Nc2Fr@jrbSghp)_FO`4 z$jJXh`uIMX;7f}3|7X4bS5j}Z=Y2rG;l_j<%n<2lS}3{*xw8(}HZY(H@GS8$O8ym`N564=Mdexbog^d?dERphjUsVd zTkp#E9JX7xhzcwT*4$KOUf_6Ep4)j2xo;221%i7XnLBd+=tc2Wn}twBh1F#Phe}U8 zhcLVB`9x$m>4=xTkiEN=JFzoMrZx@&x=gYFeG|~|pmNmewFQSKzC|oA-JNuE7d|8d zB=Z>x8-c$D1UmK6cNZE#pFsA|hj$+t<~{vOc59r|(oW4Ey`HrMQs4t{f@xn?53mUHdPUYFY+=6S1N z8yajK;1{SS&yXb}APPljgamGU_}CYBvdaBk%BBXsF>s zPHF%q@=JrEO+={55O3=9B@RRpysr_`^>QE#k8c?5{HuwLnS_^y&)zSaegXORJI$sN zj8829d+LuQy<7PDv>RnIe%|zK)<-f({b~Y! zDE-T`MG3e42S6#jax^^mP{LD+=GNRZ_Y!O{@XnJ+zGr#~`T(oB^DN$xFOLUebhx(r zMR$3R0iLxgV&y%V7bNQWzCA%O|d0*`(KCg}hZ^WZ9jPCm#}UpU%I^oG41zN)=0StHfKcxV8dX0jX!l&tjLu4O3+d)DEg`2`l65By@50!|1?PkvO*(T0Zwa;1`a>+{jjMbF>Z7XSDcfZ#o|{VQdfRx&ylS9$7c7tw8@Mdj0=l1}#aUe7vJZ@1TW7h3?RI{zUL_3vj7U+Nt~bOQM)H~fxuzBf{0L0qPf45DT8k``xc;)-d^9J%V4GIss8SFNpW#rk8u)*RMQ)x~Z@V)1 z!!SMu4{;sbT@)o9Z7+l+{%PC&$pZBb29u7H?koa7jZClprAUC?Q`UYWu(wGN&u-!` z!z^|UWT!rFg&FFT0K2t&bsA1q6|oBYTi)S$wo8w~#+mpvJA8{&SV;Yv5><+NG8jv) zYp(-gpTD*j-YkHSGZNV2P3WDPUg2AOPOC2Ptn_|bc! z!n^MQBq95U=^7PE{4JBYnBHrZAV6tBtSvT&y&h0a^!2EP*CbP@O{KM@`P@1BzrG_lDDkg2kLXVIq3yLeW23wH>yu8Tj@2$;(H+Iv;im3j<5$AX}h-=cl$l1WO;YFL>QSvyau|rX{)f(BvUEOJEi+ma{ zc0I$trBE2YuF^2xP4SUm8fw@`&D8Z>jD_?QNG;)b*THsF!j|JJUw6voFlvG{eGm7P zh}w*?WXDhZe+PZc>#o-Ih2O>hYxuv*nmAzXuZ4|!_j25}x$I(5HwN)wy>`OE+Xm7mEc3IDsHPmbhQqbJN6|?q=fB-%dxV!t^hH;a3Koy8Fl+|7z-l zrFu#0A+nS&LbI&<7$_Lbosz1+64+MpP-y3MmrKOs)$Q^?&Y&<*uowqO+Z?CB82F%x z<`C!u;Fr5tRn4X17mFvI1V*@Cf3-zi0^9mEO4_Lh`bJiIF6zpe2z27RRi8dC6O4Yk zOGi>iIkteb94RBae=G+)gYqgq}%qH zqIUAWfSIwPYO`ofo~>%izxFi zf=t%(oYBO?>f{>T3nmMFJ*zJn+29~jx+BZ3O{j7IvhH+t`#$%jc}bvSq|Ik1#w-0m z2vF-ijoEs9rz9>$vH`d4BN{H2uQs&dVK~?pip71%`Q15kDC2!e3E(TB7(kTs1)ht8 zWSEI3y@O(4zyVQtu?&AeY*VXotM2PSfG3EgE)0ZYb)qnmN8y1w!>(#h6sq$-<3Tgi_)A-!?jhXq* z^ZaM|>E7&4(=s&+8&W+?w$4>6?BQX#JccA__eNb_~dd)%6W<t($ zPu6K#0i~l|E+m~6Wsc%~l49=52XkKmCkmC%0*+ry4(9Uv{8&SxKw>^=%@Ez_uO;my zXU%96ow#ACvgfcif|A^WpmBy!U(nG=caIv|!5X0BHfU+?^rOxjgK%FD!qaW}mGQgc z(8l&vZ_FeY^N&O3Tz8C2XGyDC#|-_E1|BbQAd;6_6-7kS&#G!t!qPr|I3|b=IdicfV zh$R+;o!IqS8bvp|IeEB$#=DIeV{dt?rW~^2`QBwAZjbn_?LJQb6}Djq>undrimP+w z@6EmkR%xXdy{D-rmxnL6wA!T=F33#sx_zzmgMel9%jyzUVE>%Ql1?*Y4b!AMs>689 zy7jAwO$joS<~*cRt7KG49gp&~vFvz}KaMHL_yqYK)07OQ}OB`(}tzgUEs$);6( zv7p0m-4r1_D@A6Ctiv1j+$ivBo7AvZFuV*~yZnU59Z_euXFdBnNN#DMsOiXYzP?wkpb#DH__nQXv)4g^Zbs#6+B_QI zj0wRBPg}Nu2T0^Ck&$jNkbCA<&K~^)W?!e_^Lpc1Lu;Ks$}v(|Nf!bF)`R_SY?3xW z=+13BB7>FRiR74}_Z8hJoh90G8y!h^h?^n~+^PIME4u_6!voxA$2O(gBQmmX6R8_0 z3tCrEcOzsSSZroA)7yfi4|<)!j-8hj813adp>iGF7d%%gmPzaTmnjcWKYC|x!avv4 zN-_TWs4gXNc&8-B=8rl5X^N||yHih$WR?(@&8}-^*OQgM(qCl(kBT-OJ9Q=}Gzh3G_ZKX{~O-+PI_?mAkp*@tm)04Yj zVQ{bg1A~@dvnmfnMj@CZl*B*E`R>b70{PwH|Cpa(EENyc&?w~ID#iUTi-3)wByysI zMIPA4{9r$&<_EbgW^q}6*Nx^Ek%Pu;&+LuqK?t*jrhko1aAm!+{%$|Af}y;Tf8tN# zbQbww_PdD_Bk4Vcxiq>cpblF2cGTTLa(*ezL2JMBj-T{mZ|FkpzIW^Wp)j6oUpQUr zQmvn!$J&Fzi41rxXE-^+itM|&qn8Yb25}i()xyms#UfsG$EPY>+;u=!t~_WS-`JUN z4(?6!U)m3VzaM44cxzc@IhogPy>pJUC6KWnA zmLWXaFO~k<`EbzikYFV{n27<%j8R-aSJ|*4X>=dAm##l|bgMk$G*Gj(8p&0K=?42t zwUwOML;~@g>;m|L!kF-8lQiCq@b}`PfY0Gcf%DhXn-cFEZTwA@_-EwSFP^zj-@os(GBUzO9{i`H&r$Kn!$(tRxcS5WyS2}9IrNBJXVq$$ zx#zi>+!4sfj-Y8A7v97^H2p4(i!My9ejUsN@9VA(69yg6xxhW?(GX_jRaBY%}L=mxEx9 z!AL}4pl>O3uMSgDH4ggrw9!rBUT^5N}u-o~A8R*YV8W^#$8>cHgBzkYE2 z5k5#;jFSVg2gD}^Qy`yH_2~g}fiX@M4L!9mv7{(D12lIL&@?1uC~M`V8BmjXBO#?j z`nV#At7$XVsgY zbHu5sZ5^^xGqvR1opw&>ju++#_%IwNr{8ezoE0<> zk9OSWL<@zOgSvmXh$D>WGg76ua(x@Mo4Bn&omCbC$$?c`(E$(c6*|S2=6JnJAZ7T!-0xWQXUu zI^0Bg~mGo}rf=r=Y+ z7@JuKeG;Ji14@a`QPd};QBFAWM>nmTgndkDo!PVbK%__Ate73yA~cp ziJ?t(nT|KoEw-k-mGJhMVJ5Rd?MzJRQv;j7 zYk!%b#u5TfpPf+?pzSVP>4|5r3kP*Kru^RDUo-TNnkla@*e+q^q}F@qsrCsuT=lBa zo;+l=Q`qr6lI17>@W#}I)8-+%SgG+ZH8!nfnarMFN?d)jhI&Rb`#|g zz>m3q2(nB1zi|GJ<+9QKLZNB5yle(F7(DeqjG%h9CF~8M}tbNMsQCcLI(W?(kGNZII@1X7tYxD{&WI0f4j9r z!+rPf3jKpCb5cICUh51bX_efGmAU4&a9Bc5Dst~M!iHzR8U~lr*;@nJ95oF2wHd{! zZ`h`d%*CyLR5cFZ(sDEa_D7xReHZHbb6g$D`76y#+V4yP1x(W{yox5&^0A5zft(UK(%QzB~w_{c&u| zMgj|<1Ops)AlzgWG~Zvl`fGE$IUs@=93=`AUn)}4i9V~;C?*wx9!`IiB?GW((b_rf z+tM0i_%?uRDoeuP@vPR6@YcU9Dok4EVO>qqP4LXM2{2v{q) zO&U_vD9oaS&_74E5qe}zfCC)S-5A#vxNES!du^l(@V03pUq8 z|8rT}=yz`~y?-YkKItLr$|PYZuy!2j`x1xw7dBACj^cU&&Q6f~sO4 z&$>LBMLbzrf8!Rv-}4UD-4LKwokbK?`>AAf1p<_ZoJP>B39l?KGhY&%wnA52Lwwg% z8l1Xvo^+3YEZ(1!^_f$gk~^xFfm0)C%hB%O4SWR>YAzvm*mC?-qkK;qwKy*4xX zz;piJnBT&@w<+i*sPW$xfDxys&*X6J{=FRdHL&#$nxT!Ug6WWS|HsCYX9A63&zTx6 z5cb!*mjC>D$GPS&gAzFnKkCB5!_*Uzn{)?Y{6PzGTjF16Uk&C<`M*yf8tx$dLpT^k z2F#L}!7OM0J{W02>N#@%+DeAu1GCUaFK>E85+A!2HF)*hPHFD=)WEgfTO~t5W_W ztd@X)kUtlY?p-36sx{zQX*784iDHrv_GkYoz@#6V>*%4?8EY%M{4MulP?p%&dLPP? z=OqWH?76{oZ@qkFK=!}@M`mYcQX0MNW4WU_c_LFG)xUk`;rGeBfn~OiH_i8Mr8m>^bBEFa??`!*Z(+GKCy`3%dft!&2of?fhXabFUefQ5nYHwp^xaPwW#;og7q z%BQL|Wyi!;N0PUPacMUUU;8VEHc&tGR$P|DftAWMo)+fjIyMONhh6@o)QFdR5`^<3 z+3$hzPXCmihxDet=Bnt7ICNKjYNE8}FoY=uxZF2#d>ZcWob2!g7SwO;>pJBs6ZD}I zDhn()Q~{dTd~`ytrFFp>_#O)$E8Y;C@SgYf6?OOi+$vVWi&uB62UZ_iwbGJoD0HHq zD8G5zPR?ML|1j_omwSQ1Bz^WKJz~KH2%g{Q5pzmQRa#o5*S(=!R%(dT!rqD5Q$?hb z)J5JOHrjKLsQ=>_rP6FkC69E3@r@OH{P1LIbmxpLLLytq!&l(PlOTZoR|#URZ6wzU z-*lIcv7NXC(D^-b@XV58$c}>(^8RzWR(?wg4^*lqieg3skp2Xir37Ul<)E-F)DCu1kIJ%P zUc%o6R5}^1ltc}kmM`epQCBchX}&jDSDI9EM{rK5>exv|ZL9`BpUnq|R^^KN#d5AX zsPHwU29g1_n(8<9Bd5pwP7@4uFEYVPhKYaRo&=kG%{}8Kfn0$d^WN?9$1CJ6@>_w` ziSgMdOM076Cf_N4J1z+{0WIizs=1A5Lpn2nG0qAqX(2k!TqQy3*4-&A6sC6J6=b zEZ_$IJf_ER$H@IE!-yQX_oxH%q>dM0K^$y|QW_ms<|@44`6EjjV@G>8|Edzi2EFQ3 zw*$Aj&O8LZgNvwD`XQ_(_UGk!=-$0>6q&3 z4SQ_2PdP$%|2En}8h#K5jv#oSd|}_rRiZj<9`ki!t%sj#oVsiRBhR(T%(n0z=-pXJ z-H&`T!QNc|z@n#?&tQgZ6{}v;Ke-?_Q~J{_-b6<(-%Rjg9~t zxilAK^MdaDdqN%9c&VhLCF&D)JqV}L-c%Oe?uZa@=C$*z_AcqsYGW8Ti8gPv8I#G4 z6`noYD&Ds_M#E?0Z%)Y!A0yDibN4Q^@4d$zPQJYqX-6xFHZSxPy100FuoI|qxom%v z<=^$f1(5*xVY;*z-dq2Z@$IJ{9Gml2`jxQj1EkM%3t44A#mQ$!J)%Phs_kpPRi%ji z22JV|kB|<}9N3j(|60i|-|v|N{}Y`(HLT|(9kT}5o| z|Jn)kU_3YfI}cE_wK5SJ{VjiQ!|h`vA^#Uj@`j;eh-&WPUdN2Jt@*Uha!O zOgZF`y50yoJG)e!AWk8`$<=kawXLneh&5oe#AXo>wlGt-bU#b&a5?Wx4&(fq*8z0d+;WnLa&GO}tZdFeo$nM`Jv?(MxzXuTyr6D@Jy zngQnKPy`@yaxhs^+#7!thUiWc1sHa2Kp;q7PH{ArBsF;}>XA_GPuE#eDZlO^I^S-u zMSMt>FC!Jmcj=1UU5XNLNV)2q^}xHsS4PFgM4i9*!RPG&5geg1^ar1!e?Z9~Lrh;n zPFHL!fHDxrdzaT!?(5ylqhq3epkDwJkxvmDyW!w2ZeQ^HiBE^F&sKmucg3wl!&F4N zZMcB^*ZHOS8+*)N+sc(dWpeq*V-|ec^oxH1F{&Z3yS=QV1!r5aJl`;*8WZo*r zz>9`mRjB1iZA*Ee6x{Z_d73OVU2s z=hyX#7bPyEF-!Rtadus2{7Z<`;w^X}HX%3t!4V&keB+9(g*zd{4cu+uh%&FlNs+#Q zZy2q!BIVqt5?k(3a^n#6<=xX-Qr{cu0P1u`&Tg^@|Ke?xL43kw`wZ~*2Pf5Fz`Viv?CJrHQsf?B%QJ!4sU<& z4USmX^X*lWlCyqs179hQ9;*M`Q3(oP@+&j3w7V4}a3+b&!O9Nbgg0~sM*d07wVADY zNY-8z6-@Ceoj;9f8-GZzmS3z)8UjCr65k?oxy}MU0up_&Z&?9q1RL9y(%+fOp2A<{ zecx#2I|aHKBv7S26CP%+EZ^taRu_`JYYS0* zJ&-(OIVqVKl8EQhHWw6cyZm5Lw4xMV-J?l<(Z0nfvaN5zD%OZk_yoHAEZmGmjfmdt zl}wjy;uWgZ8Zvz_Iz0ic1(8=cK+F$tjk0vVx!1wwvbeEKNFTaG%U2HR1eet$mjGE0 zQ@l$%vwAn5*e!|Wk?TiHzosqDL0z+&0A~d2YXe;i zEcbE=^2w{Md6hjt6! zc&`_D-LS(oI3-d6Y0lUXtnfMDIh(BT)(sky%$#CCai@*eO?|b!v?%d= zVsQ5gCB?vObfzFPB<;_KZWTr)*7`z#;zoN0pI@#yg>)jvdYrXe)nX3lF-R)GP zv~p~+F|6mrNT9PXiO?;-ctbqIfHF%mO#T6>DMM_*(YTyyt>Vge@h+@SCH= z+(rLTEsepc@qla`qW;);fV>CZq$uFNXz#<>7BWS<+Q}*N92F{o;KgyZt3=iYI5bDR zdgec`hifD--M-2?mT~7rxWFa`Si1`U-roCLu%C?cCyfM7GA*Dp+KO z-cd?H&35IP&f0_+knIXrwiPhEK0`0b49-I@(>8YW{;nT1M}UM%?la(?~Gvi zTsnF_y?$e3L;3ek%6|%j>_3T58apMG$w-ds$Hmn(go6a24i4JZe*HQe|N3Y}pXT>OVxZLPGHfJkmt;Il7d z^E&FiUIN^-t%aXKMTf__Xhxs9rEw9!P~i1LLBJ!s$Ew9XNvJ2cEKYltck<%Rj7UHl zwR_qg+|J#+datoA^A-PJWvS2A{sPxu986KmNDsqZ-G2vT6JPafi)C}2KWAmPTB)0PO4d@(s2G=2X){LUFm#5t>LBf`<2jpbgJsDrBWjGR+tfXS2INROHhgT?)s zqK0MH@Yb$q3x^(R{0_er=bgy802k2t0xiORXc3k(ez|)L5Y6#{8>fc*XRgH|s)@EhYuFKn=(7oDr@4^9G?jLj zNz#~Tg;<4l=;dvGEz?2Iiz)A5XzDn#p^WK zs%)CE*y^L80F;XRJ<>V&@qDc}f1`-hX<@{PP8RbMyjKNwW7k0M!U0dahVVLQoV!&W zGf4zl9D6xe{j?r?6#LTDL5g%~^Yo)z#1|AiRz9$*Y!)&nkS%{H^2px(J)HQ-lO>^D zu^I`6AK?Go69{vP6TDkk*xr#Lb*oCu$M&JLdI8|vDK>BZ3bU^W_fb$zStVt%I?e!k zd*1s&zV_j&W;6ENU|8~54^Vtw~uqtc3aOlq7MBNIFwHFAofT&3^a@`mS_^WVb>DM zaXc{jN~9zPCyskbbp}mc^YXi!_h1SM|7k|V$_916tu;%yWixwB?(dF-(Wmp}`?{Gn zTG|9vUsKHdMZJ&Sg9#S>rTAWR-Y*{?ZhwkHY}su{4TnWM`8bcWsLT{OrV`&_d zb(BY;$wWx>^H%})Q6G^U%0zAI2IYhq4YjHWwdu_?@8l14h)gs8ql#GH@vz!@jH>E3 zTXULm0$PlWb%TW>;Wxj9JCt8msBeasq6vL~8X-IIxr+SZ?P;NR8Y0wgPy6 z?4>^Ablabmt*wN{bfd{+pbyk!M@v83OV$^*o;p+4&hVd32?t$TXl9kvpefRmCwBUx z*DIM9QCV5*{R-Ak$V!itn%*Os-O_V$=PhY#0$}Eu(Kur^$!wY|yt}lsw0#FDrI#pH z9_7#+%DmC=b7fA);ci+7v^%VKR}r*b>`>HQ4=?P$zD6-p~(`$WoxiNRabr zejs|SwRcuc>T}!$U$tAqK7P?uDI!yoH7R%-dMl38;mJ{CgJ^1sX&cLO8M}~%#JWS zLi+w`C)&k`sB+NiM+2j>!*f4|ivvP*k;Wrj2ES!egL#*6n<`xcnu?U;dBlqt0F2bG zJR>=J$)GblFpv-Bx+uixw&)Gt9vyXE9(?Z|gx?WmH^Ac!buRKsGU>vC+je_)z(uGm zqH~wyp!{W_*fi3G*)L#OAO+7f^n;H`hQ`4_;Rd zSW66h049BCx;{zIW<46{1a~D zD1{1qo$bL|Rq-v2p4ks=1=^VqQXLT-2O038czNC-q+sF%w}Y11B2L_{K{BNw`}VC2 zslYACX!6%njQE+KO8b-4h{Icj1KGD9TE2E2?sA4qWTW?c{<>1U!X}tUO{X6Q%wS~T z_J~dm;{(kU@G3O#Cm;I z?e~{+Ktd9e!UkaHy$gaGLy;OtYQp>q|D(NG`-zWvAqQDxbTWEZ!|3GU?PO*T8y(?x zFvHqx>X<68J-EP{)-Z}kJ2sT|YzS49LEV6)Y?-@QZ~q5h%9i{~j`g+FP;-9UURl11 zjVw>zxK>xxYz$mT=FbqSV)>Urf{Qr|K=zP{$VepV#5bRB`Qp``O#>{@9(63+28)hV zx1Kp+CsCwwR%P)SNe+#5;eM6CXad?;4A^zKzrR~ZuA{uNC_JVwc2<2T{@vY=q@iGf z0RHcdK@Rsk?UYrf?&QnQk0}??*>%S1WuS~5_M=dn%g{-l%VzocRn1GwYA67L&xA|s z-!3EI9w-8|PDGv;Qwxi@3p2)k%+aLK(h$Ngz4f+mhBqG;=HR}s z1jdKkqqr2t3UWxEQ755k0M=}$GyJ4{v4X?R(}<|aR=eq|UVjk&_X~T3~0zgaZpnZ84HSSru7gb;(?=t zXOgnWo!s*L5Km$Hg%tV3%UnD%*9`T*VWn~i0#_FZ3Gm34p$8RbPSAghb`J6!_coa8 zwb?DHT+i9>F`mSCO6LZIbne>@zK=s#;Gcd;GVOr)GcUgY^J%bm&`MGRGaVLXT$r=P zQj#sb+R!b^eE+aXSGx%>MURypF4{+@-}U-bf|zzu*k6C}TJ4S}e%%9IYpPWJVEx~tw z@z_2f2m&?jS}o;155wWS-5PewZL;`oW8ANnS@{W$^7ST+_W&KV1YiN_;)nbX>(#1;Qz&q0hg}?vuV1z;nl(y8#4_a;YoEQfzY8OQ$7(C1}X2`M?&o? zl>hC~Z+6>B@B7wkvi5_>rMtQX<~}?z&0v?oV{q)7=bVc1G0V1YvtELUd)U7(EtQFi z$zCYcJPL_eXJ|hc!h@*cK@oA|*!!tHYK>V3F8l8ZT{4WUl6{`-hIk{Z*)aHx7aEx( z!)hY;xk~z?l@TWm9(v#o@Y->W=<(8)7d6d{=Ey8z0Gx{{t@Vg+^p)!>7+M1=wO>hN z{X}~ubniz6oX$#PLD4UTo^gN)0|e}+I?JJ+BXSsxC*f<+G-|IF=HSyJym>TO@m{hZ z9~FSK%WT_cUIl&$fJ{w&Zw@x3WE=b@xa9v><@P~kS9P6p;OteU$u|vz zKjNPuiH=vUEBv~0rP}dR@dK-7flq%d?cSZ>cCn&OA7ki$MQ-a`9$CJSkV(5Mb`14( z!;sj9@{TZx@XAqM_|?I+_kDU9S>BYU>g0vDeP%Fvcvah-V(*Pxe4=(rxuH&CH5hx|XGg$j5?}mSGaDM>HX+Z)yDMro~wg{_uxuBi=Qpk11cv7AmuC{i4ffbQ}u z1`#}un*3d$_stSY9|QDpAvR0GDZg30_g?q9ktc}dbjavfYv##3^ysuaA`1%Zcp0vb?u|TeZ_T7IOs&zk` zaN~zI6*z)t-%ne1rs^IKy!jGpg>m)e$*dG`+&IX&ZQ~^?Z}WV{EfRKnj2o4oyQ-sV zqa0egt6|T!mn-o%N5LehgA@7ux5yHUJ*IC+JpD^U4m_qbN~g2jnrNo4 z4*Yr|5wX~PRF}F@K#>aQ=^$vpLlBV5j^97^DmON-Q%E_@h|sbj5NgOsM1)F{!juY$ z6u4z|eM9~c4GMCLAITAJ2t17Uca-d3;x{l#sEUH+L_1J1d-h9jeX&;Y#-*ZCDj!*6 z75%y&QDxBPDjFMk{tGWwrz(wF+4Ek$cz<}%=f-7U8K2gc=in_W8|!?p-#OGff}f~S zG@dZE2LLq{m!RmR(7pUOz|<$b>dJ3ReqyJzrH<#q>O+kDHG*~`D~_7~r&`$p?uy-c zX%dQ6Z4uBiwn!&h6|gK+(emVC4F-Qvb7oz;`|+8!$}TPK%O=|U7avje&#f5>NdEkB zvfzAU-J_m2%su@3?IOG<_3M`k+YEa3VE}| zN%x%K$=^)5Hw4lHSYdJ)u5X#$}5GP@N_`Y3)M+y1WGF&30a=C8^`tc){7vWS?@z zMl#m*l(rXL^0k)L%kx$K)cyCy2Ap3Q@p$Yyx6oZWO>d5J4x$Y1BIojN;ktnzO>BRPjBa^zjCi;QeRI` zV$hSLDW_P&%0rhOFa4rKMi$T@KrMry|!q|T@xjjw-5vF{A<_gz^X^Qn1w zK#Jokq!To`$zKQ1|7wEJ!ZLx3Fq*YghNs1_26vBQouzJQ8|0$GLsfPYjKEItKL~$$ z<)Za04S1gMkuVaDNds|cM?WXr!)~jLTvUw@m36vr$3@H!Tn=wZ{l|`D!bP*L?8l(7 zI(#42l79lzGMm^io0Ju8&@X8Eq@1|_6Ll%SIoV=_> z)&GrgbbV2Z?i7k%H#X$#CoYveU6a_HFUl0Ge#w|0gNbPnnK+});J{*-X0c;m!Njg0 z$ZtFUTfT93#`V0}RTuXMyp#h!%B+6B0TQR-fROY?r4*#l80j@?{Kd1`U<0qNW6I2F zT5vc>roy@c%jGGWn^C`Rbh7@mY;vi5b1txxNzc@t{5TitE#v+4&$PaFR2GyAeh*<1 z!UqTCMV=ef1qui|yw*7mTi27!Q>8c%`llrMic+$bP)<9Wf?11F6O*+@2!I~fKEH$N zTE(|Y#*C^H1WeM=W^mU1q_C%2|Ds}_VU{_jn<}Q04WKY6wM&S7`^}Bbk6kR8b7M64 z@KM>k3xFK@w(eO$VA0Oy9uPCL&#$JI+*AjC&4evDl)7t4Ky|IINF`F=uR$62$M4E} z?{e2^b*R~5Tn=%mAMX9r9QsReNfWcYwZ0p^*zN0ArTQ=wxOIIu&ItFB(f*0S@23mD zyh=t*C#J^BrTOv$;fq$o8J-OlG9=ZkT*$>`45e}lgU zMRez9jcP-RykJYR2WGoB{%*TNROsH{!dw6@$3+T1Bueg@*RGvd#JOCW*{JQsG^(Ml27GKf=b@)Sv@&l5`XhG20y(N9&y zb0ihf81%!Cdfj1}OV;S4%Nmmn$I{~BpyFEP+mOk$HhOniQ(F!OH_uwqJf9@GSTyb^ zE%ZTXw(9odDbuNt8Lj8@e+a%db*Q)jU*t^o_;xGs$M$bdk;eGVokHG|Igi9J(7<4p zUT31$BjCfFSm$5d1f_msec5WQr^2OmS``mz?$LuFYAM{6xiyDr4ee*W(J{NME2dcoNY9YIQoMuu+{!wu9dvCko z>kpZH*OX?Q?HnF9sf9cUzHKzY{lo1DH99uikJiQvj`2|p?=(n|Rn^Z=^%AE6RcWvP zj{E22f3K0dD=VL+8pOQ+C@lO341&F15eJk(N8V`17kb1qnc$-Wxx1!YTwe z>~ZbYG#p6b9BnWCIS_B0nvRm1Q}d`fTNudy7IK@M$nzJrX6b#izUg(x+62X^$-RE~ z)+ZQ$V%Ry_RWm?$iSoE9WlzBg5ERYBKE_%MZcj zP^R;Fd7$2SCk5$eKf`qu2#yQrRJ#YU{cUvT7#uH{$P4;O>y(xLRVu=m;h34_r69j{ z9%l%}KysFWQRq#c$T7{QpTZ*hJ&+bFmaq=sQf{Hrp|-Is=1tG}-LOxRV>hAs%t#wS z3rK4F4KD2rg??u+>Y&;Mn3?$*JweBe7KQfA>SZh-L}wd@rx*JziI-mpllna(w1Rm4 z6o|~fE0^?wX$uH*1a4A6bD|fs#l)#%=}aM4HQAv|#}=w>G+rQYHnmwitvxcCeAQI| z;G0lf9T|=ei!(w53vfQwDdnZPGq7uurEg)cas@DgHkU4h{{=k&1>q(nX}mdd_`WAF z=yTMIp#-aLSXgfRC=FfrL%D_5;IDMCfNekx$Z8xb%{XYoNft_W<1XGhFMEL3dG$R8hqdTi z5gQ7tF>XnK??W%a!0yx2H1|um#IS4cI`$XjdGD8+9WXVIaP~$SNwR=3kOmZn(@UGF zIL5vwfGg-_>57H+DZos9&@E5m0fKutw>T@HBwY-T^$Z_Q0AqBZkZeTyl&0F*#vbxX z3Nn93OI7kw(lh!Tj@P8NviBZA5*zMahyv-{u$D?h-j?7A?U%2r5zNCim3Ezn1JGKI zmpa^}#J|SmKb(*SB_PkoLE^;6dTvd)Vgo4tJ8kVXPSADMJ_fNdhQ2JFq3<(H%CZk& za)R;4+0)>ViUyY6mvU%$mW%C^<$xRWSx4;P1N$Wq3V9&Cmg>Vyga>U>6I^-rQfm>R zJDN?^ZszxHWbVABQ4-xz8hbV-Z?3}`wbXBR_;qucIaB}JGsxM8-GjUD5>7sjOmMOU z+Q0vB$$=CVcqASqIv2?M0fGs1h9L{T*SIn(jz=cGTGuDk?QQ?q)OTCv4gr_5BACYW zG-`He99D{3?n-e=MV?U46@10edPtm1os)8}+5IAY0XfpGin(NW`X-3q&E^|QN-Ji+ z&F~$0GUvIv!hO`~vg+v8=D}_N6X)#aBT>??G808EN)KjrFNz=n;Q|WoKOP+)Yk*D| zDcc6q&{8Er0C-S8J3p_aoTE8y&QVVuch$gB_vF@4%cgUHvC;+ztkvG@GH?p=7oZto z#BoV#6iI9;y(^F!y*q905m7!Ib!f96#pGCl7ztVLL9JQ78*)98GD@n{cj5i%oA`F^ zH%esU-jigv5DECx4+NUekH)0((!HpFf1(qT5-J3)O6;r|(Lu->LhR-t{-P)Z@N*WJ zZ2b&AAIE*=5vG02bh4#iNY!7F=~F#g;@Sg)S5)lj`!w7bFYX%sZa*i3p3YBrEP`qK zzF_q>>?Nbvh?PL#HO{Jek$F)L7?CC5ja3E=r#eaHDrOD~+)f5@b{c;F%Za}n%15m0 zH$R4CZmO%2_?kFSaJ2NXfZYIlUgec0V+v=cBuHfEqGn@-hjH2ZJ+D`02X~LfD!{n& zO<#>~1SgL{M7Rox)mq3E>z#5!`$Xc&<}cqv#XIAF%>P-IW-0peLWw#d9sEW)bN!Ix z+x&GD^G*vue-b)!8%=I!Z=c97tM;1Gh{Wel(t2L2DXQZn6AAyEN1dKcp-V(AWjBgnnd`|H|zafwq-RyFl}+7Y!q!9VUQv6O=I<1wMmJvEBI5=!B#>j6ob#a)a*3%ws>wvuD3kM2z;oVus+ZdO~vF@5tV+#2jqpki<6`0~R|}>x_PBthcxf zUF$fSq?G!h2(z(aO^+q)N81i2^wkX`+^PAZa&71;}1ID zJ*fn(39}a3iVrBJ_+R1$r~(7HPy;_tKOX(`Ah~^}9KZ+fVrzOVv(v91HGZqO*u)$P zWIROBPtGaRdyM5sHT?_XqR7c|nU~R%DGM{F$|a@ZwW>iE?QW8>|KHKST%>yPS*j<| ze6}W(Qp2va`M(^%4GS9^!&H#<{OErmAt6HEF3FiQ5005S4@XGzC79Gt`EYKQl$7js zieNu9lfO3WPLtZ@*e1wk2G|htXSFvmi|PLXi6bhY{E?XWcS1HooQ$15w)JozTT+R4 zJMr144Mc794h5+uINu9g)^KN^qSW-WugkfnSLK|YR4xYxt2CXm^;TT#JCrgqukRSG zUpLL)oA%}cXldA^+-Vv?9rB`&>eupw)oz0|F^_3eFM5XmW2|Upc`c07PZQr)h{dpE zcEk^Rm<7vo$h;2{Y$1oW+@yL>`%d9e(8o=#D1O!!x6<=bFqxRoHVQh!UGFzcyCo$Y8u=q_B;S@pT5M~|Yu#g~@=d}8hqMsk6MQaE-6 zBppEwp2!Ck@2$i++khU0a?x4O!{c@diB8-CG z1IH+35<_0^x6#x*Ym8>(X`DXDgQ@OvCq2e$8mA0-`rYRAfhG7=PZCC;#fHfe+Onyfm-O!Ie<&WHa;;H2k_+k3!}2CiG!u2rSK)vR?gs%G)X|x{db*>| zZa4#$jQGKKz*;HoEmob8hJkuC7BQe4kc*9I9CW7m=iMcTi^=*DKd8(vGYO26$FH>HeC(YDq_q{ z3_Q;GG^I1n3 zq2J#RbaTzGwX%*My7!F0FEf$E*q!Otu#wuTr9JbiSP?JkxuZWq#2+jT;k z)g1*SeFpkCDbkxjX5zO`3n7seSr*Q6j1zAk6j)X5VI_S@Q~(a}-BRg0FP7c_c}7d7 zQI&%r2Mm&+`LMEC1ph^#H}$%2H4jV6Uh7HDgX?aEPg9bYZmz`Z5WsugNU2!5JZ2)x zLbMeBRH{+$t8cw2?J^um=wUemm*%GTgm{rGneia#aar}1ZD*AfRf*R{Pm8WtKe0*bguyjKiy;BAo6;Fp zhb~b{EzM+Nfc=~NHPKU8qw;MWEjHfvB^JG)oKw+nH&J1m0PlUm_K zq1`b4sA9gB^G#_c-`DGWP&mSHs!$(*sFHDCuD*1mURsb2Vp!Q-~1s z=v-|wT6$R$w{+0G`c)4){lenmBp1#)NEIa-1UrpW;WJmNWOH5GPjU0^l@N2X!h*Ks z-ihXM+0!mxPP|GuY5@GqWV;%E!tR}0xm&UhM1anj2zCKdFFk|9kw^tIc&&92^b2wT z`JNHxrPccMU-w~REfZ!cy8T6(@o_{hgi1cSL`%!$fXUlT8P%*!$we0wt3a{CB`${A z(8tOCWmaRCnyq_5KpA4ZCXjLz93Mni-(4+jF?!4+Rrs|MbMY0#) zax(9Rf`pzia&qn!s4!2V&g@hf8X0S;GnkB7QTx~A2rqDY!0IyVR^v$_2}ihZp=d*U z?`+ohi;ultcSxmg4$m&9&tmP0G7?^#a`OH_@SsJkTR8A>y^T+My9oBQf7QSlJ>r_* z__O-Usa4aXKt1{`(Gw>zl0Ce>nW_9n^<(qb+G`)RqMui-$bN;M3tIb+tq%P9;?~M) zMvEbs;z)wq9t(zO*WG9>;qQ*u8BLRzVW_DUn?hq#g3b}XaNSK6-vf0@+aufddie!0 z)`eUU-?YuYwS1#dN?fU74vI?Fi z`7w+S#8xSBTXw02Vj0AZe&^SY^B6z47hO?1;hOQabfz`vfcaVbvre1+7Mt*?A-Rxw zwcxqQ2I#+zKrCW=APD@fJ!*^hFNn9vkNmkMK9-QlK)fy6mqGfutle}+`97Oc?$Eg9 zTn>{9g1ft3Qk@tw4lZ65+l+@Yh{wj@!kdu5~5T=KotXIqR)mWoln4!afi`fg@BKnKks`(_HjWDB!mF=szd z%l(fZkrMkwuqraD%|v0PJx+795W47XkWz(jUoo?U-^|>3W|!?W^vd~5y6N|2_`Cmo z^{+Y)Fl2ohb|Dw2k_&$IDV;L}{~>@k03+zC#r)8JaKQHF$*$^|7kMBdB-N%VD6_Pz zEXUkmnyb+Cs{^r*Ob#Hoz(NvFj|peWCnFvwBkEbFkLa2dM8x0u{$F+Ahcn;aA(ztu z^~&vjw|iL~d!)=mhhG$Cm8aMNg3BT4G-`Rf(nCentdA7Dw^-Y;8@L-d;Pp}agrKS# z8hT1z4NNHQop!CE6Hj{Vu?*~&+j=eD0Q&-xSLb~G{f3$Bf6CCZ*U6-!jYO{Bdo~Sv zIB`*$>w6az#*7!briqF{j;uVJ4D*ht*b^hdX>#|)KsV80_d==muf5my%s_Iq$WJiS zLZ}|xSo`4Em>Qo@|Jh<(jsQ{zIDXUfW5`#^wLP&&cJoy7lp~lQiOH6X07`k<29IfD z!PSC^=XLk<7_TD#)QwH?;psLMPk18Lj?3F{O5U0Tk^%gTiid7XvRZG~CVA@f45}hx zlu0M|&Q?lZ$s$ML;5D@WyQigs^18U>JPY8iA&+!{ii7i!0q11YR}OmcHEm#wNWbw_ zg51zVi=yTn{sFZGv0Y)-1~LIDBr|w8^=S_{IpTXwMx3HR-@|Gwo_;NA#8WoUr({_lLC8g<9Mc9sVnH9&%lSAN2M1cxMlS<5 z_=P8aP>Iyd_~4s7P8L$8ODsBfR5()xO5df~C`+NjLL#Sh!P45M*C0^dKkGkwJnYGW zt5?S%4t9gCq*&q$pqGQS@k&h35_bC2O`K)L)fX>rx_zGdvQl~8*=F{O2CxM;*)ucr z!zID|cbGX55}h{$ZL)7ipWdOuC*8y{j`IU4(d0bot4M(e1xGap06r$o31ZA+C8Vwk zKRO?woxWbAwU6V>2E3RPwfepb+Fjn42aYcYJlg)ssW9%o>#7i5-tEX0B6J}yKvklyDkQh9t8 z)!Sf2In7ZiPs?5+G;6mF$mEbgHG~}C95;SlqIo_fkR%yJ2_a_Btwi(l5rU0GxxvHebKEg8F4~`n$AS=7805cb@Vt z?s$ADUWIR5CMha<=|h%yXz4fig1Y!WiPX3{hP@pwj6iN;bTGacUi!-lpM3{9K4uA6 z&W^g$tbVps^1j-$KkPseBFQ-!ueMHb@qlkppSAgxc5m2W6Af2bk#l;T1Jy#{-!#}B zyOnWP0*Ke%ZI6CyWmuS!I`V)V%RuZ!14m<~C-`%pq3=Q6;*8FF#lBvrk^2YD^i*eVY=MY_Q_lJ-VeW zk_>6u(LCW>^B^nAGLfVqV6YA}QEE9wCf@CNb^#Z({yjU1?>LNbP7Zfo@K3%Q?>}SN z+2`xe+64BaAl1lczvUO5>!d=xnTK8TfaVfE!S8a6g=!J1&u+ylCn%zpjG zj)z9Xs{qB_m7W5liLIogj!r3e)=i+!6|SC3I*^CYw1>*^Z~(FrfzTPDTXR9yTAu(SHf#6J9@qEzH~d% zbQDRJz&txB&9|kU`O_IgpBy*87#z7Iqk8b!WaC@Hic-^sPz`Q~&5Xurnu1AWdaP&a z=LH7jxYq$Uo{}?y`k*k|{Zp$oG|vtJUkSq33Xzr5`ZRs+N1RD7?o^`7+}Ut^$Nokm zWZ+Zd2bc=_>_)|gOJAxBlwZ%$ZX`lx>Dc?3K(km=c_(*Y)Y6rxYPXzp$W|yx5!nJX za>TG3*i7ABw9r`emwozSQVQv@J$S)9TY>Pn2uh9?saOInYWOV7s#)0jmwuD?l9W59 z3VA7IV7~@wfEpcyxkO34_^8<#ew4__+%MCxE4GxSFTUoC-!ygqw~(xM?!BwrnDgp~ z2l3Xu%t@uU9Jy!zMq;O1oQoZ<>C;}d!0w#a_%@{TfPrv8*?~W^iAkPjM=MGh{)9af z*9`fqF}z_)VR6rzKofmY)XpF%+{`~8JBXr$Q&~9>?wKlP7fp zzReWt2rl+cq5rgq9lB|g8*kYr(1x~*!Ct0+ePtjg!64+M@=b7tTFiuc%tTWHn~JJY zOs>D`2}Ai5fqFhLovjMH=`|qLZ@I3Dd}`~*&QI4k>=+*uJkyZhCi&a#H;=vmaECcP z@ArdgsdEoOR`>4Xf6{u_E1DRF+PN0CCR|2+7MoK*g#&o-n4vuukS8((QRRMwgnInG z02OAzbc5@t4r!Nj2^A*tCZn&BW(14?*bBJ8Lu;n`w&3Kq3!egtT8BWqQ!&mk!E_3` zk#7|4yP%<~evu0LfW^F==aX>1pU*5&M(s(sxi)1Iy5#+jn&!Oiz(MUUI5y5D6)a`^ zgbmeH%dbIv1@VXe`D6r+0BGSGWrKrW;f+*KNTRx@OqW`+dnCq@ig|{vJV7dVnQJb? zY)a#Aac3WyeoDzlmQ9!R6RUPPoi*Yq?YoO^uY7Ywh`Rl$VmIxVXvdl5Npm%}ru z{?Y35@jk7$65%XmI7V)y+zTMDz%~pX=b-&uCGR2+Av(uqJ^uhq64o_$Y2DWknEZD#&4=SFj-h&!OD$RGa*hS>n$ z`}hh^>Bz|~@5ElF2FehB@=HnHzH9bNa5YHrDf#cSgxDum5WL=&>4AfJ{18cjZzp{1w+NCE623PTN&aGV0_@-Cc<~2#j4}oK@0H{p>^bV*^Y0Spg6yD_o*~7sBgpiJrk4Ss_lD;Oi zml(Krm&kKVCgk^ciz5zu|M4VnC3kfsM%;@bnl#x7bGkfpWvKCeXt=Q?}3?)0^|3t7wk> zfIO`VZI86H+`_oH;qOh=_GjQ9tq9|jCzc~G*0@6>j1*FgQrvW3-J~d&&g{BXV*c!j zQ99z*h7oGh<|eD*^He&K)zFn&M!f_SbCtx}(~r+APyK)Eb4%nFmh4|X!hRi7Z6iFZ zxekXK-K*y1XU=0A;ZV#UU6>Und;F0h_Q`#~A^N3A1*emV!;GOyC(0bL)Zj76No}jEf zf6d6CgPMo97&o$K)s@g2Q~BJyOyjUq>$SL@Z?!{Q6oTW^$6D}28x$<2BDkCD>1=>e`qGJT*^wpU4nI>iQNU=!-+7*liamfG(={A=qal zq|-xco+KIpt8Ed>kGv+vt&*EvozGf4x^wSj(>2mKGrT_GvX$Z+sVc1qUZHZ0G58iz zoB*;}nwdL6n3nj&>GVYQ5Ks~+()HS zMIbkB%gRE~4sYTdF~rWf4Tu?L^_zK2+0q#)#62Yqi;d z_s7}T-b{FH;y{0h1z|kl&4!0xw6HgwisZI+@Sjhc>s9E1vQmimhmwP2b2r zrxm7As^c+SB=(S2?$cojvsk|Y-D)46>Q)X;)ZqiP2bLn#d`3AtS@?OTG@m*&`iAX9 zL+XDxg0eIOWlid2ThcQv{nh^?4o=BsXNvc9Q!f_890&aO{vX4VH-SB#7eR2}BOmPS zNE%#C`Mr5)Qevt{p-`NiojY+q&bC!gwaHcItBkK?$(yhI6oe$?&fSQ%H}6RXB?T|; zeJv_(*mNx)Bi!9ZRr*`}mMw7Feat^8p&moF)Qris)=Zd0Y%JaGt+77;)VaJadnM}# zy#xw0_6fa5`EelYaQL@S?xflhI2HJ@T8t6|!b-d)g`9Zv__|t#MFW|95?0n~`{p@MM-{tA0S8JqP^tGW1%pZb&G#_|0v7)@#>SOT0b1$#V8x+e< z99#JN*Tkyceb9Z|31(GvZMR1DwtTkk+d8Rd>u-bC8PwD~So5{!! zN_ma+s9ID28Iub#qqYv8C95iX=U;{E)OVVuj|)4Zg3hfSGa8rd=>)*xelUFEp@o|ZFXl#*JivgPUT@6XU&nJKT z(julXy1>O3O8eeF>Sx6A9rle9c@ue8)lGANL%hf9bUWlgGCRmO;-a>i{Tis8&goZX zzy}lHbSo38pl4{`-I@lX=6&lkII-guSHIzApUPlk9{m0rgp?6h%J3;Ovdn&JJM`^r zb(r4R^}|F_pQl(fGw%1aQ37ZNtPc>`Ghc6+;W^;C*kyJ_?P+M+m+AQ9nbQqN3v2(R zjd?=3$T5pz{NFqp%x&NRXag9sKye=8o#8i{MR{wh68ekWepABz8b=S)cNoXyaoI#` zAFz(07j;iZCC#L(vzY3$t18M^ho4~DS8?~BWWJEa8@jiabuSLX&F2$YFp}*K`az() zxU5xr3ha2`Qs`IoTET)wnT!#j0+s(uCEva<>Tjy)Y&1Vy%%=k*Lo*W@SDZqJ%qzww zv*Tc#9Q@(7j0)q;_0ySUtx>l=+N1N5*CMBj-?nI_&9#{`C8f7qb)m;xAhJCFDIo}% zSM#~L_NIw*3F+#4gSX8##XRZRcHmyO;*1faH;XOjr-W4!6Gd#B2^qQBB$pNCZq_yi zOYoQ8n$3`uw9gcjE2I?@yN)iO{v#V$)>? zg6=7X)hNERPWNv2V+`3bPr*i>V}C(g$Y_nxmg*Wb6wFVf8fO3zf+GK_@zS8&$KFHgnz`#s*oUBNh(44GQaONa z>)8mb0sPeUA&hZH&9o;@Vf^roK0D@VIUO^(f=VB(;x4ai>L()@#kI64CH_pYjE3o`cGExgn)uUa_wY5hX zXyRW>y|eYfHTNy946e)$Pyob%{;A&_Bv^{v~>%A2P&CkvaPv*7$^TOA~XZAX;O^h$~sb;HB?P~gDF zGU}a|$%*Q=dDv}v?#D4Cezz-upzk4s=ghmpOhDU zg{_w?Q&X}DcF9M1-Fo0L-!VJrbH_7BhCY=o4EEMQO|Aovq|amxo+eMC+Pp-hn)l?& z8L+#O4?L_MT!h(?FIr!?9cQUP$g!kY7l^GsrcKQH!?S(A=$6)|t zC7NSG%4`~+M^DDY&|_cKO+Eec;D$3AEus>5AQnuSoHh*Iq6sbUXF3yPc8E#p72y0Y z!_dst1;W^>1fNkt&ul!$Xh3$hLIu3;i_xx97QYcrd~MKc>+ZNo%e_xV%TuR+-OqO~ z@=p=^F`zhA*iEj(+qN-I_b5lMyQ2nPJAr>b4n2Kyt>!MBQn-!*P2}}V-E#DE29BuM z>m`~iR$v@D1@EWDNJho)Y_4IajPmRS7a;maeP2u*Ih) z1lHMzz(}7c{?PfD8WxdH^*(?r3d5Dh75)?RkhYrTmeQYsY+H?nJ2*v%r2K0+;Vqp- z5e$fhNUf~CSkt=BNXP`Nzxt3A0qy>Qmhod3b-6FELXLhY#2-RYa%DqES5sS3UYwhXIGzZ}I1lW+{d%R7A2VSdHBuum7TGExJ ze+)Q$oABJZ7rbFch1Q?7+#xk?w{0X z)LeV@d8b;*?l0$QPWS$y^F@Ppp;or>;J;L(Il{&bKwE9&U_iNz9D6cdgLZ9CR228> z^G4l7>*p6?eS;%kxiZuu^$-KkXzFClLZsk}KkM?)dvyG9u?qI|U|KK_~1=Z`{IzbEmeoq&^5` zY`Moy5%!GZ0iJOXfBJ5tjH5sN8FTx=l!mQjWX<2xK7!ns=LApo$xHp?bOXzaOFo!!-Qz_@hOov$&kd(h zt9|zi(aw4Y;*!J%F@anV6fw8uk&5nGAI=}+|E(5(O*f4@?&~H1q0^;dzU3F@Q!{#E zrQH-!{0Pc)kr~d6+5C{-?&MNZ$9N>OA7cxa{`rTv}TiiE`7V%P%sxxFQ&I>|aex+jy~=U>@F#n|xsV9g_Oe#zzuZFUEo-hvZLb4hkXnx z($}_FFwY{;+aj3|oUjI)aH<}q{;x?Q4CNHWO^_;L?S;cHnQ#0|--%ZJDYwg=2oK3} zvnE|i_Z{6`!XWlm{H<&`JQ*?=;csF`)6(rj*U&d7FP{8pq=moqxZ`6V3HGMFMr%y( zBg@eXbqeUX#3w2zJfm0;S8^_RFs%w>dEwwm_OFHSD_oJrO;RBENrcjT^ zS$tlf37;qI4e3@5zrJ&Mo80|+RFoR>Xlza)5SX>wT=GYD*=sFOhegjrNgbzj$z}P+ z9$0pQif@rbLoND#aALGW3jcxypZ;(>Bv2y7h4Bu=OO!I564E^8okT zU`|b#t$fYr*@b|30OK9L8W^d3wc>MA679OLgtp5Az(cBeOj9m^}H2SDBS(vMR zwhe;juDCrZf8Q<)5k#r1rF#AOyax|?S|%-yzJ8p(*hepffhfQpQ|vFjG6KxUcvcq_ zh>*ei;Btb$Mp1$c7n=8y1d>Qw5MB*wWJsJ<`C|NnwQhw4kf>^TTdwi$MGEgpa&S zGC?s*`GH$OfeL%$Oz@#W|8rvm=FzbPF_`4Y=rX+t{7*Y+hP`c^O=0VY<+mrEMcNs}CqR@t8X&1~{t!v} zf~9P0F73c~aC4>o>_N+vcIOVni3gT0G8&y6BzX(0O$PE||FLH6_-o1jYA6rJzS#S7&)H+< z41TT^xN66oW@i4EE=(OV(*tz+`p%!@BO_0ia{lK#?K{ns`sUTab>Ij4(f)tt0@^&d z&(6+5x3`y9N*{s1Ixh7Mj+Ds`zQ(F$+IvQ}JzG@|q$KEL;uHkMlimMg5Wc>DUfa-* z@FMT5gof;fDy&Ys-Wua+gj~uh(#ACT6UQjaIfzB4dx1{(ESHy@mo{mBc?0Y0$DNx; zvZ`Mbu<3t8m~IiDAc>UrfS?nN@5`CCAK=#l#g~`&_iaRU@hq|4&I7FAFTe^dz&Nz> zA*YYWNl-~&=`9m5Ieb60YW3qu$qRHV|23V&^gNDfI!%@}W!30BaW$EW7l}D;!3%dJ zJ!8b!>Wn@cRy@eT!YK%Tfp7;*IDPBhr)B_1MNznCaoLGp*UVEzIO z#(z^|1%pH|+U5T?HoC%8&KnnnzPy@}=DlOe6d~a4?i<+34}s)JO8_^O1A`4bQ<20w zb&ZYQ{fVwr(3KS2?M!uxI6)d#PzMJQz!@r!h*Fq#E+Xy3Cio$_g`r@#R4bud`dYAX ztQk8?Y$WX)R-)VR1tw2!;Q0*&maU=PJ?;J>Vh-4&elag#)rf%SEN z^4iP<$afJ+q}qaoq0S8phqQ~fI#)%2NNKZ^(zgeLpUj>m2CGN%to&$UUVguK_(LLB zI0iTXxpY>HGbhGBCs2L#hcff+{+YITu_6;*)u;90!2bK{h@SJ<=ZU9U5p@$<%>c6i zuEbw21Te#UFBhXbFf`>Fk_p3YmEPXL!{C)TXeIG zQ%D_2dW1z+(68lbjBAY3DZW0rADO0a)G;VWeyIxXXX4RI$A2;_gOB&kF#0F0r%WFR zx)?EM5}#uX+M>u2p%9a0?NNr@6h6C2D9w{eyWk&agGmnCFlasUFCm`*&PidY;y29~{b=*zOkbIDY$){*P>*lPE|O#s&3lw32hE{NCwnvlq?O z$7g1dAo{P2AiwoEts(R>zTjg}*LktWVsR5wq2=Ccv3G^7-}hYSlf=>X_IEF8MnTLU zjy}UGZar=WY0)9MG12rauCBK#g7Qx;G(os8-rgj|oxO4Mj;MBPBlPS&Qr@Pc%?<%G zM`Kf_9|Tr-y%)8=>_BLVzXs8V-giq52HAoM7_X=3(-!mWHh2XjNd4fxpXUM6Z&2o# z0Z?nQg8^3#Ys_p`>rM`OI{e^BD7lBcjR0XZL-OxmCn*wIxMdS^hsr?87Vya!a?{&2 z&aCU!guaUWPv%{|xUE8NPpn5?tSO`^8s)Hn$@~=UY9}jrTc{FH?$+ zyB-7rJGTJle(VUQ*c|%CS>IdQ`_{bPRRiSh{|7+RFKrApqGq|LFOg@*Pf}HNGv0K<2=!&!v&ZK}mF;UrxexWBuO_x7<;A{Dw#?bz zkuec z=vA=GqUbA9Ut>UNwNNY)S`;P}$=>OsBy`$Ow|G)oN60xY z;k@>_E}dzat4i};%N)Xq9IX1&{{cbdN6WoMNXtm%@yhfr(s8v{jcDw3LiG%H%$Fmf z7H&ZShzoZ%t9$Od|D*W3yK-1V%y(t-D9T_qW zM>}2ciMIY~$dN1>5RF~9$FqBzn`6N=bNe_rThri8{|(V3h0|n$Tp9=86&dK^TiaZ3 z7q$`5$p_cdYl^*;o9^m-F6CPq^-ImaUOKcQ6K*bmE*~6YOt;gSLJATj(mcUF)Xe-j z^wN*iu`x$KZR3}`R95M`zh$KE3{!7c`r5doHPjHUxwo-;%e%@mdDt48dEbTPI4WL$ z=~Ks;Yzr=}Vm$UR1dq6AeRB~>E(VtKNf8l_{|*WN+3N4a9=N`_DMT9BJsWsN{V#Wb zJU!^$YCYd-&G~y2@Nb@ggGe40h;cd>GtI3D#~%#}Q@oj+<`OGzDMb z&8M-B6QtR!5*u49m>bbD=pq<5;91=Obv+geD2}TyYX*T1nkGPZC;&iAl?uMw;}v=RyMzznKS8;ds9d+xkLa*TMA$bfO#YmHKoE=OlYlWh;A3$mIKBu}YJioCLyLesOY(M1) zF~sO`&$h4hk%l`hjO>N7rEOFLN?Lf0S_HoZvufL{q0hUee>-!G9O+9nQ=BPpe}ju# zJiBH~4U3Sppmw}D|`Cm86$0uYHG6&a#5z!DXLSAUEjLD5oln=(F}HR zM(VdtcyQ|v>gWaEl%P; z#WsktY9yg5KH+RT+O4Nf*t|;SK>w;NOnX4`bFE!45CgEPWa>(^@6lG>?-zjmXc$jj z0O~7v5Ml?lK-QwjV(n-Df{RHIhB?H5`lV+EM}YGMdUuklj+XQ7?!*BX@Q9)3%ECVO z_mtzl04_9kU$W(mk>jm?9+)7qZILa87Pu6D4f+-e8uH=39TOS@icN}pXiMP4Wu9OZ zkYZJ!2!Zb^2>$kK)r^Gca|JA=R!m4yiFa)cLX}%19|1bNjfbIJLI1R^SDG)X?>lvs zT8PliJ|#ECBy(&5UeH{Nn zuO%niey+{OUJI;JOlAY3_GDg|Ts3xaa|`Sjw8i!z-KesDl?kic0WLv~38d=5DmSCmK!39^qg1M!`T`8l zQSnpOpn|VirCoRGq*|A&)*2&rMLa+K2{p+$xfGNK8q45;N>IOpKxaw#aic{$hq)@0PYM6Z-QHczU^zMw9n3gT{F9U$|Vi`a2A%%KR5}Zs0SOA z=hcs4C*p>(~q#M?$C-A1Rp$zdHsLxp!V81);4^PZU&EZ6M5tvq_YFe)T+Plg|LuM_q7GL zFZ%u`c_`kq@bK#xu9M76j^gwC@4z5%C80UG#4##}948#ZYm;6*!`S*JkQ52I=j6u=Ae?W=URSbMKxXXbg8oJ)p5>QxQ3hYYRZY zsd&FF(ERZJB_8@RhshLTmtFw2(}AhKjA66539wOM1gqXy+vskphBGxfP~WBnxbNht z`p-A&!4$w*@Mw_xSQT&9{`L#1fu`uh>b?^Y^P)fC;5Ps$#OM#jtOFtbEr~2u+%^A5 zD;U_NU{tsL2Z9*X)_&QkfQu;-lMB_AQ+e~1wKvT zWxB}9>{~=fm@l=lA`{suKP>NVwqond53gt%weF^HkQLG%;)>H?`WCb3zP(}U*}B)L zhGKNumdIYKi|=S`8CkDM;-=o(#D2@(8N8heivHFVySV!`mD~_oqzuc+4iK8lQX1{| zS2n}fSF0NGI#;s-Dka1u7>qf zR9gt(oXF9`7|yYw{(iXBH=MMZWP^?q6cc;@5Hk6zu}C#9F8M1Z>=vfZa+(aa zKxRBjwMmOJPLj+3z{0m!x#|EIvvpmw6SV8Kq8>k}h^;%PLPEZs`KK7l$PqRzI}pWT za=)QsGcj=c(HJqNzXFe1GXAM-cc0*ORdr@)63si_4QRW-oL%_FiClL?8cNEgPSk@z z&-n~YK+_bH41m7W(exGSF$)eCA@C$H{DU!z>w$fKF6v%_GN5Yk{=nj&9UhIFdpzot zA0dmo_ndbUf7~*-_?3pzAm`%W8@#fD!uzKfmqM}rRP^t=&>V}}o3@3E&`tF)+$7Ib z`>HSQlmfFi_47|c_nnN;I0mIF3#bSNF!S!elp>hdAO<{#h@I8*!NnjeJ5rK5^mel- zO(zz`dxbmIAQ37_$Qi~$5t1vAKa*_2J6@=8`$*O3;ndpvPDF3cy~ebXHv~hk_>&(@ z-{oa!(D|gR7;yP<7b@a(=IbKITzw1ZriNVFWz=i`(X(u!y}x~cDIq#KsQq`@6|4Zm zU-E9fHrA-X{IAwDB`kDgn(G?`146Fa;JbXQtd<~;Z(&~aDIZ!91kPxyej*hB+Q7I_ ze|YnV$_CE_U@Qo!5)gI{BAWq%r0l5iQu1$>nHJaAE-k)F_7MMieF7-7HoM7dQ%M=4 zt(APE_DRqD@Ft+rTRiFe*CO~}PLKza6~MmWi&*sQVxMm>cD7|{CFJqM=sz;`@)~l` zEWrK~++O_ht{Mw+O*H0)j7zrnQxhR8&I27?1bO3-*%{9iw*?gL>0>#957+#^@Hs=? zLb7o|H`Ya_Y@I@G)wN{#D5ucJ>IyWIJ&CYaB`o-tL(w@=&7X1^Ya=00L~Dm@yb$J& zfr$E683A1LT1r7Ch$-;KR%Fhy2(a?Z%HrL{7c3nrr1`t}+?OwWKqD8%B$puN0&b-o zigun=cDHy*|0!Wmmf3h=_+n4X>=}DHM1_IbQ)JArY17Vk?7Z3%YV@^tFn?9L#nFc< zbU@S!vU8(u`>u1C7A0qhu$ABD(YOTEO28 z6}A2&c8gy(#t%mB$8E0vR{pbHdYHjMd=vLH`?+UDJquA1+F;_pSNmaofNEPZBLfoP z!k6p7B)!2EME5!iyee+RpU);$sz0?o)jQQ%QR(s2{M2A>QSp?$n^%=^8(dqv-4)>n zdRw2!jVpa0B*^S3c7X{8i zot+U21z0(x8A802X9Xeie)9NBNDz(2VrD{r+rayfYNp4#L!eRtI~|ue1n7KOB;H_Li@kOvk{-uG;(A;=pB_E~F~Y?FK*MijnA) zbL^y82*;91ka0YNw|8B>ksOz7;Iw(e05NFY?IK|5LiGQ=IxvCv_08U%`GGN)$?u>WFk3qSWOoGrb_>BK;hQ;!GQ;H{bPq3K5G0w*rPFK87HZ#!7OA0uHWt4%+kU}LDq$TvX*A?D6I;w?S^`BNIuZ- zf?E1VSD^C$W(;p{FX)x$_5!a2@+V#@EEBQQgJ`B$(%X4gWf{HT++N{t8x|XPPtoC4Ac4FZ_7k%$r{P3k2G4KwNc zhkm^?x0fY_1??}xbErzI%5KwI$CcwLjEmbJp|)sz{^n@2j&{A!8;ZwUsE*NNCSU4y zFrvhc>k$bg{X^kBU3bQcaD{K5Oc0?Nu_L{w&f)Dej;!QGU<)pjyxOwzjSvDZG3q)? zg8ixPWySJgbr|<9qm58*aO*tLG9()z<%}=ugOPZ6z_c|v1alb)7|3ZMoHF>Spa0ZI zd}x^4s0VzoyXLunY>1H~{tgby--FrKG>lDZ7~=I-+Yd`*NLnGp--}mlMf^UU0-)|M z9^Nb#-q%3n?0!-2=dx^{(LW!*LOX>CD#N_pv!9NBXC2o~NQH!rmb;2?o?DVw{XRrL z*23gbXvI+{#6(2fgd2-#-kGP+wAHj$rxVn+DK92~O<@>TfJaac;ULVZF6ze@dLJVD z(JFaaRDI;{p*Z7ooSFkfpesI%VTc1A8h^JdbKO6pcH^@xc%?9$q2HMqL*J3wA1_oK z^zEy^^>apz(IHZb7lZ8W1qatk+N}=+@zYD5AN#Ia6wnWiXok&|7*a8Msp@vuJdxpK zu4-;h%=mCiQ@s~Sf!6l%g084zlon;Q>)Y-e3r!%b=j zg>?f|pa~!V>;1RR9MJ~x5^1RrK*)Ahn z5Zb)uA$eaXS$y6x9$Ew1;J345emI0IjoO!nXXVNx_fM}JaltObgo~YCZZ@<3-sbNvJ@ix+@L7>+#_o(}@ge~yza9f=N#=3NU{Oe=&U5CaU z`iC}Ofoap&l%v13Uk}X3YU-Ol{G&%bZyT?F^p^G4WH7wCeW9XABZ}!+uA-pRRq9i* z&CjIdwGo#`XS{XX$RhhaK17mZZ9Mk}(u2zjR+-laxHn63Ug(`Xb$K4>d{^l;NiUb& zIXh2avAE6P(V^@Vz4^)E>so-YMxmPGKuVftZCOc_4j1 zQW%t)6YsvG?!kMs{G^iL*{TkoE^xMvQ%EC{Ez%|Ibt4Aen>2zl#2@vXXNrf{qxAxb zN`lOGsa^uvl+V|rk%>I%i+*y?{+xJ1NRf#=6RJ(|Z3!ixo76H(7d>wPBfI&A^Jf*{h#o3lhb$mW`z5#d&A!s-0ly=hCUM46Fv{nkyU1$&-6rl~i!S6Q^g zo8NnL!*Wk*Y$}v1++MdpWPg?oT_M7AuW{5f%&!{tBEyWjdOFXyBwb6w{d|-h_B;LG z$#Jb45Z6@Yi&pud*gpHomOU{dBLNC6yvTC<$rGsV$@#+8A$VUd!Qw+-pT-~^=U>Bv zr{AM`J$L6`K|gx!dQNrbkZ4Fxi|6SSsc|5iy~3PMQ5(x8>vth*C4+R=qan8CJJK~; zo{u`I<=ujw5uj&OJ`QuYl}4^0GtEndh@KB7?_aEsgq*PT2l}5hD1;p z!mXv828YtRdXXkR>#cbo2T_D&H#!&g%mn)MdaphiiaQrWv{fPsh?#G;n42jmq0WO> z*LT8qHyEJntl1-;lY%W(*IH|d%lG?fFFK-Zfh_NV zZG4+uJlXyrAnCLCp9=)l;0HAg4e73~uIxk{`Ej)&lMv!4Zbjfir8(fJC;hFAv^49~ zT0nD-g3b2MPSN^cZZY{zp!MzriL7RP;}bucYLdmoQEL02Y=IDJFv>-t*p{ChD_EMr zROV7+DVs@H4gf%+__a>c*fo=e^YH@t^*Oc_8|q#1l+b(-rB8|TNvbC$) zEhjLL0s331MTUyKW%mS2%nStaX1m?ezYE4t_|o=q4c#8v^n%AThf0E-K#vM;JV8-^ z%LTzRuJpLFlyGxm7tyO+Fjfp#!qcBqqd0nPXqb-$mlW9O4T*s|7pP;tyqYAaf!3xz z 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�+#5$%(nj%kYrMuNZZ1NT5~h{C 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

9N029SBZT7PfV=OX36^LLrD*l^)An=0tBF} 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%0A2}(Xo{~V2@OkJtP zb;IVnhV-bthrH-ewngEJEHRBU7C)K&eF%mhN^{-LM-5(xRhS2DQYN-b&zJg|lkFM1 z;cUxjufNaL_2LXDAL-TwZ2=s7@_A7JKu2bU2HIQ~1A{C{@oAMyl(@%bJwSaPoxD@n z7pJVdWy&Fep3id0YX=9Iq5!^o=69^5kU8e)G^_^{dc-#MGvDLNm@ZJf>sb zUBIwhz>tqG(*zAOjV?5u*^B+_vxA>V5Hs)xWdN-V@GmcpWer3W=^SdG>gV5HS1AUbc)k>()!CN4A`U;N=N#l zs>TH5K1+O#C@&n!PwQ3Pa(tlgm|ed9HRAk8q?zXn9Q8u&YJ__?;L+rq=^pv{96SP# z{aa8{03J}AWURI;UKY{_*a9X~SX?#tv}v@^bRVwP7joQa!IG(O%SvnO zBYQ{S&qUdE(7k=h!9?Ii`AZ&^EdN}~xjn@(nggmw5jXP--vQYjde?0ANW;kOs&m2< ztGN!!c~8T0gWqy*L&WpmXFdRXjPT;JJ#rvbAIrf%>B@L5QV6VLVPgU?Mu!GD>9^_) zQ!L@~;8{QdS<2!bvSiS5NRwhhPXTWMsX!mHZc%f$rHA?1Te=NI7nRP3dB#awrmbLq zsZ!n$i@l@MO=)W8fst>IL;ji~i_~RvIiQ=<&{>$%ae(&LPtz73vEFs(m#5ty@X-M+ zdM7A9y>!r%Zl(wACsMqo$DVD;Uw0_k@0aekBvQq7F;|Zr*dx7USRWkkOXf}kyJIr4 zZY7RSlm%8c(izwEO8v`C3QH#(=#QOw!+~g%f{DM>eBuXE8~-r0IFq}Pp)Re3KoKgf zhyUE1bdIIR`L(=epGz$=c3&m1p|8ei@jU}4?J5?3X8uyIIsPG9USc(qOrG%tCuJk$ zL&BPR#8;&djHG`BiN-srEP|=TkU_7%HK*T)T+QQ{0LBDGAC0CYwr0u9J0&_u!*kRh zpuM#y1^azmg!C4lzt|e8*G`HQn~yJPY(0v3)%Itoh9LA{3&x%7NZ%5qj2o68oU>_Nn4IJC-dS zj{d%2(kpvGgU!e!b)>5&C58=;C&s*go7{OrNs3~`XjG}C>)l^DW$&v{l;4~Od8 ze;0Nd8ex&q(I&Yq#2&bejOi)opQx%!AW^hkvBmB8=GB&=ssBYS3B@K;Z~uSj5=+BF zhw@rz`+P{2A_`?ld;Yk9<4H~N25U&b;Wtc84Oh2WOiT=;(SCT^^0E#10(P_z4O(iI z8W1Oo5Q?1>**bO?r`W*s+MWMg3z&z<1gYzw;qK1O^O`?@kcEAt+#~@HcUz6H8&|06 zJl0sIr>68s4lRL<1S(I}%%}B(X*XjU26P5og1ZfvY z+)^b+K`#ntJz4{&cmheXh{Mi|t=-wCqunN^*>e-b((V!Aq_t++U0caoT=gQ;vj$$4 z`_b1V4SU+N?>*<=u7E%|K7czubhTrii2k!somI`&>eDsQU{??bPAWV+l{7R?)(_vn zIRJ_70GN!vm`TY=t2(OuFJOL@u*Y{$PE8S;L9dOS&>#;A-td6-xqxLI#UoM=VT$f} za+nEcfmQa4X*g*MAheVtHrKL`r+PZJD-1FkThjv$^%1N6xarnoQ>!rNxYD^pZLf~L zrt*!;6LCTqjuf7zjA-9yiII`Hzu>UYQ9w-t=)}?5ZCsvL3uy4VJ+2bG=YhJ-pRTW| ziK_}aRKmsQj``kpcezthbxx~U$TFQU_U9)}_ZPmr3p?XYw_}qXGtA$ko$3w-X{CFv z;z{6lMWr=3zgoYd(md6iV~;wUoi#*ds!P->Zh#>RU?xT-7E&V+p`+WcXKXsAHm0>< z^E&XIx~aCq)EIUT6TF>kpVM89mdm0aqthSVymhalJR*NBXD#!n^b0$T7~6d>)Nx6*oO7Zv4WZ>`}?v z_C=Y^rmYl7Jd@Li9Tg$91iY=s$>@tzR~vfjK})XQ9}EhyvG~4A!P5yy6sk{U6#oOF z1pDZ@x#WK(_hx$6>FIDJt1lNW4KRpr-(lKqfj=+p^_3qbCXR<)V<#&ZEp-b0Cdjul zWL>IQET7v#c{Go3N_RX;g`xV}lqp8(2=!4h??il>_XWsWRA>5Wm`62#Y!cRw>UBA)vln3RkU7&#ZO(Gzkd1+%f)A5MxuPgdc7E>ZR(_L zL*?>*^51m;+jUGmHzqrXGj5w@>gw(7zDS!$Y%Eswi&g~C*OXRsv7!9AGEfU-3XA|Y zXYH79IUu)1Or8hBYgHY#X)o(BzzGcq${A%%LBHX2lTr}M2+Qtv@l?*d!ehrWpw+6z zH=hKcv}EKd=|jBJ%;cI^1;^;Js;u#S8w&|L91R$w{PLoTwv2ZE$_<$@h5}TxW60TK z>8~pHWzgpGnK}2>;hrO&BUiku_2Xnh)Cq_7Ql!UbAyYPKiaym(FFfJF>KAD;L%3y$ zzIvjw-r_32scnsRWbYpxj3GA5bSub3^LG+5hX$AdR3kG@YqlkZvD@J%_yRqe>l&A+)d zb|?_f`dE+2_io^X{k^FUMTaNC_6C??AJP8om$Woy`zjLSy%4J_ISCmw>s}E8>jBM) z&^AVvwd5M3EhEYhy~|c(x(!N~1j(Ne%gcD@!eTwVwo@*WPu1Vg(yP1mne)9Hj=AP# zeMiY*EVibGF&W5;wal^kO#fy*^Fl(`Ukt#afY+eswSvWD_`bNsUB1Ds8_FgkR!=@z zwr81-$*n&%T+dG(OTf?F;FgZMd&J=Yi|RHv>zrO%MG;GSYNxPgrhanfm?V`S@hiw; zNziqhMl-5t`8?cuQ}jkEc}5D4P-c?5i_(iw{SqSV7peqBHuAD9AvE`$P8r=L?hkAs zXstTfrD}?7!wz&=*UKWj0p%^6wv54V-cdeS?^KZhEy;`&yGb+osYEb&{yq~rmuh7C zx`K$C(ll9huo4A)RFcil_>G@@2AQmUT9Z#GtGP{7`-@%08? zyved6Ksb0q$v9Cg~ki_H&q(s){(mk3(mqLd!`Kb4Z^2C6vD5GVLcx%tS7C@ zEW^aGM)PCevXJ7@5CIqKXmpq1T_v26dUI^*xyoNthZ#F^haR!eKv4NIC;i)IaLT?m z)X#rLo#(E0?yFsuvar8c`!P-@Do*O%L+L^c&yIjFHAr?rv)OmpDwq*@cFYj)HqedC zm)`Xy+`ArQ$0qS+x5voAS#jrFxv?y#+@gP1dW>R4NowyIo)i8iDg zPly~j@?MZQ2tA>C(gDswRP5yS-&I3gUK|(a<#pgLu68-t*!=ygd;%xc>@|u<&4dnl z8gu;@c<62P)SQm^-|7DO8i(5`8VfAUeSea)RS75UCy;Jmk}Zm!wA*A5B^NI*L41iQ zl4m{+fu6NQ-}0e9lkA5F9Ojkqfe5VJr$4&iO!g+L3t- z9hO836vTShEXbuP_tj+UKJskMwz{_V{WK%-G4(E+5sFB0SQBt3)m>B{{7CYv#2+-6 zboz5+lZ=F@s@rLt-B$F-yCBJ4TFYJ#aGR>gi@=(c(o2K$1JBEMOuT22%9ms_LQ8qw zR;Ti%jW(oCW1RHP`NtSxL2{$srJJ=NrrH>C7)alAOyJ_3lBNax41TYg`q$~X@xJ*r zGNwt~m1Ji0QpT83!=m{!er1P=f+%)Q3tcUtwEJVoMfo zC2M}E*+U*C2<`Ds#m*D1r;8&?u})npsu!CbU~;zd+7n?Xrjy3L)=P6BAmUF}&h65g zpU#{BT}ri&RU<6xXEKiP09*l3cq_Md(L|$Qg%7V*@1IMcKdFd8ZQH+CTO$b}Vt|I&;e)svagQ5O8rFr`h~SjA$sYg$#-i+`)` ztvaWRhiPfbFHog7@S1h3fhwzh#M5MllF1renxZ#(7Fob5r>*qf0NUC{e9aDt_rO#t zWch-ny?DsZzkYzJ>5RFwMFKmN?>Yq9dp*l50am5k5qqO`D!aE|_Q0z=2f{R}J0yQq4Br!LZP z-)R2Wy>W9%$fA|P-tu;&gPDzFBkDQoTCZ%T4vMB{26?5eN0K$HfL(3EVWfxv$~o!_MFDkY+QlwmPc-)`%|daEmW3;-?*OZ(A3X$|8$x|$R|6*P8jy<;{5!4=b&ZynR z?%o~;iz`>SF|hS}SV+2`r{s`*WbB;@jM2*30?T(Vw-r^uMxOA9%r;f?ppa})IiI0P zua`&f8g-d6>9;Hx$=e)H`~5|~KVujizye6kNPl>m4D@;v4V54KC)!sR))a?Z6gW&# z(Gi>%4RE1(aXwmrXP|0W`+U{xHO_FuJ_ctS;E*=Di_7BO(pco3t2c!z$6}Q1j=E!~ z=yY%Bo(gK5HHe~+hrx(m2Bg0o!i?N3xl(&KvHT^>(mEQ5Z%Y&>Tp6p!hELHGL5Y=( z`Za&v<4qf*ady#f`{wU1+T$L+7_U+Z5VfDxvE8l7{MzkDMezo{A7HSx)ajE+Lrd8a zJ)w_3sFo>3{zKI2cWbXXf8xgtqkb6)ZNjT8>m+v&LIJLUQT{~|QkK&u4vpAf&iCG> zi>UQo&wU;>s+4Ik5w5?2k&$i+VVQG$_X6#NvS>(Kk@mK4B2t${l747?5ix6MPnXHt z<2*Q}C}>G|XTVKLKvw20ww~}K8J^DKrvH&v$})#SJaZcitb(+QI=x}x%f7+u0=rxe z@#UUhzaI6}->())f&F0wgRT`gnM|!1HZ_hJ+722Eh>L`Uc&|t~El;kBl=^vH4UPBB z&S=!vWm@+0d9$U_Y}eQx51ixBm?}BS^B|dyrDlE5kaLgq+7rcP#D>{YAl?uiDIYEQ znOSulM0u{+*o(Iv%XnBra+nxj#tT(Nd#~4N)i4lD%hqNx<7}UdCOi`d+o-PRl}0Ec zspg|@@~q6*mZpuHch`EXzHrC>T8IfbDPEmqy4B$hzHN?DX-B@a3mVcn<>DGN9&wNL zyKAhGtv*YNph7QA_V`(9ZN#O9wU;UqJKQ6DM@d;EiltL2D|4ibeT@gK-v6bx0w#h|VRKeRl_qPjRB#F$&Hohx7gkv0=MY{5+SW>VFt zX@A=m_@3%I&|V0#;pkJ=VUFBOQpPbgz4%{#QCn#*gs$lD_;|WE0$(SHGc!5x4t{iY zCb&c8Tl4hfUy5_1JZA2H=||_;A(`y|oqCae?WH=X(G$0`a5(X1!0@HB{kS=zm`wQV zU2f3MP}yo)<>28t65p$=tUMFY4y1J0{CYMwIk^Wvw*Jp-U_)@?kv|aDi9AnNLAY zG$i#cabbXY#S4_`yefx=?r+jZBQv|?l+dM>J`SoTnRhQ5SIePdsw`+ttdZ2MC zewR*){^JnrKq;E9 zJBJfze%W?=n5shqhmhTW;74}n&BsoX0QOcnJ64c#aeTa2bS?k}Rzr0?=p%~8Yh_eb zRRvZ8MdXWO8D)74n}Q8!Y5GJPd5s*>dnSU8OuLegKFVxTpt>ZA{{Vi&5E~n7?$dg4 zn(>t>Dx8xb+@KHgrEXKR7^N z^ld0aZ!8%*aGdYw`Kt&stk@lYAO9Y&h0_|o|FaQ{Zg6FXhn+7-E>@NtdmS5TUt^3s z5b9s7{eHwu{VPf4e)mDG$IGc(Z5`hR>FUO)O&UKTJ zPLO^fvzxdxW<7_2P<5*53jkfG2zsQXwXW1{T{$*ByNv?6(27q1zrko09zPJT=^2&} z!<}sYQz?`xnP)+X=^n$z@;ODI^)$!i6eFlClx<9M!fic!Q6`N`(n3Wy(ey%lxqtk_ z0*~dDI~`e9qZq079-41ad>RNa??+6iK&i|?lu7CAhhC@Qz8E%GXB=q+GSyAz&xd9% z@HU8Jl8f>S@wTtZW^NHOI>!B#S$^tNz^ihhuF67N8etp`40;dp8 z!RvP|lfg#;)x}$>ae$|2u1vLqm*=Qz)B=E4nfpGJdTaF8k1wmuJZmVYn-YT1s9HE6 zmf|hYzF_)r39U|(15ED1E^$w|GBe0UxaWHMIK)YOq?_y5Vu)>_$*tYo4Q_prOb6b3 z5dU%QYT-+U3F2l>WTALvi0#jd-mrESSPxLDFDCfCJxjN{u!+1+cKIK0kQ7P}<%6;S zcq?U`eYv@a?&ggFGX0gXQdi+fShNr1HNP5HBQXY0f=U1ss}Qz`*`3#7D5g^&ck3_R z25y57uT94Eko0H3w>s1oOjj&IOw-x94*gLzh3JwysvBYh^A5u*%IW3F|lDF@W2J(Dm->5QYvJEJ_hd-$NO*tcEdh5nTV%Fh;qA6jW> z>>9<=aj*~=Eugxqy9@>~;oX#1sH$&jIb%`}sw=TD(mDmqltyD?{@WO*<)_5}8i-O} zbp_;K0!y~KejALHBLLMn=8S_aCO8{97) z9jc0sIgi0RIJgg<)zv;Q=)HPS!%TeS-ew5wsThx7IzFvEgjIE81N@T$qP_0p%N0^~ zK%8NbqXnYl4;XVLFN!5rzLc62T9RPUR@mL?f#iHV?NzvkXO}33N+NbcQSr61w{9GZ|IZ@A!G!dF8 z1duMs&nV1zu@S$rdAP>1&9d27_gJ<#||MCYk1vjSop zgx^PFjSlN`AZQb@^-~sA@4fNQGiBp{DucgX^lH4gcswYsbbdueCIr7M-zoL|d`6vt zO(M!=t~J<<5l>MU&3NeBRQT5w$3>CImLA4fR3PSm&tG=_^wX62=ubiF*y>fN_<#`B zdcN-OV~p8i+YH6Usky3xVydAe1lw-*cnxm~_6WN?N?E>WEf$^v3zd z%$}qKVx~!M#XKs9wuq&m6mqOkcH$r!XN6UD3u_=Af(VC$O%p6kxCQ3<4RIw)ab>TG zc9?nM#$LiFNd4&#PY=(jr;XQ}#jXRGP|c0bblvXXZUdTJb~*;zC%%iIfbA)xzNZL1 zAW^2sGxc~TTo)iowD$Qq&uoG1{FEl|KJ>Ew{CmLR*=wZI>D*l};;g~e=HBrp@%L*o z%ytW_c1d-yo*b~>WlP8%>!}`VttQm9w|p-i$2&2k6dIK@jlXO-|1wG^Rh^5e$i{pp z_(zITpTD&&d|%w$y&Q1}2VWy+6}B+ruZ}j4AF;nhkmJM}Z=G2=P4v1FNU$gwQo6B)R)#b@?> zF68fp9Z#UDkn@7^Ya_|VopFkJ)^+;vg^D+qE5`S=H!w>I&+2e~#YYF}4?fGZ9jE-1 zk!d||cV9eix%!Do;(>}xhood^?8dk<{3POtK)>n-V~N<2K6t!_LvGCWwD{YNFJQrD zmtlb?VI#^+RuDW5dDH&oUaEI>S~aOeit*{aaa+f%Yvx4<_iHOF`@YoAkRenkNi@0k zE8I2q2Py+k`}x-cTlc?r1a$B4QHw7GfjXt6q#dPL1fHyFl$7=+C`E`_gtqEy@~c{e zsMFp@2>@tfQ9l0|Xbi+&PIOw7>OHsTDhusZ-v{R2VSR&>tqiogM^6ozue)s&f5$P&lOZYIFI{WC){?AbR=3dWGF zgkmu;e1!u%h0&M}8uk~aveUnzPXx8lxkb8s(u><_7KHwsisjmJFN=@~DJ!zRFUzw646Tn*lsL!eyCP4D08C@K&n-)(1TIgm}np z`sYu8hHf^Z`};sZZSjL1=Jy}*oFOcAvLyZEot&5@RM~S=2q$gV+^7Nr`Oy2Tl%{fXZ{o?>VpS2;#lcJtI%KP)xhe zg8N-MXyjv@Iw#7%S?SP-3{^zx&eFK1ajjR+xH!XZ$Ebp+fP9s2bp$BW)kf(sk|Se) z8wbO!{D(#O*;ePFmyzQ)`O5p*s_?XVU&MhMK&piuXyv9jx*ZrHDZ7aviqfnuyJrV5 z%CXKWu?D$=njA}SKn9U={a(mfPGrBq7k zlx{Y93{a5n0iy*rx*4z$|9#%y-}ztSa5!fdxUk3b@wmrLpqnOe@!C3<5uG-pdwyfw zU}-Yt=@Uooyv6F+99&oxSIYBesN#FCLtZHn&wt6wHGuD7dUFN}yD@c=D0m+HC%P;i zL7!^a8`^@T(5vfEhCjE^mRGIr7sUPkd?W+ zmb!9St-v$~%}^?w*g0`WRb{9UPg(q5hmRP0N?x zv*N9PU$7-9R+IMD?wq$x#~4QLH{;tg#P>LXpC=xq1WCXGy7Liq4)}nt%GJR^<_e(u?qH zQ;#ZTAyl7wb?@3|ofhUao8vc>oM@f(Y~%OiQ1~i{i<4&JRVjRfR>3;}R@V5ctUG_> z+d1FdR6)}D5aiUxsbr2Afc4ryd|u$2W6*9^`GaYdFQtYzukKnz3tMlrS65tz{NfFp z@eW_dW9=H?!(HV#Op^nbXV zREa-XA5iR*n*$ppQotI2y@S7RuLfso1s8dww|bQxU61B=J+%K3_^C2-!Pk&~6kpk@ zjQEImf`{x<`^koN1L8bcrLIw?|3Z+?u zRQ-3%4-&^T{Qr(Z1esk4wq&46YFNEU<7^QM*{a8HoE^>8GH{4ZpwaNt}e znngMMFROUA>vMs-V0p~s?%~k`LUrJN_4SXrSUYwtv>1T~6E5P*=r7C}6T>d*EQJg= zVgk0R6t<2dXT0zkn+?$Ol(X@W^Xjt&a7#t|(cByG?1g>fX86TSy6+M*nDVr3@o3^( zV~Fj5l3#iA$@I$r{IcN2pH9Atwcbq8B$A6?8a3!K=-$s?cWxNYl<^I_13R=;sXa=qJnL6rFBN&ULm)2l@HQ;W0-(+ zEiIjTUizk(DApoxh!`{J(`+FnGkN(;kn8!zoq2(wy%%SuRxNI?-YVVW|2xNVx(IcJ z9;3)MQ9=+*n{jIc;YJ5M8DvGK96bm4wY7%{vsyTE>ac-Q)XC6kHc`4Zc($*)1-y&@ zs`Jww@@6in0nAzT%G`u;hWs+JumV9K=^I5d07SUvf3PPsX z4vUHIrHpnGlxMs9|JJ@9wHxodc=iHps)FSAr zXOa5rr@`hkqSd~C+wsOeOByL?ITC-H=2qOQEX5~cr8vb?wxc#bm&U{2_=oxushu|4 z-?iR!xWN2O5$sV zN!sW;oL?`CFY(I%NUMyTVp0Jye}$91g0#DjG7ijL@#a}f)Yn~H$)(7V=$j08wN~LE zxUNvFbQa^1#Qgm=wdXB*9{jECG#G~ScP$c9uhczGGR1PGLG)SoBeJjTuu1?y6wE>| zV&(p#dr1DxF1osM5lq^W`$;FvyzEgsNva79Fc{=X1j$Q0Y*Y0mIbgj~sNevyy02yd zr#bXPUFC=A^#Ed_oZ9!gwU`w=0iy+Y;vPsjTVlyN$aX*KCo!^$U0Yk*+=h{I=Lua$ z-pTu78jUEz)Uj{N75k3TY@&I>U{+6|LsaCfAzIDw>xd%d2U#FTz98-(E{Br&>kx8z znffp%_k`Ig2K1$i`+9~stF|M+p%_@w|5G5s#uJ=zqnXkd&a-!=pGy$ugOtc309RP= ze;*v7rZs+l*%ojEZga0G*h(941o6PX(50-v`mZgpjr07Yx=DehWHvQ7AFgASzlRQ7 zU++=wL_Y?c!~8@FUBL8>FStJtlPRC=Sp!Ugis7FMXa}!AnJ?J`;2N9OD`Py0!#}Dl z;2#yin;2hT1%Wy-X6s9ee|;5h7RrO(Ty^#vW6OkMSS7A(GMzXhHvxVtI+)&Q2!C$D z4BF0==`f=b;|sd>Hbm7qov59&lwSLRaFXf>U1^#hK&`f#~I@p!csUYf_tnjT?V z_mq$MNJD>kLGy`nEEBHBQw6Eq)h4NH)UHOP$g&~ z>(dbw`?gcdm)YhZ+MXIFNlF!-7Xu-}D}HZ$JHDj`@kju%)61%zEiIh9&lU{0z0m(M zl{(j602}3qB0AA5Ku=s+UZLZ$G7rT`!^?C;Hy`#)A0D& z@8it11>;KqpJ7d97{J@iRb$R^c3)2(k%jH9vnr1a8?=(FC z_UN_cT(S>QQPi2=0JQvbKyjCmu+4Ng;Njx6566mAPYy*WANUMfZhF;O>`O{d+oWyc z1J6LmBZ8w>gP7Ko@nw&NZGtEcyb)=`7FXlX|8`cd=AIKQje$2*+NlKTY}6&~E@Hk2 z%x2yQCmNQ9@gMz$`WMhE;Jlb!+$-i3_?$p6g~mXz=Fv(!XiBli!((H%Y;0^#mNLkW zJr2mp@nWp`S**bLT)=ko=>7kb{MjNcpWFRUu_uQGWb`(DhfXo3Zh3A*=yej=&9`Nl zO`gWK3S?TOm#3$%LvvTxGvS1T2wjbk9nsa;qr=17E1lv_$FI_)rT?onfYw|;2_d@( zN0rF7z+n-ly~gi(32~D?_S+#l=?Utpq_yIfhGEFg91e#>73*yzPL+*Su4Il7iQ%Pg zE+#5-#)$?7r3U2+8yvzHt}It&-(P6cko_HkOkU_%&2(hImcnb9=^ffed>M4=>}b}G zEEoLQs$bM1{QWkyvCv+N%^{;1wor%Ajn5Ho)%lRdne>3YugyDAC|#wqug%1bb^_KT z)(A2EW<63ar9T==>(*k|F6qa8hh1l(9CG=b^eZupqs5K#*kh&K3^7DUcWMekZ)Zc3 zQVi!&yMMtZ+Y1~ye}FIFnW@nWt6b~cklNbWz?pvD5OQ>pWJ_8}Gu&vFv8>eXgjSRx zJ*4j|zW&%2B`RLN(nvz08be$%s_bf{r42C~Y(ckAw{dF?Qi+MKUZ6i;!ixb5Bb~B7_iwVGmDg&3smrOJ4P`A6$saRoSt&deIA*4FdfIl7b8@S zmtikm9R1=j$-x;z=>-~=GH%YqvqS)>n_49Mwi#HHg5wiA3|IVpSI-p7HA|Pgo1`WmBP>eDa(dEA=YgO zZJt-oYQ)KdU(Oz<&y6EE6C+2q>*x0Tj)=1rZKX&-4fUzrM%lh}(&xjGrX<;ptFh5Z z`8gSJGVyOc9e{X#XC3ieGkes`d?n+11pk3V=lNyShB)aZmFFMH zARJc5YuLa^H@s@>;Aw0-EG+&&8eks1#Jmk$kN?6}=BcMUi3Xnq%>?s0fOg!G5_VFC z96U#gLf@|ZQsdn*GNrgn@mr`qJM%*r9EA2s;G$K8vv-dOlyP<(Q(p94er0ScHUH9gc3bTt1)l3xqWT%6 z9}L=7JE`4+T92@`80?-)T58m;uT61N13K!PmME$GI`j!L1CP6dyIgQ zHk{%&B`3uzQ+@KP41Zd~n;;Ib#LvOs!|N$duL3p3eF}b{r#%0Ll-RMr_=-4?9ozm6 zkp2-ee_yW)8TxKiIYKXiW8%Fxh0cR(#mHGB4;DJrf{u>lQ#o=nb5xtzNz>d!*W(IC zb@rXWnG<=KRj8VJ=9-;|`SE({q^!nLer(uset0%##PH=U=$Jy;gm6%j6^*zRQ7S>? zX!o3^lt1ti%&?u_S@_<8EN`r)HIvl-= zZU)tv4NU{a^-h^MT2;9SQWFGFwH6Wd5Mcg8!2|kEoVXkP;ocr~V5QK7y@fVze{aki zbLINSXFZ%lNndFZ+U#ee_FT@@l@h#d5b;dp&+08C1Inj@=AB8o-^twtrO+3XYTANS zC7@p3)oqrDM*m@ zeZo50rr;AR%JVsDC`%eANW)8G)52gI;ctE=L3-YvDabMw2eCQTUZZ?ZL-p!>k|TMs zh;Uyyic6cDr9`E579)4^C?&Q%s^d3Ejq9wyVU8;7mAH-45c4Ar-L2baZAZ_xo#DaM zUh}3A$DEg=CC#PQ1R7S73!%97vS^OGzdCA`ww2;{Tfo%8+ANALYUXJRt`!d z&QeDiRj2hyr9~iMEx;K?lNz+pjbqpr>dDgcur-rFzayP{7NR>|Aeau#5X7Lc9desY z&Y{6Q`Ch!YbOW1zq559n&8*3E7x%%|@jxwIK7zSnh(79>Qb5Gg00^g2sk5IQ9I=Cj z`)_nTG>=8}dPLkSjbDn(`GC#o6tL17pz7lWcr*O?fTWz)rqnUxzV$k#Yx7(&mXiG& zp&PV0AI!^kBEN4@1k@5&)_k2jN}jBfvalT~7GR4_KSyjh{pB0lz=`x8mPDJc55c0ks}HZYk$D8ZfbNR-FUIcXWPN z9y<=!u9i!;NBcREEdcn*TbA=b$Hv~au4h8qgEkFDs;5KP(dn5@1(#{y4+<9Kg?f)A zz(tf$tC%jzzp|s_wyyr(FQS+qk6%JrJZn#XIyVWGMrf7ps4x=z5R^|_O7M3{b;aC8 zftDZksMEo{Gi0Oy_Vk>fi?Hd8ISF`?{r&pzd+n~aw)ZVPiXONq^N_Q{!ju2!?2EjR z=qFqJ$h&yH8@WdI&)!m3+-k~s?BIWzz)+5wQqJin`)++GD|~>Cde#oaa*vpzmAl zZ21Q>tA>P(i<1HGab6j0(9w)d$nm21#$QUGNw!#JD=p=BhyiEXzsBhLFAHS{Kx`tuTWw#v7OG<%yhfK+Q`SG6M1|)bj}x@G};| z$a@x>mDsOn&?&=R_*_IEu?b;PmYPVIe>?LL>eDmf0d0^r8LX@*rkIc$bknVWNm?nz zZ|2BYBEhqMBg%mnyz4G*)wAh*DF(?2%ld|YJQ2Oou2bIzC@HfsXI-5cM4v#+Xp-gG z7;3N~S$L^*|CGKsCf4|62&AOcnb-Brh=Mzki}T_VCi{6-|S z)+m+m1&1Ek!q-%NN2VkZHju09%S!07Y|(&WK@m~cWU2kfnImPY>JI3M3J2pbr z)r7AF$>7eKjr0>!@ArAya)iovtjAxs3ZMruJmxrb)Z+Sfs~j<_@Hg2p2YIVx@>c=4 z^ytW>O5|tR$0qt6apDI4TkK{^OQQ3x-|)ZnMnCVKJ@2)@KmHuWoxK0}Ad5GkXIcp| zb~ZE6hpKb3NDVnUx0n)@aqMzVWh0I!oMjIz?fYNGjmtG`;-W`7gFcn|U7(S-M7n$U zeo!61sw*Ee+2%cvb8U%K$=~(SX9V8y&Bb2ezCZ=ZHyENivKg^DNFkn1uV5-lfryrk zPskWH@;0kT(_oL%4o%tJNejE~QbPObbJEm@4@&24JYT6-Y^y<>SAbaA-#O!z+DLs1 z_hJ!?^!+M`(TAiN<}4v4{*Mu3X$)V1uQ$ZcUygEd-*}PLJsecV`ikWfNc$4!` zLb3SNs~k>c=ak1VC82Q9$Il;zbyD@hM2k!~eXhXRBj_6GTxbg-D8S-G(2%@X>i#(; zt*l4^kv^JUh=%IvrT?QIhQqIi9p7_qgYo`@j{Kf-KBM zCVPLwnGU>7DkZG*+H&=u$Ccg10k>?(<_Zk@a#icOX7Q4sNC6c_UwU89L-oNtU3>`~ zf**sd(YU+?)I1dOD#@4dIf_}U;J?-NG08I}D)t2_Ac;Sh{EX-#7`55?VQ`TMC6LN% zsXhkxORl#cOI?S7#NqR1Ki%rL0PrBoJove9JjnfVJzxxzMe`TH7skVUU1CICbAnHn zMt^@w(4$>eC@I*hi*Q?HEAT1J?#}bp754(fK$LHp;8BWZojddq;ZHdZIaI|u5>Jos z0GyqfBAg#N^wY{Pg)O?cyK&3|SvAPXPxE5fkFPlQ`|xzPA4)N2COlv!t@_&}NPmy5 z_)}!K`FX_OyeR3uwkf&kZ`9YYC$4OddYUp2aTDV8SA7vyr;ZWn{$6nUGX29(lN=b5 zndEp%32^Dn2*p;QQ;L(<*TPEsoXz_+uxqK^!@)JpS;+exCfplpFvnh>V4b;QC=q>K zHSqn{UlzY`6Z+6)-4ZRUlv^12{a*yCLD_=bll0$aPK-OMdf?C`a)Zu;4Dpy`?)mb~ zQmGkA3bPTuxpif*Z%vjo5H0t*s50*~ydxe}g`-o~P^xU;KdKA#0E3 zheL@`8PrxGoFMu_=XD?}jXz^OFKC?Y-Uq>EK+0M&(Ma;10X0%C*3259w7yZf~m<@9g^ z_mtY_OS+X6F~;Ds9O{jo5QpMtQByO(};e;DRnNWa6j5_8Yi zEnB=m;=Wi}Q_%r4#xXGec7$RtDGGD#JYw(mfIDo@w)6^i!#$M|%}n`D?d{k4Yup=q zyFYb}M{Fo(wIX%{#VOp!eVE~IxxTs@2VccLX&`_3a3Ep_`5sa1Z|pUv<3)g+?%hhe z-Z2^?`qwo zzInrA(Q~M>e5SXSV{?R*L02sGF{V>cQFx+#ahv&=y1V%JG86@*<_4!Pn5L+oGcFrH zCDHg#ZH^^n%ZvP2B>9O>us@~mw8)6yx9fm zK5ebHCRYtJOWOUPC-3NW7+|%nJ|!U8BhptTfreWAkFMn6;xdgo-76=olIL}vdPZH* z}g(~+^Ic*Cj>I4Cn^l;4WO&tf1ZdUA5#zVxikFW@MFV>8ER zt|oRipuIm$*^x5n%%B(VYHd9Iu?xV7ggOdf0Rb{fTil0N3ChSkT z?xn2@+B)VST}*zinPW?)XNNS@ zj63^nKY5OPVry~TvW{=K!f&-wP z_%7$`=0YR-m)VX8dCrxu8(u^Itw%KruNI!7W<%YfMZ!zZgs7glMsNSQ8=AG=dmsoLm9+jh8PHKtmiT0tSQK4bjZz@n*pdZY|iJyaL;30sU z?*dq_^PBto<<*zPS3C@&VQg*A6xTso2icG5^fK?cKLx`8BhXXzWsq9tEUhQ|{GX~l z)-SAMRjgwV8=p%n$z>|zcwYnI0zu939&lD7D)r*Iam)9S^bqaJDw5BRCNw1uI z#~2eI7&VZtSay%b%GAIQe%Y%$!|$EYlX2~mN1vnaJpo7_8Gw9!LNP<|5m4F%KLoL%8}e@u7sa+1s#93p?>N0mo5`bn zhs3h4aRP*+wVBn6#9+1^(Uq@xUEF98dX~_VX#IH!+`IlP{&`bF+c9O(&a){XZ^H8B zo!|L@9tg`bt2Z}2?vN9O0HIf$Z#HxWhsO@_K?D*aEm^Cs+CE~x#HG^F5tO!TJ2!3u zMsc#6saQm31d0#>G8Jh5=*u{TjM6%+2ABC8EJH?n29wV6lLOGyRy$tQ12 zyVbbVc0n$va3NB`RCsG$A*I07;84+c_ueuWwO*$Z#>3ISZJmb7n^V_D)xmxArg81@ zy+Of%A0#Ee^%q*5(p!H5oye@dl!9YL{`I+2B#K7;X6^o-*?) zas7GVeGJd|c#ap>_<%fhFE{tY1!n4}CxN*IU3DxNKI)dr1!b@jRB<9_k3vY(4>kl3 z_Gsv+uGu2}APAb_eBd)S-!f+?&bhIGC+fM9RrzAaMx^Oo*VSJs$ zFyI=&pf5OJNeJq=6R(dXgTDso2R{4qO7xHTTV(64UqU)5tlPbq%P?w$!%t=dMrr=`ef2U(!B9= zmpT4|TT?^B*v+k+Y;spCmUAhD)_1>BF;yL_OdR}`FLTYqD#G?qV)UGM;-_3a_7$4M`G#KX$#an~-?Zt%~O1%3O@7$uk5 z*N5B3JL8SCTdmcs?WtB;>bd&~d7$et@g3 zU+b*zDm86wc>caL#osF+IPJ%fvpYu9TM!c|7FoBF2hKU@cV(A;q;I{us^YC746=8M zp=<9klOi>=444U&W^{fDL#Oq+#pB$h%0Jv+RtTfuOHD;?ePboRQI0l7f9?~86v`)Q z-I`zJEBj7~rOG+Be>gKJ?lZQr8Ik6Fx2y)um=xqVJVN6wW$8F6;ctjdCTcHj#;{t= z&L^!F#V>F!)s?pEOr>(>kPB87__N4RbdAz-3U;9#{A9Tktpx<}^q<54Fp<(G1Csp7 z@UTU6UcyK7EsNyMJL91I9wTR>@WgBbz-QXdDA<2w7K?lEz6?NANDSOrwP}2j9268? z_6OrHZbY@itM}%gNp+M^5M!?2#KPZKbP_djH7~ikoZre>7_0{wXQv-~tk;DrBf>Bm zJaJd&e0*b^OI<&eAX01gYnr-9fZyoI)JTgsQ>Vlm>r|8NTRqSC;v6gOxP~Sqz)`x2 zTW4piVG|q=KfSyruDcn#e``H+hNl^|5*!#iz@wnhD9&(%z$Og;+VtyUK@0d}e&f4Z zYLCqd^$3A6n;VnW0mGKllQroCN&kKp;@b`t&TK1PQ4OQ!`;JoV@9pw=o?rU zZ5LLFJD2<#Xl{Ze!YK^kpMCErPtPr`!O-4t?y?mFarx2Es+kq-+BMJ~u=40i;lE6< z_^Kng+ZP5xi`#3aYhxV^R~PaW4r$%_(I7M}h@H}(z8gB7g0ExYhgeb3GC7Zg-?#9x z`~AzKsuDz&1(|$}wHo1U6r(I3Z;rCUX|;j6eruSyDXjG=4G*Pa=p}yFbj~e((@^0@ z*CGf-X!u%6iE{Dw(Edx#-)p(;AR)%=qQ@&LYoN<_oiw$bC>k<1g&4M6%E?SbW{yL1 zMYJM=lR#E5$QmvI_vYMgAo6tU&FNW`%5Sd1RkVpJtj@^qwYx*XDg2BD*bu_#Gg>`B zG?C-w7gKE|5X#7%j%Fo%SM_=Y?u(&CQtVi2H1mNkiJqR`;bA~Sf5ta0pbbQ#-YL}K zM5LAK_cfO}_Io2S`h37p73B-SrQj2&S)vwp6@KGj2CueAFVgADOt9E-#{e1Vr_6X& z7#Q8(ui3u94THpI3vqvC+3C1`lQwu~;TEld47d7TB_K@A?=~xzDsP>4LpzUHbi(+> z7W9BRmx2>?xiyJ5YPiY8RcuN%e#!_^(7sAXw}dQ0WH<2?a_oEk3S7$9+yb#=>2Q?| z{YoYm7!;=iwBI9?2bm)hdG1r>rh2jTXdHneDd1cfs*3ms34OjTk6dP0yN=)eTyrap z#2Skq9`O|I^3;4cL_{;M!UwV4sjRQ2+B?N^0#!{iyNpY1MzL*mB~KRF^yKMFjeS1$ z*ALePMjYIwog3#lxi&<+qY0iW>K5>{*I$*!>~3abwlXyUt-d~AhrU~Vc^_mCY_lA= ziwl^-2SzEaRI$Y6VYr2UbkL7>3A?39J^#SC!|+!( z)Vg1v?{b_bOVQE&R;)0X5T5|=`pp0Fr%rfQ8nVe-a-E<9u|af(8s@c%nMdgn*G6Wc zr>~xnt`16j0jeHKuuKMw_8BPnHwP}EW#J4oYcq4N10EE%JBu~j-EUj^N_wf{`ss{b z2>drj`L|7n++npc7cGYK>)aO%8|vw~Yjm{mZlP!a%|BAvr2=L1X^X>iRz7xgae4ks ze}?h`s+|uz$NT8vKo@Q3^+{dd#NXCoL1m**Tt>5G4QN6FmKP7=uPX@{`HfU5*?tn7jJ@6(%7K8Avk5^i6^!hvQOiaSGtrs%pBD4_ z`p=H)sSKt2ZE;C@sP;f028}C9s%!)MF*g!3iPHHVR#3v0T>8v&-SPbh`{Sj$b3Owu zcx6FG6@e=b@a1TJ!w)-6N3hI$uq(G$C!K|!$!sj#QfmL@qPmYn>KyJY4)b5MS1X&;>Vo_Z3`C(S8C$({}V zo;Kj(Sj3Y5w>sUKI_Jm}o1Vn0hF;U7N9nGlGsMN~@$++z|83)q_vZ-&)v4L*R6F7A zfeOr2TXjUpj-~DIx)iSdIef_CWXTjOv z5zQtr)p6pX7h3%txAK_UYS*4@IyH}?lnJ5q>E=Qpd$cIpCB$0?!{d78e3d-wc?Jk zX4Ul4A-P5;A}{aE)Fp(s@%abG@nk<<>BdXyxcc{bW3~DHdJLI~9}MofEPHLIE#eNB z{O)U+B!`(-D&38c{*7!2R*rBcb${7Eq)g?d0$$~67^SutGbcWsJJ>(2gBYnxC5&J@ z24iL(bOkuB#;tx|HQnw+;!)i>D3DrnU4?y0#NjN6p zmnvy#*pA$iCr%^rWSl0T@gVhD#mOX@YwPor!K)%YrkciqP9*F*p9I5Q2Ptz8ZSa*$ zIsmvtk?A;oB#ma_2Sr?Ynxn`^WMct;4GRDm8476n{U=(f0Uq>?yjusicj&LH^16&1 zav|KfgkHGvaIfi^@Qb${QyEp#EK+QuIXS%ugCDz!B=ti|sE@J#6y ztL$!Com`&GG-JdE0)^3F@GyuL)B<{$Nks?9CUAS_{aR>!gGhKw8(%0-NB_IiKBmAC zbT2EOI`BPIuct`mFgxnOv{vvi+vR&OZ?qGjx!e{X&E$!dhZW!$|FTtds#q08k9|>A z+v&q#l1W$nlyY-%wC=19)GRDk0&pGj1=DNxwwk|GZ8h`ci&(Jmb}GugQ~?%tZPK4| zLXga?5ihU>d3|HPpzdfD5XL@-jh9UY!A_rGQvhjbg{^vCLPowG_Zae%v>E_%GfH9l&tS4VIP}C}nsj?A?-K$wMN;0Yxu0 z-3mMhy9PvWWf`a`TpDRN87OdZ6kEPPyz57fk6kVG3e2c~csQg_vAkdMvLp4(>II1* z065HffLk{{Owz+WQeAJBcT70_s&5}&LL*W@D%fRpN>+Mp;wl@mRfALUaz3l(vtM>j zDVno>jA%_DujKsZIJN?C0m~IVj1J>CXxG&>OWJUxZb?ZLwdJ0MTOG~|-*)b0T75Qd zM9pmGxf8pSQ^uJu?astPKQ_d2Kd39=9#=$Y8M7rM9+dezwJOoL8Xa-`vE4J70o!4Z z>m_9>wd#u`LR~kt4LDL zk>)s!K4Ay|1>78OHovb-`FdEbJOd>R4kq(ys7azEfwQ0DTE^C|{*K7id>n92$2@?P z&|>RKytTJ?&H6%a?H_T}Yttb~$WZp+-0n$E1pohHl@mD_KzT6CrT#5~b4 zV}chuy~9w;_jO_xdTTh+JS`}dd?N~6v#kCIaj+`zx3Uba-3RokXil(b#P54X`@~#ZSM|2vyXQ`C*nv?@Fd7` zNRA|h4@{yP0Bx!fqbj9O__Xy&O?`JWSbn4Cy2jzez;evV0sEyiAnvZ^GW+3+^q-sz z&!f%pX4g3ZcUwNMKi>!DQp#JVPx}w&`YgyMwGhMZ#-W<+>}LX(uWd8=*7gL9U51|X z@E#tOmA9NXM3&`_efyu!Ez!x5TjPH}$-qAIMM&1j$VgdRQp0WtlZxuj&O$q(Te$pK zd{kau-mLkHW!cWHnhy2ayjw|?Pf*F?g=7-o&#cEkFv$O21sDC{|L&0X!FhwplUgHt zA0ORa@{uD?^bntL`L^EPnh4>ur8q5KD-#QgA)hR!Alj+Q`ugM<-?Q?P#^QGJn?Q0B z&kS^A1%{r`EjJ>OYjcxGvorB&+T*DP&Ut9dZPTfVg9iYdLA{4>?LeQGeP6ggcTK^Nl7i9O2OC}vX$z9BVaAdbmNcx z_C5=GGe4ccA>KI`@Q3&$+||KJKFmGsSs3U%95&(OT60Hef|qgR%y+)!fTh{cSp(2k z+xB=M*sHIo=6F)k6a5f7O~kJd#~nS)3^ruoxhlGn((_sHfr*{@%;pP>Fafhafc<&)fwRV3lMn1fW1qBUQ(bO2h3_$yv@{DbQyckybUE>FiiyQ*@-#jg z5gpwGI9#72({;M?%g=fig_v$>VI}!&`sw2jdGZ7UTu@ zVgqfFdRxr0^Q+)mPKH{dgO;ITIc4I#rSY&cvRwq*6H_J}q&T~4A60egA2|DNp!0r_ zB=Xo|9bY@^FGFs_A*GU|`{YW4^8vD%(txn2NCPakRR4QWnqfKyj11o{4E-^^+VZl%e)fe2kBklMD$$g!hMle#@Z|K z;!l?quU`OQI)>geTZ;y9Dp}@1rcX>y+gl%7oUgB}dCBiRf*jM&gIMT+j}o6pS1Z!j z7_Gxp_@d;^R5e|_v{~U=XP#(x5ZcNBFNrh~h!WR+OgEXry}DaT1;3uwF0n6fcnvzN zoXH8*32D842TSuBh=&D7Nb2DZet+%jqnI5!lA~o`5wL!*CyoL#@H<|sH%KH87Guy#n><7q( zi_9s{Q`R40=S&Aajh76yU5flJ9tlnR8J1Gazx(RM^_2ctuppeAkWt7*@R2Hq$@a5h zmm(%+gH`1tiY0cKQb#mP4%}IiPyX^#3HbZ4DQbTTo_AI^`^%jJX#fi8tf<2T>M1N^ zChOqUbvlLfx0PTAgW3GOC7`U;WWs4AY^1 zU9b9-FgYS&l2H@Ml#n9@T55P8V>?xBJ9TrT^z@$4@39B5LVc^r7#i5+#m95IKT(=` z3)+;u#RG9z2*C96DlhW$5TD_lG||iQGI(dOL&fH_V?xA0H-1N-_5*I2wnw^HN`(xa zHPRYkYgXoqVpXOPxfI_MIO4Nc;^<~Q8(M>uN!nbD1`I=e;$XJm0g7m9{bl}6Vm?ihp)Oc!Raer+f8zbU4xo!5b|Lii$ zgMu~?RaF^?kN2q=y))}aV}b)FQ+Tt`Y^(8o>RPE|)DNu)F0YyKU)U?Tcsa_`X{I8HvLMkj)l2oEl`>o&-r~fyW9H{MH@5HTxdP7AT$Zq} z-@P6ZoK@24^(c4X%9Al=B@RF7F38Tabhff5#mM_xigDTnx1!1hqSM6-z)1Hx(p5&*u(o)&jMa%3i1sp6oDh?7 ze#QZ*80BU8*LQ6~04f?q{B*+ANV%hz1e*-uvCi`amJ@%#Uhsj~vG`FqQK9D7;f(5L zs;&iKoB0ZJ(}UQp9zv$jWHbaFFGQR#TF=tnZ1J(^V$ojUUGMLY=?I>|;qhl7LQP4k zL&T3978P?B=SPKJ|2f?2^IXOL8~Z=cJelaq&BUh21e*lZZa$|aCnWgT`a-I!P&ePq z$)C*VeR!q&QJ#&T-(*N=8`R`m{{Q9JM5@c}H&W0eKGSd2)+|zu?HmajZGb&6?_=}7 zYMtT>Q4x^_9b@=~0n@RYt=~*SjCx+x*~kSkMD=2c0nWb`f(}B5C{%T<6_tvL%N^Iy z^Ki}x9+VeT$kTCtq{TH1yIWYAy`x6|53Td2e)%?OW;@ts+=3K9+Jv0XY$ z3^-UIZA=J&Cq`l+NPE8VlMf+7yJ7){lMx$v`Fuz`Bmn)SaaJ#YW3#>1q6W2_%B1<{ z5}aHTlPMO_rjuC?!J0LfEn{QV54YWFF}tx)8!{$O@ppxC4ysnhtuDRETM8qR(UjEH z;z?Hf*SBw54GhO! zoIR$-F9H0Sb9l?ZLc~ErJA5iygY-QI0|NL%A{2u!yrlE0)DylW2-~KZ8qvY5tvlX9 zzqzBy|4SGe06M;E!+qQCoygIz2Py#-Kl`uqC*YAOWm2xg-yMftER$dJenxIL`efc3 z?lGDAewx~}g+UAofMVGCr?^CSz) zb$s(xVi3H|TF(x+xJ<@o7s#QX1ikqjn1rb76^boEyuq@?d=7lsfWr$L-QPs*<9x&Y z|E-rU&N~X^Gz(pTE)I`W7g<3*ZyR0{C%zvMrVahN26oSUT^0j^qp;lAOkz%DzLGU# zjvQvFQ>r^fac+^e?|gffOyV>6u}xOc8=wwgrGu{#((T`mY$D5*$b4e*Tka@t%kS9_ zuoSH9ZMt`q=*iFhngL1wHwX)X-z)i$^?(WDdljm%0?$9?{(nH1;=M73l-g~PN1VzF zx8&}6FfCJ_^Fx8FgFND0p_c)$Z)J@9?4QjmA@yLzCr^zYy%by9@22?5llh3b4u*iGtJ?kkTEvpmDP*}u~5q^R6tP6TRz)~v7kUhY&@lt$<) zpY+6mKcm0DVy}W|53~CQ229@MP60`Do9m7o_EI!Lil9(!T6A{DQ`^SxToo#}@Qz)y z?s};-2G{n3#fAn70_Sf$`mIA#^b}O1B3in!Nh{Y((JCByeu;T+qL6tC=&=57JfS<@$p_KV?qg z^-n(1!@Jt;ij>hTdlbcg<}+2`&#N1FU^M_+A2~+{yifiap*yN%^(`GKi9{>jz35Dm zc42tx9t4u0<1HVNJk56iFMpV_tAt|?kUfGE( zPiC7!Nc^U|ZafVvmiX+04!@IbE{NU4VD7#D{P*Hy(EY60@HrNzv2plTBQ~uY7tF}N z`_rR4=E{T6V}RkqrOBp#FD)9_(~F%CQqd4)CZ5NWB}(z~AeW-Otg;veY2{JpW+$z; zxARepIYrQ9O5BHf`+ix9fx-R?F};ZHw-V1?fz;Pb9q>EWVyn>WE-F*ISx;5fkD4r* zRVbch?MVq)LdKO&dR}!&C-xu}WvqqwZmlZYr5KV^8Q}iczFn_N)U%MuVlY`1_Kmi*?@}TBioOOsE~n*X-^z z#+O)^+M{nq7Z#5ciiXwvk>Sz;q#y156O3mF!+HFwnv~=<8B>Z_c$(u6RPFj;sXx(W zPWUaPE(=anPnM5?`L?y$7M1H(PR(O1sNu|uu14jSQ7e`lXVCo+Q45g`=2VwD_EY~EiC`COFPaN1)` zwE4}AOH4^0<6bsDyuvy-_V5|v^GVt#!kb4wXy--YgG<&gR-r-D@pD;G^yr>zt7|U% zI~^ST4qzS94;5^$@|c;xnnD1}S^)Fm9rFp2tdmA1>H!2l5T?C0+NW&v4Kn$eJ={MFGcFp0fNPKIx=E-gzaP4yV5BqnLDBS%H9eY zO`TNxUyYqOc8?WibF0iR79FjnThX)}B`}?^!*0y!o+`w4Z?11vq;`B(Drnq%zvaBe zW6{_6$j!~rbYDT=?t-Jyec^raN!AueNayKo0=Zq5YiR5^P)V>_y5A^5owBk z!yO$@c+SZc^)}>+dd$%;{Rm+FkeW7;ylDG3UhME9QL`1X&~rUU?}Q6)vEU8pFMg3R z;@X!8P|Ov;W(?W}>U4tte=ME#Thssh_FrSbkQSv=Q9(MSYlw(|lysw$?yfP0fT*O> zAt4~$-9r?lk?!uUjTmw7{r%j3z<$}WW9Rd_uJe4Hlb7oWjxQ`vDafYUu4iuFwq32s zO|jnKf@|3Q8B@?IBA)vSOlT_&`kX}5621?h)N@iG6@>bR(Z#Lj(oJG#d#8%x zKS!Loxbs2F<&PHZy1l5tkbO40f+%w+-h5ni*O!!xz=4|@5&&^|M^5~*rvrR)5gRR6 z>sMkIEprGlPD-sxIi`L1xPACEC%(5z^l_lmb1pe~tR&mw7#`Aq6!IsbIk9@w=c z0ZsfH6G4h~3$5jowZ7ig=0A=$H7;^-Rb^yPYYz~!1Np^sLT3p9F`<%Wc%?bTzc(Jl z`(M+J$eR}BS;PHVQE`n`4ob!dHkvy-hI`*W1BJe zqvBIMfr8C~KwS=*XP990Mw%c%yehn<-HWU9Q2U;j3mSlF{KubxG_9xDW3I^JY6HI} zxY*=4l7)BPW}QD!+_|k@E^p0IE(CQ>@OeiJ@_WndF>HKy%)82!q+~;(&R<2h>16P# ziA#5cyJQLiB>K`|%5NYwmo#32Pak4X%}J1ur+5TMl`K$8&jE!EP-rm^h)7L}?S*Nx z2ZRQ=k{2O53~PM(@se3Qg?F9IhivTuklQ}5uK$6Z>|#4aIK7vV_ze<5e#uL)NOt~y zKI{IXKqgrnR+E7E@Gh}Ve6k>fS5w#6r1&pj2#|7;Sd=aTtTA`4-;x4O=h9_DnrGnW zMuzF=n4o#SH4bUE!^M!!D9V_%7B{aj(1TpnoCPP~eF9OrYw{P8C~`jc zAxC>p6>k&dyNJIz!wdO{XQ64iOxNLFR7eZN3H*XS26R}K_0fa6n!)%(FWOzlHF?0u zls>Ye*2;Jg>KPw-^H!sR!6j+mDvAZAxjHxt>BOTW=0aS(f_LifOU3_I)l`h{y4$e7H8dpQ{G#>q zvginRbtyiXr4NG{TC?yOY=wp4`0_qb$J7xY0N-wR1C&DK8xa^%>&p_E)e$7ASL4+k zeG5EoyqqD-io4UHLbqwj{$55$0fQsTAUwXVzQ|Ft=_56u-;(XZJnD^q_ zv8tSdA+QX&Djqo=mmmW4ip1rC<4RhkVK~&GPYvOw=}2-d-(SVEkj0ztqaJbENX52u zA1%oCbQ=HFiz&{0Ei?Y@4^<;(5ZO)S&*7|TrN1+dH5s+T-uvJPTyY=pX%KklG(>xB zivZ%>3Y+RuhkiZC;j({QE3kyPWAMU%MPhOmcw~B51Ablmv*EYKkrbTRAn__f8L6az zO%gscPR0h8qR+f+OtUYQuv5k`0pWZ(KbFWUg%mDpMOpCV-|5U&ppweT@6Xw==Y=2G zJTE|n0)N~7g%T9H?YX8J$uYr@pKZHKa*;-6O97Y=z#sD?h23AYAWg`_x#ZjxCcQHY zuXNP6Hpr-@F&vApfVMvp7dg|<^LHN0FeWMddfk*_@+_fPb^4A=Smf#1xlCp=odW@n zyXT;dnme=Z^w%5pF&T^4X$8#$nA*AQuZH#53k!1?OA`C|11tlU*#Ee1G-=~4g{S#% z{#A1YBX<@)ag{;wv$Gmwb^9PeAPvlPLWwp?1ia#62g$esfomdWRk}r^n$>NOkPSjE z%kPJ~bo9Fzw@Fs4$oeidwA%CHnJqlSn_5OjVb!?0j8HQVarD}9UlYSi+f|ZXqP8}8 z?*6#~PcrKIe*Qf=CS=Nyg>xRosH&9jlcO~5O{rhSnAV=r{NNVUQIXM#Wr^JMb2A;H zBXFkNx(wmyk?x{vtM zo*5HmclHc<-Dl7#k;uTd+x)j~Je=259~o|QU+Y{ao&54RcLn(y=)#2Mq_$!#%{L^% z7=t1v64nwKq%OOKi}Mj}=d&yQ2b#$QSk~K>K=DjS`I%#zv0_~4L2qhmD&O>*5S_q@w$vz& z9?Q}mXfG<)_TGKWS6>Kh*0?dWhl8H4{Wp0V&(Jz5*n+N1E~04>+|A;~#KeJ(ETcDg z_W(m_qpsTynUv z)Q(XD*@u-$VDr0x7v(ux!H~*DYE#-akc85^!KFj)ldbyl#nE6I?T>QQrLiBpu@VbG>uiuvw(!Qa5=jKHff>tk{dCMt5v`Kz#~tn_>5mh!+m3~<&L`I zljo^xZZN%~v6`O=4?~YMs%u*h(FCWE!!Td*MgE&Y`@kBq65*)tj@G-UO=VNNr*Y$> zAI8vUWIK5#e1@)8M)qhWA`ssC?*uPa)me6Fmua)OYWEF3P7UBQCT;}p_79DMl&y<~ z11?tX0e$}U@s7&RsaVaXg_`n}FuLjFt`^G*$n|KGNq z#R9vnZe-%si|$?jyfZsedT#c<-~Y4y9s7jTltlZd6Kx+K&$Q)H^jA`dW;AiaON##e z(KPyzHhv5vIa4sYO&bmqpBoyQw{N1!M2$-t^Co+pos{C(`18>Rp*vg(o)Ss4W6BKM z&g-_e_HbP3+<=0_5qgLs;AcesmALtIy_bgv*0WfQScz#+wX$@*p){K&$xmaPn2+Q3 z#%HywLoLex*yhd2|=oq#TcW1kiBHE#_kji zlKP#?^$^~;3)s>p;afHvGBRwA)Bt}0zxu|6;eP#aul-$R3PovQ!A&T@e{379Ktyf_ zJOz>DJJ3@SII_PGK)oPkk>JddM#<$nm+v;qV3z&zDcy~c!WMG`q9E-`#bgUql@%&=7kV<$ZTdt+ak z*Z;HY(sYh2iD2^XLUs#E3PefLV~w-}EtAHOsOX|3(_#rXA?G0&e9Nj_z_WmV1lCbo zRl{IWu%^iZ+lSsijNJx(ASu5WbNBEaDHG0FU~%ut8WzyL@pnT9CLlYxVlj{$EnA&D ziv$+~Ci$&*m&dzauRV*S$p3N$1jUgQzc89sT`-U%=P$uubg+*-tUzW|OF@GGDEl=t zqF=t&l9`^proU`UTxfL95!}3FCLP6TH71hRM`8;~%a=NpGeDBvL8}g$9%2aStcn{{Qh zHTMh>;7~-|mdmr&Z1>KuEgtdLdJ}|xQt&cP+9xGO_+F|17BpILta>9ynom;Bsx|Zr zWm6My>Ff&pp4ri)#Uf}G^0x`Z52gXQt)Fyu7MjD%2|qpJ@t405k{w-hBvQ%sT$r$7 zU2%1_9tnu>eK%-4+WK5_f9%K5R3B?$0B3Qf7#>}sR`sZ_u4SYhpVd!fRQPn2d+UT> zy$R+~BuD1rhi%BfI)ncM3+A^|%8>FNiKSuRpVT5RXDP6?SFf*=nGPo4MORx|kzvO= zL8CrZ+e!1Na5pu}EkU&CdunBam64Xoo-Vu1vCU{J>i zKJ%_IRGP6h?cn%%I%m-tk5v(tC}aIQf5riSgNS^`N&E>Y-xb*<5b4)=D)%;YOE6IH zpICYas%Pw15;(THyFTcVG%(g^~*X zHtc@WmU$n}?gsp4cRTEi=1fS`XL|j-;Q!*{rKK~&!-Yjryu7>@XC?jz&FyW$rj4h{ zL<>7?3yI440beF)M1>WBJ z(k+@_E#Jb#<~+V%-<-A8-frAt0;?eV4O1-AZi#cgT?c!IS#s0b(esuX%uO?9K9>mp z%dazg4Y07?|AJ>yWwHl$Nar@UKJ|>7A-|Wni0-@LmnI<11b#`>+FP$!!qs@774eG1 zar&BRx=~DRxc;oJdJdaT7k=)y55WU7|K`TS7VuhHK;tfflOLL>yY;jken%BGX}yNC z6YphzkvBcej1bHtv-NEb5Yl;!<#VF~WDX|Yyz@aLWQj$O&)+xSty8-%*{Z7TqwAN7|hS!j~p$<2){6Dg^2PPB*V zIGJ=&_qSKLu+(u>XDf#CwPsYWURyPWT!;++*@A^1? zh$uZGI-|md);(6qJ`s0(MVtG1F!h2Rw($A5D#wR|4saa&=6cre+RavrhlypoV!qU!TqqL>5unP9_5;*uf*^La z6|KvQotox(`}&RrEQ{0@)TlbY_@T1OciGy0dWbmXmWmD{CY|xuo%=>7@}UhT2j{3VfExAGu3DFLvU*r6rYHIH29KgF)Y}X zB%h_gq~>l+Ur?Rz{fqVH?;*9gcx~?1-P_l4c$xau7d;`{(9i<9>4M7U*C@g@+=aXF z$EUv=nTQaT2iJJGJ~(mj{W!JAGsbP3{N1c+n(4d9Cprs%SJ+~EGBrG*6g4AVhG=p8 z94wRvO2K&n(%0iAfJox(cbfx)y0R{i9(9xupw`FVgiNueYwtf*(1Je@=?ki&r>jofyQ zJE6qzkTT6DJvyj2`MU&vo@I(%Bn4~ts?|ILB#-g-wP;tOxE?A|M0Y1qrs%E6NsiiE z_7h~ie;Vrw@xuS|P)GEzM=ux+3VF#$%XCVN)Wf&iVmORDQ`+l10L(o zQO5MkE9QD065hHjkh9UEdVgpoW(%o(J2lpi?11| z^-!Nebw~-tK|lohIBSz6ufmq=c$Tt0>;&BpADS2NPVGxx_o?Ryv9oHX3o}ylzbin$ zQc1bk1KhWDn%H@(K0XQib+xP!cW{#_GLG2K!9oJw7t@!ZCoehXrU-fL%?e~UcrM{YE*pd?Y9G6laLrHo|nW&NaAxML0{VH${~qHp09hEj`MeJTWrz)Gi>(rbGkF zvI_g*wNkWWv?C2R@CH$l%GMPl%E>R7#^W)%dyJ;v_l{|ii-pvAqh4!w4s*sob^7}K zSm+8mJ%6-9{9c{T4b`AK)-nGwxmC7#u=v8TCi<`hRE9Gp`~B?oP<2 zr^kC#26xEjnlIF!d2$>cr*+L8)!Rl=`z-ZD;$7f+0~xBPad&5H=CpSMF&w@GAP zyFu2xt=KX>Q5t;YJpIeBaMhj5ez@05*DO7kLE$+CgoGc(TK9HrKD*wn8oV++yu55wf^*Y^1g$$J-!^W_mYxz6SJa%b-v-Kj!z>& zbHts+&0m1Ax$(*WTfkGmLJT<~Y_@4n`h=Pya^(^Fl{}<}bubR~wDO}PLC9Cxo1~#O zsoH;&)uEw}jm?ZI3c790XY!K*&fA+XIA`}3yvvJ^u--W!pnp7(*3r?nU61DC&sCwL zxsC++8Nr%d7y(Qb2(o8Ptu1Usg2I%P_Hc#bw~lpl7;9{=xl=9npl!mbekmIBi)3)> zE99UeFT?Nmej|vo<7V~Zso+PjlCYHT?tWsOb>PEI<$qy%i6Rh zFa36d&*m#nHU?(GoTY8M7JPgCq-Go(Y*2+&)Fru!_J0TOq%s4jOyF+{cDpRl6FBVU zKR+5tWFb%531Ft(U7abL{Iy$r8!&2MTo+lQR@9G^`D-Pz7|L%jSc6PvkGCC4bm6C> zB?~^DsC>rz%eHo;pBFD^q##Phb5EI;$58$6J;Uji9N$Jd!WrEUQbSaStO?`kbCoNi z96Y{l$$XUoXRiXG>CSdqfx*mh{?k3S@R7W^jvrWvp^zhq%S4LTfzOixOV{)kTTEh0 zSISw3ue%w$y`#oqN6zB|0@a_b`3bJ-=E9pC z`vxAti+j1Zpb?~J|Jm(bFUOlpGFI%FU}LD>TxXo5M;>?|Z3JF*1$rpb-oKN9xU}8b z7vJGu1VsUwCPCJ|1Myg*elhV$n2f2TUQr)i%>7JapuMrJybK$Dy>!DjV?c74UX%w) zS#u{xszs7X{@oxpLVp7Tk-E?O34QXCGCb-DH}MZ2qO9a={LeDR;>_K*Aa*2C+RuLT z$>_fO3(lSujwpyHcfa7$1CRxB!EFVs_w@B9%Ug{iC(e6LqIzRAXhoRnD^(;D^c!W0 zPzak6r=N@&EGoTn~01qnE*bg2;6%cEBBYg(w-AB%~BL$5-(`nJ1qH zhG?*#i+)Iy7ipEQ_TP@nVDiENl)|PqYD7OXa59srg?YQ?<{e+GJ>r5 zCBrsbV9hg{3!kx__vALw+zz&-NE*;r12EJT=?0jc3&&6ve$Ty1!Xa}T51d7xX{e|Y zX+bBGD-gNKL(S_Y6(*I@{G~Iw-#z1l7%Y{~i2g+0{z#&ayHD>ttw3i!t`IDtB}J#I zFFR@=cmw@3HuWJ|ZL)3K3rBRR716KGDivXVzAdDO@(ULgoy_$kX^j?nMg#RWwmYdT zC7`==NaaI?R_$cw7jwZm6a|GdvV>;T7VjDYyWeGx6&>Abx zO_2`5+Sz(340l$#>uu%>5?d(5zt#Yne~s`s(K4KNGo9OM+;xIo)lGWPIrnKo|CwJ^ zA&4R8n$(+-C-Af*eEbuE=0(P6!9)Nwneeo3ukHZ^k*bl=^m>Ry)ywpr@c zPpoi*)*u8KVaMhlH29fk_3aH^(_@)zNf8R^3@*J`-+GUd?^DCon6W$h*wkbe^kFqL zNIG0|4;Dz!alYo2sY>#;pKp}&-aiDl(&HcG7Qrb-N4 zJh21#a;aXwJs_yvpkG~b@{Ekx+{L1N6=gJ}rU$VmE|C%h^VY3FF)&MQKn^gXXz4rO z65hHt%sY{gNlj)1yfL6SnyEl0P4tE`GUHm}r`I=#Ia(xBa>^YSi@xa~X%~#PIu53)9=J8#=S|>4#dnbbOkz#Upn&~Ze zwVppI+B+9T$u4p|=rLSD#nx~w#ot*e#q@1318KZberA}q<!T39}X8}WMn)!*d9Ydheg?kR$fK z>fst#{?7y-akPW8p4SFoy{wW=yIYm%7D<6CuZW?xtJvKt4Y`^(6*l%eWX5J@o{Ff? zN3Ok*(ex^P&{yHAs{iHE{Kd5`T038MygQGEWmmM)UXI-TBR6nu1doQ{Q+94J&&hc0 zl!(n_M>AIiUa!f`;4JCO0*n8V-NN>p`l*2o|Lwc}nC`IM!z{+#uh`r78qywBGDm;E z|6euBN%WkhbMtxquAu);{KjtIh5NXSxJ64gOrF5S%9&^}^Oz>cOb+jyzji47)L&Wk zd7%EA9g+v`3al--g5nI?FDz!XC_cj3<;#wXdB0Y&?Ag^LHpX<&^ott7GGA^V))h=B zCehJgLJ0{l6Tjx)$n;BjfMj1`05ZAB-h@R}1pf9FcfO2{&_snK?z7)_!4fbsvecX{ zz~^QCuw+dx+X{@E`{lEfpE{~T{>{&~ZmJ+dK!li;i5MY%{$&5 za!i^5E)&DUg!Z^>-1NP8MvF(NoL(qW@QSuwHC^9ww}|yb^tYqB0ax7k@kNu+80&P~ zOxwDF;vVksx-#V8e#}CHmRr>jYoi@&$P4UtRgO^Hq3g^zi`a?p+(K4TydJUR_5J23 z{?}{d$tbq`g)xOnMl;L8Np_uO;Jmonv6+zCGiE@A3wDN%yz@>{U zY~-4EG^uc4FQP@Tt=5+x8KJY~VOWBfIJR^MTl3on@wX&B_eKi=3>^f;8DOoy02cTw zi24e=Jh7X2MvSJe0I8*iU+?|?YwbI-%# zeGXbi(H{qL4gU}|Rolp?dn6Xr77TWloCY9$MP&T;AC7T-Ehu==c+5vr47uD4_JSf& zZ=f%n?7F6e&v`TF`7A~O0d~h#?#ao?%+88c+3J>>eP0Q@8~k$u9}?94{DNg-FI0GJ zcFQ)q%9dqQeU{*`$nY@v{R8;TI!N<5{pifh%-F6*Jq@UwtFG?k1K2y{+EVRJE$+Kw zG?CW~Agm@nq}xXJy%o>k?XNFPU5IVCEi^CYhY*d)u_^YPRE*acSqjBHfRWKyyUG46 zw(Lx)e5D~}Lu)~6$vaqegLHVpgaXy3(d~HCQ4*l`K2A61983kziOR_4yH!VRA73Ot zFr7%z3ACj}iyPz#O*uF7SL>c3LzqTa8n>T69tsG*DY(AJe%({lpm^PfT<@7ee%^%{Db!X(Z3% z(cXtEeYDU#u2E<_w~ZP33=HjN!Q1ST4)xO?)qs!mqTP_^nlEuUww>xyX`N?lxR6b~ z$iq)#W7kNPqi9b4^_vIT(SQS4e}@CTh&;MCsJOdamY((UNA`yP!c$=&4X9CN*r6;; zs`wOSdM1W0`^H*_Il*P?g5SR8)Ij_B*fBrtn#mHHx<@|)T!0D+NlUnq(*T+#$h8j?*~ftZ+T6nr-l8d%(*Vyl9Xb7IGp zqZxNm;*RKCVbb^Pwpsn36b6DGk}it&lyU-<5Qw72F}2BFv|o^mzE47VU6CU>qR2FN zIfuLDV@uBdUY;6=lmaWMl>R+`-cQaWs;tZXPDCHwKl61mOSwyC?i=2LEWLbqvDVs3 z%0Yu!#>`68usrZ0&)w*hfejjcloyV?_%6MhYjS;!&DV2@_`4HQkr@hscW0IA7fd(#;V+LU6hJP< zYan3#N#5?7zIlb%>D*yS-9n}L?d62m?Gj{HzwMI3|8k3CcQRXPH@fZmb{aQQ+bbR1 zX76fX&X*W>3zVFzl%i)X%GwS;wcK2>V>V^#rWpCa+-OrK@dC*n^6b95x6)H0cM;}wU4pRWRoe6OFPa}3oT@zmeXYhIniG*?eO z7y$SPb-Qr4{$&RO4qNRg_vt)AmHF_4uJx7tT1sLc8^0dEk72u`pU;X7N~R$Pt#+)< zH-(<2;%jf?3#*z13~SM7vYCI9M3jrPrT91yjNsMAgCH%!(T&2Jc?rL>z^QdTz=oDq z>y~?Rcsr$|(bv#45VmJys@B~VJJh3_8Z0VDZXXJyTBxTzDY?e!aT2HPlG%^+&FOYq zOY=NlE!NHO)L<=8l%1LVeE92)lD#Qos~(ZCwDM~Ib_{w2P{mx>ojk+Rq4~*un`RQ{ zu$(n-AE*I;m#bYF#J-DRUu0aQHP>#KJydh&S@!UEbYA$zX7e7h>VAT4$0Xca(4WtF zJYB(I`s!43HP#!!`22eUSPZ6XCr{V*BmdE#oU1gYj=Y_bYGl4D(|b7&>`j7yK1; z_sL22jd#p1v*W9s`8Eb>R1TLpJd*vZz_*NxeVV+_yoTdzvK(c9ys&$9Vp(!g`5-rz z!2O+8i+c@s!%{VumK7Tnl!Shf{Gjw)J`a0o^L!sXq_*+Vv8dwx*l=7)S-+IY_#6Tk z16X7>`%U}Pz4V!wjNmS@4nPcmm}%7^fYs;3OAsl(G~T5P-TMd4eGopj-G@W?{I}NJ zBQJdxZ_-Khk{D{ImUDt>Q0z$gQ4%5|ll9Etfgl?u(Uc5N)I%s~h}`#TOSUk{L%`zY zzb~P#ZTnlJG$_*NWPYh}Wlh;?0SsCD3DseSM?S z1}-*A$RYmH!#lA0T~u_Z5ur`T1|^=*Y26(_vO4!>(;ew>dTrw{^yNZO!S)~ME>g0e z#1Zmdo|^bmsMopmclQ_lci0GD5&XTg7%VCrjf&6b1-%nkN5!1VAZZk%C={6y z*;&}hiSi-4;3{8PUoYHqD3N;qyC!@l5;zt~U@oTa+c^6q@m1BT2cy^_+|m z{!({GpUgoTk%53?UY#*bM_9`e$LO8n4g*R2+}b}tW>NjtEcFhYg&ww;Cc((MU)7#Y z9_F@fB+O}f*XSM{sX6}NM>$(ecG2hMrJxDiZ(y`_NPnCeMu-~I^gp6L^Np{{syI5D zxCC0KoI=X8L$-_iA`A>$qqu0x2cP56`b4&c5|~Ou|6>`Qdv&6TE&LI8ust73MXGDP zYA2XwjYedy(w_nPC_D0;e_dZ&%O~=$QSzubIqFd^}tCu7MuyF(Z$97Z}cm=r~rMW)_00q_x?j1=V zW13F%MsHr+9v&rk%bP15-7r|lWlCHCds>&tTiuI{)BJz$>4+N4^`=+<_N2G9$>t{S>1k!94aitbVq~p;yXX9;;6d5Q8P^p9 zds|;eKL0qp?a_OIv*U|93jI++$A0@dDiZpIsSF41fBjW%*6k2u-=ghxu>u)d`5uo= z;(O;A52B$XoOj#?%vv)yhMGI^{yYbuS3#bC{9w$$yzqQq$9QLR*oM;e*MQWU%ahO2 zl6bLTWvUNJG2O*?(_z&?tso0Ln|mw_uZAWNr%YxMQ0Mdv>EI8Qi)jiW#fIr54NGQW z6FUryzgoeGLbs}tc)~(u5fuK}MLTvfhdd=)5??YdBsITF7a@NKp_Q=yYby^N>aeNP z-DjV_tPftxJF;sa+=pspS){BCXb9XeS46OLh}&X+wJ4*T#r z`(OEOF-rGfbv36U7=E#qxRw>h^6ent!2bw>*(j$q^J%}&uSpeQZ~X4_;{=0ufh;Q~ zW=2L|WSZ`&?%L5nE=>EWsBxUF(0B4yR!`PeqU8hyZ0+rp7FHyO?L2dh3Y7U06Q{O( z+xPejEs?54J3EyH2LZ-AV8|^!e!ZOwt4iQZemuc;;9KxH_#GZb7|>jJpsYGMK2UmJ z#nN}BL~ITBHc0SZ2$%p+6AN&Ko37h)=i`x#8>my`5#+en{6=U0cFyq_`P zonNOq*O-Z-Vha#JYD7w2U2h25r;5or3EJj|i>!|8>aJHACNH-2EcluZM0}4wTkz3( zGMFCor-AvXmP*+!@h&6cP{sZ$r8}~ju3iMGcEht-I1od%#jdZ+TV)j6GiT4%$|D+ z1o^|uV>;k*jn>tMZFtQbx+7SHeTbhNkF@WYNzcrsZK3lTV`@M7mPXBA=MsD*pGvW( z>f&rMx%(lxpoZYkAWd;cYV_)o==jBq2U|&s^H~rEmen9hg-6O$%hYf0$Qr-Y<7)f7 zeCe*2V)9pP$L0OjOKko{eYvTsBrA;?%$*vA5Y6**rUBBkg`PV`B{&ZZy-(Dic7to*b9lj_$eW8&k$EkMSlT;Yi8p;S^Pr9 z7K0DqYYrH-Sy6Tx(GF!jnu}`Hx04F8K+Mu6ju8KKkQ*#yUNb=e2{xM ziO$jzlsnt>Yb}OVF)um!4j3S5Q0#Ty0(~9_u_NuOWvW>-vllA7@WcUI0e)yC;erjr zrF_$IZ`Cv(gq2}8?`=X|`18!DC9YDA)M@^`@F)s9gY}P8Ho>lAN0{*muR1%$K&RM29sVtn%egZVi&HX-hAShzFH*79K6h4TyAq2wLl1@IP|qa@iFEVzO{ zdCUo>N7$?FJdxQ0>V@hW8qILHEwBjhw1Y)#ZL+M;LN%EUv3`7xbp(wyNA4RFuQjw? z<3J+WVdbTVldDvu-(%Q|0HAL7sYOmzp1QqJo%1F(3Ue=4Iqr;3_5M6(I9ysdAtI4g z0pJO?c$OwZz$qn&c!R?!XC0&sg#LW$uq9qjG3j4B|9WjWQly+Ovp8%38H4oC2m3_0 zO?a9vT_#=tI{32L1K&$pgPh`2WlkHKn=P=dy8WtU$rGL#u_rU&-j(|s$VnH9Quq3X zciXXqCqsO^BbcCC>Rj1O0YEO*datcUd4@sS0G+Yj+s&INm#AR z%hgIwCLw)t9e2B6r{XCvp{L!P)0O`;g1M|e2pv`dll#XJIKJ$bTuC2WW065-*da-? zS|^gJH|#lHs9!wS7u!!Z^kZC2j`{VDh0^8o+mZmgd{kv8U6_bkZ?dhw?ip2pm7@@i zy$n=#y%Dw@&iPsrI@J(k9i4*JGtM}TmB3FRxO(AR&Q9y8P8U{M8vPSNI6C^~-v9mjBm^^;< z=hrt659SPs>!4b#!R`d@tnBOcZR3giU;N{i+NFDrR05K7ZDkmDQu25rjmDvdCaG0j zn&dC0#^P}KXuQ(o#450gG`FsK5MivhNH`W-f94quC(Yfc=1H zD%eyQh)yF&Ba=bun~tO%6>E%Vg=$CF(oT}wP@T1@$&{(}Ywpy!o6r1}+#t;%OB0UJ zW?eIs#oB}=z}_0ke)$N%;ZYf~u5WrDkZ;!811$c30=+igxR0}}OUTGsUZh<5P88>e zv^wpXq_I@(!~_&sLk@A2;4eDWaFd%6*>Q5u8N@$7I@NJr`?MCDFDaaZ+sU%!-UOMK zQBS2>FMC*(4x~Q^xURIsECgK0Otx7g7$X90Iu+&!ZUlYBtG$;cZyi#)lf<(1%>%}6 zE*_T-;zV{*tZ!M=_kVIbVby&9$egO4Xz34;Wu6)W&Omyqs?}u{gLA9%@bUGWpVxPD zf;Wyb?%keh+};lqFo%F2<(N(1o7n%K;@?OU-X91Y{_}nA^J6a&)mb301#^QvP|kgm zaARjaJy$wv=lMO@Q9jqf(o%N;-T19PCs(ttH#9tP@B86ZX!wU=*6o4(3WsF0rM-Jc zdw`wP#$dG0?MoVHAR!*%7o5Faijdfk8l~s0Xy$XF=(`s=fuo>aex1cB_VKy4#$Rm> z8NOTe?Rj7iKLX=?9DI8vx3+G6{c68?&EM@{Pwp#i`b}i>@h6z?ziaG%iKw?pXkpwxYc{R41U-5Z-BO`!Le-VdRPrA5RLa?$(6Y<~?rAS(U&pJ!_ z6U@H#Ovf5JwRtjbjz4E*jtb$G&_r@@-&!S%Rn{w6z3;wI&FT7Wt3 z?9oLBqGc&kcIsXtCxUmV|tlK)lLS* z$35=-y{-!h&prB#q*`uw`|ZH?*~@d626k~xY`HnhAa(~ep)@HUBlIfI_T|Md*B~wR zXS+xOOS(@g%-N^d0Q7+>yz5SzTqy6A3@6jT!tk#nS?RPJft6VZusXl-c|DSQFia75 zgJRN?SiRoqlDj#gE@%B{Y=OAHrnKNPyL?q2EF^k*Qc!g8EtT_4$={2)e&}AoW0I=a z5BAE4T?o024hgvlFi+=kDl7!scPG=?s>{*sW+Z|*0Gwb>d~vY!yBPDqb~Thv5wi}C zDdqw*7NbM5Ug{%<8X4v}$dKOSJWk`iLZG5qLnl zDwIhQ148E%VhT8e`Ou@edi~0G4K#Y6@(kL~7lIx|C}pROOKwT2D3kvcvT&FiTeGOB zefr!m8ATGXaqQ*T!V&-LTf*0W;u}tP&j|?l>@%X+_pGwe-u+KMgE)tk z7AsGG<;1y>h?=8<)WAB``(BHD_29pde7s%##M1VsM(GLmY?-wSxnLRv3H7q+iK(qS z!F;KnQ1$OCwFyNl&jXQiq_3y(JHf{zt@g(B6J|v=0l9meg&=gyyn+Fe8BhRTcRW{ z#irz_ce1a*Y@c?FP;|%pq~Ez=ooByT_CE%tA^DjfSrLDnb|MYsM%`aeahXdHN+Sr%=I3~CcLz5o1!4}-!2c{r?Gmx;y{~e-6!KPnE^ElOP z=n{l468TePQ)A-smn2yS{WBt4Ix);A?J;~59^w1wguV3YV(>t4WBN$$Y%`|jtvwZ; zr+!yd!>S2eMt=#KQEcW)Sf`x4CZNxgRk5j|8vvaC4xh%2dPGiyhp#_rjWZt}{LuW} z)C;pC?S>FGiyNfgbab`i*<@d=3XY(MpyX2TISQZUkAt|Y_KPkXVpaN;`GoUelL@}# zaLNhtxGV9*r_m?m@zR(5H|Dn4@QHEvD!X#N75A%2?E0JW`S}{e7i)6$x@~5xNQZ^>PaWs78!5)Iy2`w2hPPz3 zBN%|tErHP_&%K%kj!5=n#me`>;I66RT>Ke|`Av<3@}2RBtw~Dq(|q^N6cI&@ADay*FG`_r=9f4rzEcf=d4NDyDcdUg9KjssN z+8Y}8av~Z}YRV22^5NSI#N%WF&m8AiFpfNqQPs^`6|Q@A!RE=%82SuVZb|;Wf86|X za(;u#yO(rr{SR+Ga7F}XT!~KO;$BvGVxQ;_Q^jtpKW~!$B5V#nkviKrGDzqu@MSyEcMO&eF+at?U(4G#7;xNp3UUz@Vdh?hEO*1p+4 zxZ%42Zipjk`EPndM29i;vi}X+pC4n;j2Z0pez%E%7m1T6QWd|WDu0t5PS_u`+@`l` z@Y2Ii|8-^jou4NNsGI(3b&pn*`swOPrGOa6l!=+wGbhgg1>joqxBP{3eFYy1nSTqy zn1XHzh88x7uV_t_M87m~&Y78;1zd~x-u#j40aGmSQ^;Y;XK#nD-F8aazTKWr+(ut* zce3uF57s&vZ*=!tS7?u$W)Kf3uGR@Ju7kyTwJByFM9cZbUL6%cRw<(ApE|dkhBTiZ z$GTZrO#`S4xO{?U9$%u86O0TGf0sBltPhWfhZG)gufLA*kasq$zWOcL%H0?5kMyP8 zMVW^`qey3jy$>92F!~Ev=H#(isHqkv1^lx2MCCX^+Z$@4ukJzk5mUbJBgFw1R-WIS zBNhs!P-F_9E>G`={p77b1ioi2-tV=}#-+++_&Mf%Reuhoe_cEMcB*$-+1gsLP~){W z{HK=?_|bY{2wY2ywFTQDr3cj`dmDr~-q*LV&opgV<}M^s&+#|;`&UXD#Cl$<$K@ayWf|xbS@QB&S03r+0QvIN>ghpXOAB)IK@rt)=Ro(Va zpW2Qcf52nqlLNJBdgFN=f6=h#rnYC#WGD~ShU1mG_q<-sdfnsVr19N&!LP=`Njr!c z5H=#)_~ujorpB#r>_fc!=e2` zND+$Lc0y42i(d-NY$do$ezaR4c^h^=JmZoGCI)4{t|>GX_2fb-W>Nyw7F7PV7;&Ny zFLBGZgpX1Jlz({c;|D#}GQg+o`)TzkRd1vc6qF)K(rn((aNhqC~YbO*e>E*4d!iPe9fnD#MXuGS^>gG@I}I z6_OvOpv6ZQrGrtHUs%Q_4{BNpGEA{^bs1|nCFn^Sp*6E)3#l>xcOua}%+hut@RyO&IV-vr9n~B`J#B zG|yqhK&t3(iB3O^z6CPW_k%P810Zo*&k$z#Ffzf%%!4D4bJHta3=HFFX?o4c7AJWql&LIJLf{=i}NQ2>+`&0%9!Z;HEH+Z zSh@~!!QWmrVg93gGQBRHRt#@l97!?Aty)U~^^WP8nU?Aaac8ao#EuE^qkwxjJ?tl^ z0GITzFy@9uK9Su)8aa6oVj2`8hsCYPq4KO)^z&S9%q^9LG&BW6h_=l6PQx?{bF++9 z*XVnPuR561i1Y-mo%H9W2-H9&N0^buxDjQ8gftj(dSq{Y)O z%JH$|Tq`mYvL`|>hR(ikAcqxfJ=Hs^?>$%)?#C{hE|}}->M%d=EI z%|>~7DYu!)1-T0p(_P7c?!|a#OCb4A)DRn+!C3KQ<1|GP7@)ahbe~t2W zrj=o+iNv?zvlWCCxgXMvYdx+;K~j}f73jr3FR<_bMdiOL0`+e%|M^6P@oPL&5uC&y zn}Ca4EG?TaRwAb)j?|JpLP-svQpfe&q{a6GhRVr*+YlNi?yl;r{=F&)^^E% zIpud$xO<*KJTC8%>-fL(%l2;!atmTmsQE{ zPu-d2&QrToQ=_ai9t1Qc(zrv@$=Vyhz?tr$x&D=2Fb3ymeCVd}jZB~Smeo?-mg$vVYCYKlFqboTE6f&S-YLphGV6D&mt9Ea15A`h$KJDNBpAle z?CC>Va?mQyMg|=MS93jaTD(S}^1)8e(J>R$G{Md&cOm(KJTrVG$Hp|B9LvvPL&f+h zn-P>Z)M)_zdo(iz&)B~ez@SQjymgD$*VJJ}`Vl`h64KSnVGJTm^pq$XDPSqmYVVQ$ z1j<%egPe^DPJ;a8^>ra#r#?W916+G3gRzONbbZnr|7l)C-Qi{8 zaM)9Xu=+j=VH;SPh7~(%{+T_CPG6-Ap^*4+C-#A`t=A(D3eo1+>d1UOVxnW$%_`R% z1Ee@fPBkDlPE6Du8O{ZH?s0MzPxO0C4~EEVXXk?Q%k~=zT;Q@XJ{_$oCrL5itEn^D zaSs=FuLBVM3@Fv;koV1bDwMB%<=Q*Z%3q0&c4yI#`BeY7S~qpzX!*^9z%px#t5xal zWI+JwovDfq`^P|7TK`H_1y_?>gV1D~=4yg|Vo(;k$6r*sRqagM?joj{t$+)V=GUHS zxg>Gj{^T{?=pKys!&fOhDH>edTwLiQ059&QQ5#OnP++YCu8|@<%|3|5n9$ghZnH&4 zLYVaBD3GS19>1*chg!_FYP!l{8m?y1Cz{D1-}%0iIBTBr)Q^L1VO_8CGZ9#}_t^`j zo1z5)I_yOXM*g`p+WQV8KI-4X(2`Y=V$wiglj!JRa$rH}aJ3!tFiceUB%U)BpA5_K zA`M)dQ#Qa^LpE)EtCS#JPXx8si02+F$-x>OVwDv&)_5nRci9Hu3HZec z*fal7l*SzBE6|#p!k;UsHB0Q*-eQ-_`gkST)7D9$tuLn+^bctJ2_m1FurS@+ux>vq z#1vP`H#$__M6gVi)X80d-_{&^;iaQLZ#o9mCqG;MCP_#WK5TGcHv+`j8_ma8@|qI6 zq88_Te(B5cT9rKK4MO#W($3{0o)uLvbB72q1*jSSuuE)7c#s!#Y;2TcXi~0C=n-ly z)+WzJ5obDnvQaX9|FWX{kiDv%V8ISFef?NUPVZWlD#BN^J1c^f%^>wo}e#UPktCv(%6kk#bqPEw~9-Zipn9LX$%No?!~|e ziNnG{$LYTCntXu{aD4Or*5XGrPyZf7$&S73UV+1drNyqmqu--CHCZKI5CL1So4YU9 zddyd?y7UEjaoQh2e({+Uvvb5NEsfT+5zeg#Zwmu+%}k|eDYZRVZrKj1KyJJ<6xGqA zAfs$Wz7BqeWwj|lR_9sNCOyiG?l9<#Ie+Fy<0^dE?gNovtU#NN?1d=GhwtkR9E%mj z`I@JBi2mWr5}{519`H^Qq54Fxt)s_g@`p>OC$xg9|7Of-hjt$9lGe@m6aldNLz|ipCLXH0PhFwxT)U?k3}DT~G{75MFvW zmhuGdo9qn_oUk^99Zj1Q6lNkT=X#h9K4VpS?nG0WdF?q zec!1SZp`40ZQklVL!0v6-1BY^xiT-a`;si-e(c}0?pZO1fA`jZ&1!b0uELq>(znx^ zn`e6AjiwrAbxCTc_(0YBmI9Bm)Kely%=}DJ-_KsDp83c+3mtGu2l3wNRF#`+;gX9XS$sKs-C5~!3?a-Do!#Bv>!O@y*@?OglmEF z6IdHJ;C)WMDpNe(CZoTGZmjwteMgyS*ygi#et^}5m^7PJZwUftG)L4}92#=PE@f$` zqQZmEr>Nof;iPw=&(hSTykpJA^W!$ZQ!@zJ#cbSEOxncu)^0t?;r&Og@hoQ?J$E?o z(O50NSx=A?7z^wM%Dyc_fziOE%YQ%ki9rd>%auR*s=RIN?_fGD-DNh5r>drg% zZC5QG6h1#v+`Fwyo-N(w!}`midh(tAXjf7~3#aPbDHGl4oz^O*`7F!p1ze@x10Zb{7&yZvJeAt~m~imYtE2Y2s_@ASAO8h0p^&HN`N~rVX%RK^ zj3Th_SWqubk&rZ#AJ>Kt6N8b+dukN@wEXfTLKvwAX0lMci0kYnYq^7*Mp*+=c=tqz zE>`$q=c@DJOjWae# z)4QB=#`VPti6(stBpyp07E(6*O26aLfcF> zj(LeIM~=79bY@VUt299-85gG000x;5?ZR6W zMbKsP_uOd-QE%S;`SqFwev`s>$hAb$*_=@mWRd+FWFYd;01V07^&s9grwV({{w0#E0P~8C}34rq{*h00KdONm67R?Dc5Z`+>t4RW7*YJ z@ze=Jz9vGxr}vBuU$~diP$u>kCWhK(wI1=W`E+%R@5K*U3aVFHY(p_uJ!y*iia0v_ z>=y6$6Mmv7=)b#=G~9wi+Jxx>ZTZ8a@qf-0e(%jQ>u}oJ`Bt?X59|Tnbf4Cca$0dl zPb97jLfc#9B_=GFpX9V)D>E z!hEX}(kn=J$k-q-Olx9d)mEqAw|XD^(c5a^JZO18BSH`_xqH`{E6jFSp zwGGGT5an%J>}{@RcHcP`WNLWd*UD!_PV*WOZ%SVG%_;kwR!y=8WK;jHn@bGG5ztsx zr_&a`mdGn9sMHK#09wlEtOdca?7HHQ{APqw_mED5R$M@B=J?O^Oj2hf;Ojhg+!u5* zfqKyxE~e~i;W6>chG#mZ>4O)PY8jB8NF$^Y6FI2DTqFuT|C;>+3I#qLUSD$T@ohgN5fDij8EfB-jVs*C8y3^yC+2o}Uc(?N(rHyE zOz#`{)0CuyGAVsaUM(_%NS;y=tL=D@f4<(ZxVOTohT$TGyV7uI&cezuS$?aR`Qz8_ zd}?87B@#W;d?q6yw=G+kEsEk(nX67SO)~3pJ|eA$Wlm%8p*f$Q$d0w`uQQLlWBeIl zn7U{+0hEJ;oorwMb0VDHgdUR=x#8=MMYKN#5V*$Y^;`*o4^Ubf$G#Iu*@SP?L98z3 zRqqt=%Js8e4BJpkJ`~#3G(9nB>@+i0>m`2mSbJFb#=Td@!?EL@miy9-4awf5+LY^X zofEAtfp%r*$#usyMEv4U4bv28d(w`_7Yy#J+RCov_qpKQM<~)khJto?@cm-SzIod1 z#BdbrqqmIngE@1Hv8*;p=j~FEzX*)$+y_u@+OpU4uSeAESxsu@; zf^}r8M$WBU(%j_mpG_rFxww1l(pALGnUxk>Sp=hK7|O~7A4uyU;H@+glUh!4P8HTm zc*QBL=T(wwyHAZ~&5{JEe@SI?>>5d*SNbLPSX;TeYESwQ)v8GmD3)!HNSJzh^|52r ze-!ro9+Mo^PGpOp;r6V*$jcwwpOG z1TT8e7)D8(YRgM^&^(hk>^~{kXW#RW{g0gws0Hfi{|C|e+6Apo(Ju^UAxA{kRlne1 z6oi2knEv8~u9}Z^EvetpmBzMi+?!z zbm)ljKan{?Y^Sj}s(coX-~OQTqBLRIn@cqTHT!)6=3HbOT z{8Hg!#q7ci0-8L_OY77?@A-9Zh+pb%)|@g_Z&iwuNbv+ebo^Y{bM>qA!j<~VbIZ!k zsPOTJjedLYJQo7n=DR(nB5XI>x?Epdmr5$dID^)80a@UaS8@(8%(jhy&>-OBu)SLi zat|NdK|Yx%)D#8!%XZaP?r#w7++M__d<<7DYCl z7+4Q}->92h#Qi>!aN1k>Qe>Wdkk-6IdFx8}YIFO9;70G0FJa}~6xM5Pp)--#LQfMX z9qQoSN$JAQKf*iPTX*mF-H%$j{>+qX=e}AJi zeBxfA%wc?2cX!9xS#np8YUlXgj~t3_e0H~b0unp;E93!)jPiAv8l6{lYHZDYB3DFZ zl?Wvtmfv13w0i%yk3O(%Y%w29eJS*=TnJhwS;WOp!)QUd>#N96KrHeqWN>QzYi2=d zvR~syx5zSDr!p6FSvNMN1?wlWRUv6B@7Xn+RaF>QGknMUQyjm@w4m&iyK9!e5$A#v zS%=rY8J0hSv5A#%Y3RoEbnIKQMEeO|qP^RZwjaFBTG2jdqHJ3ZH?i)uFbYRhc?yw8 z8FT5AB0PYSmo)UCx5oPOIhaR(TO<}``Y?&*n$0N*+o=e`LIR=0of#Pz|J5S{=G(y^ zi5}(K(ovVGM9(xRb+b$rV>$In*gx0s9uGM=_<6iSTiXKJV}|7{E#d`e4qaqv=wy^> zd#CW~X?@3uH@ON63TT-f59WUz^XXWily&)Z{0YWjdfThHrgUWMEbZ1`d|4VQYb^w+ z9B*qGk-eX0F6ZS6(PpR&g}+fhzT)gJf#HQy0PNE@jPtw{@AYem6)9%D76BYxXY=R# ziQ0K@+14{{y~?P6a`#sRzboH<{fCQYiKEJ4Ma%L#I{-&|ZFNxE*fUL2lHxzIx4*ro zI0C&dsWu!z-=zJg#HH^7yaZ?guhMxb--8Ed%!RTb6q+Ad=ZZ_SR6$pM-bbc=3{R1= z+V~wPDEQjevuT=zOID|<-&q%HLp}HAi=R83neWAEnp$@vwOQ7Op=jmX4w#!?Fp!h| z<+Ov!sh9@Sq?r7VYZ3+T%DN(R=!EEK*^MwafXIcx5N6Hk1mP_Euw_p3>u|O&q^vfw zFhg-(igFl^Bf1p>lbN=5j3`fwvP95MlD`zOl5@zDzb6%j;Q>rq_VTAw6GfYkKyU{q zr;e(yqyUh+k9#T``QP&Dy>u4rhny)mubRRrT!i;kw?^udc!Z>AAxH@NVrbJ&_IP?i`zhB;5@;U;YJcG0r^-c*qk=+Njpyph;-C z48W{g!*=ymB8fs~AzK5asd_CJBe@(5xc58tF` zLv?a&ZI;O@pJC7asEIXUr)LZB!u2+Q+pN?2limL00BYGzf;QXtjuBpUN zJ3#E9n3s9cPXw9rhwQ-=nCH{0RW=m4LoSjo>+zwT6`NYakT0K;EjGJAEPgKDZ+-i7gRxoeB zVZ?68srd+b^JTD<{(uZP&2cU9(P9eWHX^VIS%b)HDf6#|8{)F^QQ!+;tE_w7V@;Tt zwa@gUV9vkfHu7@=c=Jh6W-Chw2o)nzVL?VsX zEY-B`BSD9)=#+09ls~?dut!KN9ggo+Jr+=FA06Q7vZ`$Q6q2<_l1?fIC6lHgrTF3I zW2;l6vF7(ce7T6gv1ArT{YoK&_ORSAT5oMbY_D$68?%5lm1LxK8}PIjag%Xxkdo31 zb?q6v#7r*T$FmqCdfm7Y*iU+^k||TGRQe0V&<3N%auc7Al0ya#aR*VdM(unn)xvxW z{UuE!El*#!X%O?tdaHK~2ZVo)tiAO3`EytoZ0DBFNpF#nSp3ep0leCOplxkBR-NvP zvMbB}N~T1Jw?zjiyQ^*xUv(CvbVl~l&7vwcl?oZI)CJk4$uCOD;R3oCiyGyFD%4ZP zoYOr3jm3_1E7+lkpVnzR!cM1+8i*8amWkOXg7pK&m8TN~dNcF6R@oLoWZl{1Bcm3+Wlscrvq3b_p>=YF!FLy!z zXu-$4R>r6=wfw)^ob~A{s8#$oB00CrQGC(@8*0K1wYtdld1J906i80L4b08d2 zl(NLa5CWt_p#(5he2(tDSNvn5Su-3`XQ&f)OqHnPS+-RY@04b2By!rDNNLF!9p%8oBGFXj#g z*vO&h^;-ku>%VvlwlZoVR^%2iTCoq8dy{d@qO&V$_#1SGcW_Swlf~CH-~A1X{IcxQ95L03r(EqFzi`+c*(74U|MO+{L`1cv22A~-GN*< zD)`k1^3A&iA^WNM5cn4z18s7G5#$(p39F1P-7L1>C2urC6Dpc@BWmdC!0pq_ zRRKQPQfeV7v0e|j_d80;>^uX;AlX9uB54%`S=M%Hh8#Fb=Z}<3&b0R1UAP?ZcV!C9 z)4#1!Me3%7COQJSv9Ywv%QlVv1IbdaI^j~&%ou5$#CT#PCDktwhlvVe#I*AyI+b(a zFhDT?6t|c~`x_hv(wF~y#inIkg5_+9K>M=KipHMJ+46I(B0H3wdK&lVv#|D{5Hsua z4GivehP|>*2JPT|EbhO`3bm zdYM&sS{FpjnHT0={E=4s4i}gx8rA;tH|Y#B!~6w0%`4KxD>URZ;D`}k#E)pB!Trj+ zE#n^sJ313RT5ycRkDa5zQZDst>3o#c+cJXYZ6I&BU(LI+b+zf|DZ;vg<0sFD@_E-- z#L*`|y6|C1gdf!_Lr*Lx5|FQS6j8{YUm^m%H@}!~U0%0+H*`{vsF+ot1qVhferld0>s%195?bpUesI z5|4(?K7hZvv$8$5ULJWlR&N#>AS82-NDlx_esDzE?d78G(&$W@zU zV*6T)ZvmCg%Ub^h)B)LA(}%h{pu&UwIx2)cd!ujggoRFClR)X~WusE3SPi8oUk+Ye z`&ZCE)zx51nt`z!JcYu`BDO|dEEE5geu09= zKK;jxr=HE-12NBZ#tDSOBCM z^7Hrh>r44dg@v`T!!*MR6HZm-_mbAKg_hk5oSf5gjw$G;!${Gf+?>5rtm`OVX12btw;LwLG~>J5oNzs0Be2`NkO_F)^WC%f8t|!QzB)0Kz)(`h>Qf$fwd$rq2iO=pz7DMad%g($JxfP-nAJo~ock9m|%dHiU%;X>1DkIm(+<=~P zmhCW*j9z(FO;J^uzaoeu;QegB#S`1YA)6P*Rh8Vcvi5HDFjt1Si{QT&3mgm=)vBk9 zOU~p#SgU9<|4Yji8FI!S)ZrSuFyq$#{%ad$LS(g>)gekZ3{_?hII{%?d#c_Y9e4(} zaxQxV4^M=`I}i*?jI3LoODrYMqd^G*JO?n{%J5(UTC(Y{T|H!mV!yWNT*&zHoL~_7 z=TE}5afGc%*wXnPWz#P$sSqK3l|hGvYBBv$`2^r2tiBeqL9^NHt{Cbphqc&m+&*Nz zT%Y^36C}$SvnU7%(sTqiRgXE=cF+1U&mgOeNok0x!D{4+?9uu1=x0wIF z>Os%|O;#E5eiMmJZ}T3#YD&4YDM0erU}|cxW_EC$dGK4H75vn8=;|U?Bqj0db6J6M zJ0+5EC4djOkGZX?ra8dUUcL#4Ov_KRuZq32jB!(!zj7-p=MM@}kscqdhG#aW!YR~a zY}MF3fNLn*Jl~&eI2GLW0As^j0gqX#TTorF3u!5W(SoeTIYZab#;*s z>9}Kl57o*f{Sz))AIYd6h^9NC+xs30fBL8flFY)eYAmVK#Ik1xp(x1&Vx7;Gq?e~O zM`Sjh{H2foT$7-{hsQlg5#V}gL<|8V;j~PU7P$lRZBE?s-h6ydTit@__TT|Uu4A^l zEsWOEai#LXxUDR&jMQN+AWoN`;jpequ=?Uc;7F*P`}CK30GNwDBS>}uixvJqd?F9r?)QJkO&3Avu1nnU-!ig@$| z%B}!i1&6WorNNNPVu6Xox%_@tQP~~1Rrale@{kQa;0c#}4`LYH;TsZc>JDYPo3&xd z26EI19>_!+4%UD4x-H1DWL^6;&c}NApa-7j5NbOmamqUdhfm<6!%yAeay@5H9Y=eV z1GJy4g|7+Vjb_x6}e}MSLxt9JJhD|HheThYL#P2|-Ss z42x!8tJ>{9rqwa|>2uOQQY@HmG8e~)_(8)|-~jqZoZ>|iPvvHUkq%vV5GW5WZDt~E6?t88qXEpT#l z>>>9__1RU@(FtLlBf;f5%VWp6|Af-#lA%yPxSa9G?)S3#dItf}IeN;NuuE26S7$E( zM&MILZ~a81dbVCfFnIT#$FN*JDK0B}Yxl{o+jZc7kS)SW7bFCOas0Q*F8|920&a-o zMjVfQo?BbkE6#w9(f#yvN=roxn-5)Jq<&W`l>hS-zG-PXsZv?T4$i>!s24R{%7dzCFuCR2W~JC{3JMHh?Y%{Xkue;j9oa_H;o@3IiH-%@T=u3o(S3nwQej;RX*y3NsWiNGEln1i7vH)9!TK9CiWsgg;NO92?+Y2|@< z77p7o{%P6{ftXmUv#u*SF+z#0q?4<2{(c$uc@q$+&Ua(4Eyt2My%Lh#T%NJj$7fKA zsJBbtd%dUm1bzvovhi}ggMpPf z5ae*Q#&_e0DvJ%*%d=xLb;zFucIf^TVb6U9iMC0qW!Jr?RZI5IW7e|%p(k)!?7+j0 z`M=Cce5y+Pq7Ito8L`4#ByB5339mtj2OTmA4mc>QG;6Vm+=EXi0Cmq^(N?x(!x+^5 zbmlNF@%K9n-!$)HKUkc+Sf6y%6WTKrL4M@zV>}TQ4K380!uA(|D z*FmT&-A)sOhnGWM1}5IN3o2vXhDKNixPP;fEQ0Xzy&p!CgMterw}a8Zr1L!veds4jE~=4{s`_$w zEV6Z%3}J^RbXN%;V2ZN4z8!obux~nON&MJ|URzW>ObLrwFxXPgNM;lDt>-t%3i-&v=@`xqgP zY39??2$cj@Ni(ML#OQJ|2U`3yDUN~KqROHq3zS3;s zxZS{c_UK9I$dk7M*V=rFc-#thn41k8mePA91xp{~+8Nb-cub_=n#i8tPgYxzY)7yZ z2?|ypn2hxg!(39GA+8nGc*<#5rMmNruBG-wtPaeG$xJ0HO#oHIMCy)4hv~v_H;&X7p%{ByN*wl$xJIIYIh4jtXyEWp7ANRQilXN-IvvlSTFGrUnPOA zQBRm%P^=T8a#O7*ta8fBYOf*kuXyuOLE==A|Ja$d)f+wW_n2Tt0Tyb^(%n{im!y>y z+f(Uo1*q&z>B)bUT(=o2`~DXlLI>VEUCs!n*_&(h2Hp9W(+=8;{nUM^bU*5ALIQIX z2t5}n9&*;Wl9@CME&Giv%E@`)ZShOdb)4<){}WCNHm|SSuUG$nZrgK|6=@9PL7@g* zcYfVtb|gj7C6zQ(+)jC?#}b;U`^fzdKf=laE&oxvwxn8A1nz|Lj#?604m>mE+=FC@r#uV(l$(*#TSwJ0KX)`_d@9c_z8TFYyx5GMl6zk&gT~|M zS6(=NjZ3Z83#&hVaXkH-($&$+*qR~kt+nUqO@NWw%HSdBGUlF1&ecs5oy7*xc{&LI zFT=aUN8@{ZY7_rpodVCmV4Sg|Mcf(WRKHa0TB1Db9Cp^oJ0J80_ylQretS)}X^}y2MA*N zxu^6@UNwJd0&{ z)}OMP?98NB_Bny*b&uvJ9FYGd<_?wqyU>{!@D*FwGL*r9kqY|wLamc*9&~?qar*Y- z`{(;b3WPcNj64J5$*=4~BZa?yS+XHA+~BY1^2y3}1xIXPd?~e4Q0OiNzIcxQhorfo zx=2B#vusdLaci~cHOI~vTd2ULd7W%f+ppB-1y1ef^iFe%HO|Q`-rW3xkDR9R>Esp} zAo?rQ73WeZ-eb-a8K=B&v#h$jJZhpD!*oi0H5`#3u|bEk?9B*^pS6@478elIyaEO2Z{zVeMZg$w*O zq(5I$pBzJ-O~n=Tp6g-sB58K|wqRRr2o+SwGL1H^wSK6NQ6bqs)Jl^RVhlwe6+j%FMQP}NBruL|M>05r)35y{%clF8U%+<(s&mjJPfrG2#|h=p zErJPTZz=+%dzHAhOhce z;lqWq?+;EAR4jiPR;?)}T;+ud7UiB#6C$iLe&_*lCDl>$SO3N-b+c>-eKAugq%NIX zRCa^x%k$N0tE<$$im@)e>%iBk%P`inP~`7t$Y_VjzD6hw)oLc8x*9?y_+|*)szchamr;BtvnR6PomZr%ZEKp8c~n z_iMLq-LX*VNo_ikQv5faeTF@u(bCs$%rG+~#&DSQc$E0+NJPrYYFVfxpqRnfi^%C%+p!tAPixkM%=$^j~N$NqBc6P z>ejnd)AKEGjj5PHlWvS1`?Am=!co?tx9{L%SW+r`l{R}Bb;-wEX2Bnu37?CF3C~kB zy75w}5*~!sgr%=fvtcM`*`Je9GE!`PfLqyDNkJ~(0ZuAsmwR~Q%6zkAN?bc&TUBmlGUkaOs+rytU|*)3zrq$m{W>_q zmoVZ=`fqCCbF#A-?zxRI<5D@f%GGKJhCm*Ig)&nxUyN9@E9@k_!q;r6c^WIiWs>>w z!Hb_t!5(#;IiBE5e_urfu>x#*ofsu~1`WrjCGov+3=H zK$r765S80pm#56CW%`|(Z%YcWqzWP-T`t9=V}^OUD0d^rCQVWrLk`-J80)I9NpWyz zO$tl(^GV%dw&Y4fTR-8HWfz8Ncva;L*YUQK8H0;5?swcOCCULav{Y?wA(|E@eKLEV zug1Czo>xbIe#nKwO9+146Rnr9nj6kRY?MYzF?)O5U#{tGNHTJzEiH|8UVOP$BCHXL z3Kg~{hvb6d3n>M;mu@1X#9Z$)x3iV8_A(Et4?0Ow(>jkFxLj#A9l~>W1$7^Zk+TA=mLE9uk83 zw>V(`+Yzr>`RIewW~Mklq;Wnw1``N`#N%Tp5tjQKot%_enVDVpX7dUg?Bw2FtRv)t z<*KgNT1)$$l%4NH?Sv<#{r45W8_;tvGPlG3wHPZtrrWMfyyu81bUYhSD%OqG;R$1= z-|Kt9*%?U9_;ZAH*&C^Ha{lU6V6Y`nF-JU6Xna!a7Mx2~m*Mz!w*p$fe$*9<4p{n{ z;xV$X2Ee<+JJKGUAFrVeYe$6iMn)E(emaWV}4)mUt`oEnI@F=hDW=LK(ItYOCQvsc@9`(9YKWk-w+P zyLayvW`A~`q%2wPq0xo2L?47ew z#O2s*itj^K)~RPyf>@t&p!e9AA^OTTc+hehYM~{u9vsVA&fT#S(O0f-e1R;nIUgYi zs4y}|6}3d8(hI~|aW+jcPsF%;lAt6)=|y^2Rg8*Co#UExH6(v49~0Y)<44FjP$VJIR{c9g%EOSYOGiAum+<{{hXBi7tYN&MUM1u%$wB!8 zWbvLpqmeLpnrZJqs~Tf#v6`HIQ2E^#^c@&Xug{*FnY_uH5s_3`_H#TkR!f`P=VEA z{_(Ajp;uj}Fq?c;;+uNlu6dwuoN9H(#l?)Z8-;(XGt0H;p(fx#_w}$ z)1}?+(Z8jn_~Aah@fj7FJ4wh7t5cdw{_lscI4>R(rNyA?U-NDw)JZO5ihK2mAX9aU zF3_7n%A(n!wIa1e)wYpzX1*H|JDOSr*85TZ50a!h{3GXcY|bk8HzIWF69ZcaHZ$nxb*8gHDxYxWCPAxF0i{QItXO`pHZ3@-v4**$|aPFFw z*I9nSJ>BLWr&?D~Am$$%>f?`qV@MpKgM|aS#w9wL6OGJ1@UwCuw0XzNGdu=7dCSdCUSxoI94Shi{1AEqj2ie(jEoD{sg`bta}e z0r}Ba0K|0czTRoh+Hh+Sdc}tJU-h;N5ruPc zjh`4AHSe*3><9O-ljfIpHIlO4pnC>7#tG7mdMnZ^m_;_3rJLKiz(+4S$@k2RjkgRE z(<0XU^HWB%d1qPJ<0`AJKyuwS`rWg9ox~o#GbN)+l|^+B=*ZhSASWF8Ks-1Yd>P~J zmp+-3_9Xk2exgBb2D0>3CxI|+ z3?}C&+1y*5c?;wGYs3@IIda~FD6TMSD>v=Yzg(tvV3zYRHhq7P(fflYEt#{1?yU!PQA9_xg4NpB53O(u!2%7u;*;+!*M07igjfYF4w?UfC?4rU z<=q=DSM<&CchJu2YVPq?P_MwvtBaAbm#Hn`m;d^cv3w1O^;<2RnxB1biID@@k6XL{ zZ<3~2Bk1>%YxQ3gDb)izbX^>07P>?E!w1HbuorpWL^o7SqUC>%>x28ZhyicS9>yf9 zYN#pYXn#$aFj*-q=xnu{LdUmGY#nesL^J->MoK6)Qu`y#0*?9r(3{h@YlOas9w)3E zn=@Q36*@?!o*_jp8B||hcrScpMc-*Wop72@_1=t4yF5ee;?5hRrp^z%y0#yI;DeXk=jSQt(L_|eGM7kS+(Vc>X#D>&}QPSNbM%?pv{O>0__HYkA`@G-R zb)M(zOc+#Fz{2J@>S{lnvmM3;oPGrXLXJA%P=O54+33}Kl{wj@6lQS%?HxD`!R@%V z!2k2bf>1z%F))ZK`)rsVE@d|Lw@;S>mWHuGy@K2_Ap=}=c)s6yY~?etX2`?WRyW}@ z7hc|#7cpgvJL!3VVp|Z)<4von<4&sNLX;_>C>g>JRscO}eaw%V>wuI0!hLYK2o z-1Za0Z-kI8ZmhaE$Yo#_Gjgoh@LQeP&Ox1aDB_o^tKDnUaV*4r{jV?Z2g#7@=O;iO zl8bRN+NXbg*?Rx@#?1axPc3brpAK+cw`ejhGqE(swX8DO>ez*GX z--{f^zTEA6?Uvk?!<;XQv)85S+q>ADy4ppxI_MHUWh$eDOHIck zAo&hb_MEkTbIgmR5wP(GocTOcG!Df3YI+^so?T>Cb1Wt8srFc^o6|`%ii?Eg+-|1O z_EtP3*$$icrrqpie<70qXlVj`^v5GGjpcmAd8M?ZVcm_(j)h6xSeeA(P6&I=bqe^j zbWNg`OuRpTqx-wy>{|a0pZ$uFbF-UtBRbhokdwUp_fKL~8O3r(_NeND=5+ogaGvB{ zM=2MgUrG>$9;eJ4`!UF5K0<5z3i}uq8NTh4FE>s*PvnwQjKz;vlsH(wR3k!AizaU> z{Ql}y^(cf6Sgzl{>MiED%@UJm=h|Y(Z}m#SB~9vxJg##}CUE2ZPt|%K@CJ}`YMT8; zUZT*%9ZtxewVl^Mjp_*CclOlkj^+;N#+E%4>Fc^bJ<=+5M*^Rq#pfZwJWo%!t&h&E z%8YDRuBG{1+|8J6`jOk5W@327!ubze2!s|ZWXMG4L3n;$3OM*nc=Ua#?m?;{K7H9> z+0scwrSS^AKp7{4h-5ngBYo`Cuq zXC&L@TZ{m|iOHgl$#gYaAy%8b)EI6&V^$)+qP|G=dd&AewP^o9N8B-$YhAGe#f<@D zV;8Bqrdg-Qp3;eQ`eQ}8K!PB9$@bTKDJb!Ic{EI0hRH_D1?RQ*XahlQ4@P>zMcU_F z>)*VI3$+{NWgK7Q& z`FXa*F6I@S)nF|9adH)(5!E?~mfD zjS7(7hESUu?c6&bCWYgEp2j8+fAK`)(7EIFdV1NWq4-C2EdAq%05y`cik(wOWsJI= z3@XDe2UOIQDl3-mB#HkCIZq;L6SndU9z1DMeCrP928UDJ!K^JD5AlOyFcF!lEJKD9 zzNCp`!IQeF{zqb@jyHpm;y=T}$Zj)sRH<~ZKEM+fZYdo949r^spd-cBL>m2%{s9Lr zj*b&F!u7q#W{CZKrLO()n(%G_BHstAo#QV$Nva@TSSHRn{u87;*NO6 z|4%P<+t@Z3tF?Z4gwNZGs0XS6+KX9sRSUHiEl6&x{moN3XZKW?^YykuAdJSx#oh|& zV`YtFcgW>qx0zm4%jt`1&?L0`Go)^sl^v|^056U88Lx=+W-@r_<&(Z(h19klSpnAt zhq9J?M42g~Jb-4_B$=iiqH<*K-Rt z!c0l31y-hW>zcMkqx*nSAsA}Q7|5^3O8Sum>T1kN9Ek}}VEU&_ht3Z231J(DZ}haN zWklq*hOuy|)%02Jz~K$}7#lw!Ug}lob#Q`D3m9 zAcT)WGi9_!tU-W(x8?FfDvR`ej=3P!l}A0f+P&*1{hzsdGq5cnqAilce+1}Hpv@Gg zTl-{`ni9V-t|2$#LxaC{{V6EnQhzs13bsspouq}jJ{r-yB3^kSKsl{y6vP@VqV3rb zuofVQu!53ylxrk!8qO_%&5wMy?0ui_=hTLG3$g~sMILNL{|;iKK9U~5_wUu3#Y0-2 zxf*iL1F*0|!Z&3ggPUO&IPJWEtzP}@aO<8xYV zjVGR2S+)+$PfjtBpI9|G+>jadnOgdOk&T4zUu|?gce~4S96>m{Jjl_L52}CAE!%j_ zw>Xz{5qPxmk8vHPe4AmFs)mN9!|m8UfYJ2nMIc>V#MGPpt20i3Kq`L#6*uU^$i>=o z`Nn%r5^N{4*>8xmNA{blN!A({zk}5I*gwX1r~zq)U>eHChoLMQf0HE;ucvBKi&%i& zRN{@`Du7eg3vm6r;umqFKk~jD8P@Z8!lsldY8ro}%6j&}h|5^8ok*)@muflUdei(< zvVts9J6~puhiL-z*2+9Z4(fkR6p;qkY??t20Gj2css&*11aQgv1kQjIgv*$0_xoXx zH0?ArAiu&Nn%pm%bcDlrMyW%dbJiJf+b1D;mNk9RGkgGOUog^R8-NA~dCY%msM?Z% z(Uw^lvcAz+7-pXt=sCnz{w?$ZaFOaix4li(0+}_csvrTAz9(`0sl)}R%%qI@3KSnT zD`O-jqkV6|KucAAM<8=7>x?%V4H1ZJ&}Ks!)R!`q_89kV$Y}8)|3e8Fv>_AoI7VotSd%R=l~%A|yioD=a|hx?X2lww;O={RE-hjf5Pr%0Q^XG0F< z?*ky@y=`mt1$tj^qs`%i$5QEOeg^&KLBKm)6rA6JfJpar3H`|PHTh$JI1rsglD@+w zFDI;JIc|f$s~k^skEO|gb=L0)e0BFFp34q*=5H-4Ak}e~l?9xbObL_S>NKge#|4P2 zzVnIcnIVZfQ%Bi#Nn%)T$`p4x%+YStr$9BdqE1jSgke>kR`KJ>sGpt)3YC-#<^oC( zd5t`>=?IwE&($V~W~;+!s0`Xv?|zF_8&nn(wcL!r1K}waS*70d9Xh>ZC?g`OYpBp#goizCp6czG`h@$KVd94JjyLPWNg#3W6 zK2z_Ze~~N)xbgQ1<42ks)cW-^oNJOjzOThEC6l8pu@XPe0!Fqp)-@#1PA zKdt^@8C_~@7BEIi{V2TQiD%6In!A_X^aKkLqhMg?A1#SR3?SR`gLHX}OuSk*B|#Su zAE&-|wU0c~Y%j;@x5Weh9)76RpAKpHU4S_X$M2t!uHBUJa}IbFPyeW9AQr_jYFaFo z;iYERl7CRJJbgYcC6O`_5!b2D__XMF;Zc3jYJdUehW6v%DiWJfM_VeO5>d)JOseXV zr$f`d#l?aeb*o6Dp&GN;yd*(8orFBo--am~Isu!JdMF=x<*gK_Xjyz>i0#FQ@+q58 zMcFv*qbC4}<~g@#%%6fxPcJGG8$yf7rfhY^2m2SYPWxc2FDYP z3r@iyPSltGK!UkWuJJtwqq6b|tL$er|6@|GL`3%z%H;3c^kDi3J+t47!jwQ2*28vM zz*KC7J`dg73Vk6@8N_wOx-4y`0>YkXf%PI&b_1^g1Igy~Sn2RelyDksv+kqMA>h40 zNrA{>u3=5DP#aNRdA*TSWu3~=0(!`l(zYM|*l;kqE+dpU;{NKeYS?!>WKu(j_Kz9q zMwvlo1N?#9!sjjj4S9&A#qNKyBSfExn+2(@OL$4m;0efKQh8k zCJNyGrd=2_%;r^6QnJ7poEYv~lw17KEu7IqpMM6V)LeU*>dqg0S|P&X#1tYw_kdzP zmEVbi`jHTAuQ?1t+EC9(vDy*^cBHF0tqCv{7i0eTMOB7c zZ6#Q0BpU$!4kB9o{9k}RhS^VV4Kxo7@V?b-HS8QWsIiz^I#PgGG5v|^1kc}z8m zg9oH1VsdhPz0#Odvc+GL%t1DPrB#n4SywW0-ehn%jb;PbhuBU`8~7>v&sJ^qC;tAu z6fS>L9n_rmYk4tU?6iE1Xx(O}ueH5+gOQ^I4AoJc*aYGD%o;Oy%NQst0na8TjRk2T z^&~g4W7589aYU=U@iiUS{Q<#&8$!IBDX^>=RNcDKFs>)`Ohmr1T@goRuHDF2t z`(5ojjjfZ;bhj)VOe7Ep9~-_D6DL#x^%dp8-1(!++84?3ZHX!`86HXwLMX`|Jem0g z%orN?Dz+%6n}-f%DcnVR+Z$6o_#==>KOdWnPq<)m@~^4psrj!QiV6xjNj22VtCu0U zu%8k)299t*&c1iiT_;g0 zIPVQx?}{ZBE6CWx-MhB3Mf#c8RwcRa#FwywG#OR48Q}j}>b#Ky3AhFhjR<;g=zQTS zX9mB$Neb$H|ARRb)=u3{?m$IsS?DdQ7|CxG6&8H7lB|vWs!#|*D#YFKd{x5=c`f;n zx1b#Sex;pzp2xhH3MRtK;z}V<`RT8D%iFUMUwu8QQmClt1_0MFQ>gG3Y1-*&FjfI? zpdO-RsDkGVy!@AlzBjt6KLT1YUhN7k(}@%IjC3xo$<0K(BY_P;j~P7*&M0q?#*f&b zYN=~bX_2U?Nc>IY3v4ylwVgb0bAqEiTCt-V11<(u*cpg{lTp(HEHW#jCx9E8rgH*bQ-l=v?nd??+4hZ{Y*o*OSg}tfgczXZpJjO2(dUe<><9P)6vBo%`6Guj= ztkeAr{=%5-iQm3M!@}hT*cy~C#33P-!^$QgxvQQ;r zcAsRftuDy#h~h#+*mv%yHW!i}P+r&&t2Rk(V>0s%^bKR6*YnZ`^D}MngrLBx+3Osf zN9W1Xj!`gYThnFm@9nk=n}%x?w7>IY<^jzGp5x%CMgH3=wACOz_(JULQc?ap!R1T^OSiJzT5IG=X;y^dHEl9cBdiBJ)$OZ}<@Xt#J7eeBxV%YK(03xKP;JZ7fx&@t&up|FKA(@J$UK7m8gq%rFx04aa}A0U>~d&sIr`G?k6`S-JgmR(XVSRNLX_S81}mDip%6 zi*>D3PoVax(4f-_AQBqfybGQPMS>5*;O$<;R-Z%I86ULhU3H!YEuoUbo59zTRtm=8 z#jEL`;&TFrG3ev+TOxEM;XF7a+TfN=s-*DD=D>83@URrJZHW6p?cAJ3vTM5L>Cd2^ zcBSh7qkgO>8$TwkXlGOXbF>=N(5@s>pq=0AN zuTfp^+&M!lsjCHry!5^(nDbr0nj7Y#Lanw7_V=Ib;~4!d2OPh=^9rAe(v*91n0s^h z`Sj}dOU|B7H~O+;wihfo!qI|66FAWFA~5iqRJ7b~@4KK=nO4*O+bFZab9hq&c-;hQ zBIP11jPQC0wWAU^@_i=|ygL%Mds$C>>Nj(|^Y*-%uUT8p{ayYLT~dLJ0!9)8DG-1x zfZ@YpHXvOb3Z-frKjpmfg5^eZel#}+-$3~Dk*AA`!%sWyB3u|2KRl1$J1nikz1;}` zS|e{EyI#2!hc@0O4?LetHE;!x!o#KxhQIuL_iK^*R_0A?G`Oe;sGa%ceItW8gj~BY z#!9Q|UDMOQNG{5)*TS4C{bcVznF0cqdDcUB1lV1l>uo;I`sa8R=7>%qNohC}Ni490 zu?R4iLr{J*V+wBz`)-K=h72}U${-%u+vUwBp?0oX{lfOnh0yVSCcDwkDAr8IQ0-J@ zI`hvVc2d^J$F0<%950LYAh{mLhTn(1A>M#% zqz9w8@k(~@vN2?lIq`_hNpIR*BC~P1%P#a3Ims$uP}u;CQDBRy)tt3gKeU~*lXs2; z-U5DJlU5D^Kd=kNq)KtEqFJ%t#azF6`5E87kY@#iI!uiL-nnnQg$HrQEyR!DV!`C! zz}ZRe$yy;GM`j^xF|Uz2FB_z<{9-Eo(|(m0eWY^t_lh93w?YcFKNx4UilH$lAA;Pe%!>ar*6R7#ZgOqiTkO1GITHnT)#Y1p zq{3J48UxP(-kj0Ce3?t}={2nYGQ4LCh*dB;&)5)4Tb_(?>XQ?aP@lFuo+r`oXF@G> z*Ewr^ZQvX~KQwTPu4Vfe6SP?AW8*(^kOliVIr~SD#D^rVN-6*#oRjp@~9AYMpUyO(Ui<_#UORllT~#-=Lk&za6!j0q^N3MySzPRe@wJ^OMw z4gI$+g0)E7qp;)Vx`MgIn(cPuT#&iPPMK#^t@svGp2FzG!6eybfRx=3o24B=b((a| z!P%>(<$cu-Q)gUIxS&SK@1%u|ZY9A>+YLht%9jZS$u+_ufqe}~l3B^paM{#hVL<)V zycur+Tk74^H>pf3PxMAK#rN24;z6l3CHd*1$u`b@eVJXepKBF+n96xG(*KBNttQse z?8W-BtQpK~e$6=S42e97ZuvxYl=>{GGHW}9NYDgias}BpN#@vw>P@oz95p6ppo;5p zT~1|1#Tz!i;U{zs^e0CviBbnMK@L5?xyT^bbQE+-zuWATEd2w)@yw@yfGZpzp;^g zRDmnU4X47cj#cI32)oTn>{rKw2Wx@ey`61MNE;pAv*jtrRQ74H5iXR zyXPx2=u2Q~^y{7U`k`RbvaVLgjJA(~Uj^%vm3r{@sCXJ-dG$XwUyi>Kv62-UA}1q@ z-@e7F6fA{`o5mpuq9&vB#*__CG7t?WBQo#+_9aAnMwP%t`1VE+4mVLbQZ@dhuO$hMDpp zK!Nq!ZV*z=sgUhYt$wn`mCDtg>d? z*e=@N>(U~%G+IG=#_$s|1qXR{w zNOWEVo-#*0*O6rI4s0-Py@%^zvu1DYWDnT;d5e;v)xvwm6B}X!g;Fbix-9hBs%yI} zHOZlceZE(J6TjZTKAygIyefZvwl*0awn!5Z;cqRIZ3&TK(ghuXZ`?qVj*7BUlO9VN z7n4|KqQVZa9k}}WbA}ro#xnQ~W~_+MO>?rnUapMN8>klzklZzIR=PR?N$ZU1b~)k_ zH~H;r;o%aJyswbAk8{U zbwU*ZYDjZ{#j9nCwHx&}Z`hI5#ntaC-72<#L1|-u263x`6f`S@fT_Emjzm^=%Q~^^HuFg6kxf++Ck53Gu z{ah!%^uOu&U<5K!&uu9eA3X+afnpZhUv{{4Zt7q(E~R|`zK=@Kk`rN6o&Fv0bsUyD zRy%lqk7*g0eyg=9XRgZQY8~3=ztmMKy2sEC+a#~U=J!3HuHF{@X7fN+{w{Z9s=`z7 z{c2oH$9hnE0K|iNQ&b zSY%38Z-dPKX+!N-<2qlS84U;kqt;tR$YfijHaC;)S@vw5h65CNDJE?7dXj~V{pMvx zAp}F~Y2+jAJ!G=bKpE;5zM$dZ*go);Xs=37h^SThx7si{EqW_QI|7xykoXWhn3M1Z zkU_Njj)*iVMvk}a>ZDU zQP~oXaYM>NCM3jUT923gG%l!IoiP|9;cP2^6fi1Wo@g|Lr+;fQ0@`!(QF;}5(heiU ziz-WN#=qV6_Jq@YJNuS^#wGpUnOn~GKoH0Wt? zMDBk^h1CKV)SSk&?~UmTb8Z6bm;*{`i!yE%k_bJjPXlk|@gCJ+&iW>c&LmuBuDsqH zjR8MNwWSs}(gT1Ip(;@YJv~lc;(0jGU2fzK zUm&NgUiouYeq2DXGLZN0R?84V##E3BS>UR=Zp~V&!EcZnjlOLMCQep0)l?xE(?hgs^@HX9M<0Iea_-&okzSf%2j;G31k1g- z_aC9Zyq+rNA2~ysDw&Noght>B7KZVUn~Q1K_K*UD<_YXd5~k0h*rcrm+KG{*2SjcZ z%_7aGU#-UNVDry{i>_aL_o3xMbGmQ zfX06C^O17soE+gE07isfMTuW=#^eDlvhWt!N!;w$Z4=0quN5(^1GzAX$;x+o9L!)9=)l+>oF#H)S|*1{A8%`{ zb;b@ZL=mYRSFQfe2`SE36*%Ai=;f;>m#>B`k4|uBw|(cu<@E@8xa*XZrG1F=S9uxt zVj15#B0jXGElytUl>4kxQJ&a|SZ|OXxc11`FvBbeui#5qp6iDY*U&w4L8jKjOumF| zz2$)-8e*Gq{TB>>qRM>It7r5BcU=EC-t=zIt9<*InAhv`3CT8M+&Z8K|D+afujDia zKYgC$X7#?a1kDe`omHZ0O2d=%uuZ1Rfu>ES$A4&2q7x5rGJ#iq)GR4q|I0)@gpH8R z=-oa%bl*B+N=i!keli=Nl+S@yc9y(9!za&2ZKZyKBW|3dv;k}-{Vs&e z^r#+u!FXN0j5<=e)T2fjCR zjGO+WM+v{J5}pm*Yqd{z$#7|^bH(*i$FWtbb_Pf}M4Q?b>yaKgJ&KZq;Hz6>#NNt) zD2BypLJei*R5c)8nQ029@*m^^to_Wm1X2@foADbg_^9{ZH+St5+W2p+vhaMW*Em`B)ET)th6}OYJo(=CWdT? zemSc)-YET>C6x8sGf|GoWu?IsaU|&})kjh?9=Ht7>+e0r8Y!A+4{4o1VsYRpq#RU; z9c}dIR<(1G2FAFGemqr&WkCrlC_D?9-@iqlBt`{u8wyHgHqS=Y4UO86T7?(IVHi`2RZYIZZQ~S8 zLn}Pcj42k@ruj!E#Q(+1q7{Z*t^U4Gme7f2z|G`)EbTv5j)(3#u=&s=(wg6x7#QWR z2?VoKPl4mJOuG|l!P*AsK_e-1c&6bLiFQ-fnDEDF54gLUiOX2JTN(L-I=P`*hrq&( z8sv>BNkO(*z*- zm#SN4X2Cj>N`VFzD+wnXE{YR;1PIRu7ru#WtIL^Ft;13(=ep$PpyE+XQ?HoO;gi1+ zQ_kK0-RX=kv12R5@D8Z1v%8_%LqtOcDWBy=e~J76wECLv2@iPK_BNB*hSt*5Fulem zl*E%~HNTt6r=~{PL@K@nBo6*krv<=~osRf#7S!H$b#$>&>EC8Lh3qL`#iCTSWfO#} z8lCBD%+O>z-2kPh5GEnhEr-7oO~{g3{&Bxrd`M2n6=$?;dn=!{7FY(ME=Q-q;IRwD zN{TP3UY6LcuTt3PDQ@^Z8}%sF49X$59bm^^7O#xSN`gYR0Jy2f)k!SpP1KrCVq;PI z?ytJXc1{uTbAA1M&RIl);go^01bI-Z4yOc3Icn49NnZH_72$7&-s1pyfcEsXAKBG3 zW^-O%n*W&GcKT0?`48k&!K=OoZ^#5G01}m>3iqfwH;EMemFiT^u+>^bpo*E~;&8Wi z#B+<~*Q0FOrkJywyI)~S4Y}^CP<+EPfn{!R{xiqkSQB_EeSu2qWk8Q8@q zctqLAYP%i6-cGS>tYFQNC%=Vi^={dHYOiOV{t(1&eIREaxg&k5W z)xf?~>9<`WUhw!Z@&v-4RZojxNj(4c0sr|`vu#_?VIBCIo!A;YjTAi_gv7s_Q{S6- zuRkmkoFL`(Dn01jE@ir2Qk|#5rMipv^xtur;`C;SW_@aV+le3u9g3#m#L4aDEOm6e z`w|`9PuOka=WpJ7cUG$|S8{c}MFd6G%EuktyIq(5KTY^5nV0fR3D_p#%EwC25UlN! zsx)%I%0TZ8t?4{q{|vJA@ir9WW7Si|Ub72$- zRuW4Y_O-cn?|$_Ds7~fpHTter#-S)HTuVH4;j(cTwM0EC14O_B<>@Xv?1PAiiqOl{ zCz%jni_`8_k=-TBrqC#Xt#tPf!6lZkbDoDgs=9vYjXT<{tZltZjQtjg*sJ>PdCMpC zus0j9H=QuJpE%8Z4-Y0Np5^2RZ;8vt^z2-Hy4b0`=JK9BXKP^4->Z}Vu9qJ86rC2J zF6XmtXVAC2JR@!vOEc?hGAkYQS}jeQ<91b*P)qfLs(z*<>@Gt+>9bq3;?3*r0Du-w zZ!>n-pJux&3DQ9=JTH_%pU}iacU>*BdmwJCJCVI?Joxv3=u7MVS&g+=IH)Ii$PVUb zw^|9RpN+LLv6O7-&O4JDJpXU~xp7APW_!lK$j?1vMMCy^pd{mh@!+Kk?T3_Q?FL5_ zQWGd69H>TqmfC!T6L$aGBEB7-^ zR3hDE@{eCxiS)P}#@PPcHRUG7$=n=4!Uob`Cul^@!%9C9;*qubmF$wd?taM&#t)Y~ zZ05%E7L(C4L01oxQj)%%O`gHFV+URhPRJg=pH`C7W-wtfHk`}Xlopl2t(5V+bh$luRT`LZkI(P;$E`_>KI;!xjMMBujm_VOAA?8<$Gr32=?U#+_HH(2v{ATObV3 z>9R#mDohiLqx;I|QMd%%elAxa0ni5Y%|t>NLDd$@zSVmD_oz9^T)U8WA|WyMIZq1p zrYI*u$m5FcknGx;8V~&U;Q-cW4B)SMVyLmTxgo1Ty$z6gKnbS=MDBCGU3rj@E_hn1 zYb?f4No44vfdV;Nk4dk7ns7We&Hv99qqJ`8d;B>nA%EMpWt41-7!pn)yu`U>uY@(4 zQ!pe>UGWV?*QR(8%Wxp{_Jjfs%=(zD9{C~IlB9gTo2f27vad3C<x`Hl!~!rsL6CH1mo!K|2oE5&z|QeYWkh|%1j2l(PMwO^f0qJf|C?>W0ysxT7wj)DX>py-r z)r*4qoAou2*{$IKq)tbhhPpb_lrNT$c?-$Ru#6~>zykUa`I|4FqKe~XMcukHMW^0( zWc>6-`b|AQhtP>XWl|^5ytvU`S6B6B`}v({x$SkI?aa{vLV};`G{wd9Ku%)Mg)JaU zt4mRoYHi5;NhqKHRDtRIBhRj#BpNgTF;}u~#}LE0r)!2ib43i&39aXZBu>fg6hYfD z<|e95g`36o&E}ar4!;!=rubATK0aq_H^)g!R6V4c+3hbfD9y21rp5SV_4Z8g45%4M z*h$LQSAw}LU0nJBugAYerp32ab)Bvy+M15jY~B)uql-VJKL_+~-2u7OxQyD^f0Tk6 zvzZqjhJVgQLCr)?U*^1Z1&_w2(##yN}?Y zno4Q% z60FTk9gYtTXv09oPZuigO*-mk{@K^VK!&O?a?(6N;-=)BVxocA%X&C2NE3??Jt;{yyZ!6a(C6CTDdah@Rsq(}h}ev`kG>0qiH!o>Cdo^}xXsH*ZuHjVp3L46z_4ElQOvh;KA;!tx3L55 zMHA-j_wT}o3NEuVjq7<$$95tLr@V&;Axn=e~3JD1z!Jyr>eEv+c(Qj+xA$bB1M<-WCzee34+ zdSmQ!sT01#cLutJ;RLMh0?#fy)lXQQk(ccIkBP4w!e=C58F0g5Nz}Vt!GL<`>>WKo z)T~SrwwBqIN3m7z1r`|AIW!y0w*2o0CiKND^~%i+nrYGMW%H!FdR4P1PR!i%;UYF3 zhq=GQJ4PC_#Km@dRp?L3jn@>4j_oGaSrRUMa@zT2(Fgae?Wn8QnR!Oh4!k{eynH)` zJv_|8O6+q{?awYLyWfh)F|YLeHhXRd%8}`KZbfDnFhkEUy1r`%Icd#Us0;`oPU122 zN($b=t|bA|4bbDsgi^hB^(I3pz4);~os0zfga-w?_iNmBb(6^qc6Ht&YV7rb%*_nl zts2}rw-F13Z8xiPpQ)pb;)^9FtER2$%6{r%i5xA{Ex?wiBQ5mlzvX)~oXf&n3!4c`+ZB98~ zZph_Oe$$)=4gru4O^;68{B2`H<|%KiMS=qk0?w0|wF@2>sIy^(G*%HGB3>gj?OY>4 z0NHx$_91&LQU=KiprK1gTG~o$#DCA*uX&CBUbGF0>7?Q~qikgID5V0=+c5@0eyooo zz`YtSYCX3L!z8qK8&%^VAux(@b?t$|VnahQ{lX#)+dM4vIyJ&X>!t|jjUjbnhxR~# zy&+*~6imf9?3Km(LW+i-M34Ej@GR{-0k1j@EC)RRZM{E-qP}qSsP%Uo)w9Zb8QX`& z(N$7_myh&9=8>LL)Rcw@dna~}WGTc{WCe2!UEt4|A0ff*jz)03KyFZt2q>)D1(`{N z`82ZkP}!0`v7iFxGnMBc-djwcPHKS{0M>r4jubCmOaqZN$as{}d={cW{ROk$unwf? zmO2yMwxnXTBXxGuyD4C*&%%iW@E1IWYzMk#A{gw;Gi&X%2&C^nd}d#?RkllxzXH(a zt=g0XwmTjz#06#8i<8j4SQOV|0XJoP+;Fsl&wQvg>j%V<*&8Rb)ybKEi3R~QODwkv zr;8vY*}!MX?io8T*m8R^o-SCP>TqPdo~eNN-o@s6(4<*oWIocAl|MA&E@ z^{`8yr!+R-Houxw?FZ4%0O*w1)UjJf6E9QvyHoI0S8g}a69QM&z=@b+I~bFBa&3m& zV!Ed!D{<@YfoQ90vG(Olg-)G4Bj~3LG7BUb^$bWp&MSf{7_0YubVGd3=A2wl9&gR`gV26- z%v%HAj2<#Vol-Km z$II}-35GEN#C`-_cRP`i>2dc&Bh|W}tZP#9ufXR<(g#E>b4NJsm4jIDhqtZ18+QqjP}ZPhew4;Ete^tuQIM?^YBDHm+t0ZjKKwK_XBM%~!qXw+vqI74@DRT(`aW@9 zIB}%3ly^~RFTa|IiR@5uY2N>U3p|;r*t}cu>uQU>uJB)Da2Y1G0|~l>^~{EZfMX*rI6iJ1)|Z11xWjm}R#9NfRoYY*oARr>RPM(8%}!;K*J z(?bCxM%Rd{&cB@tS8~btauK%$B0#8mfzZj5iZ8D(4hxGs&FMQ@nSpTdgaU^WKlGqRwz|^qSNL068KHxqmP=WSxfpkpuvy*r={Hu+Kfb4sGJb0XrlXRxAm+sRnBu5 zIqMe&%?1ze;@>)zKT6;a&b8aDEU$jx(t>|3iQh3gxbolad&!nib$ij>+5UC@%IaG$ zUr8i@Vuf0Q4S)m#?PZb1>&k#gU|<-GA0`OtVSC^CEG99}(^vLXoTTR+_d1VU@9oxW zp=XlVDjw8P&zwI)J(h%<BH$3QgM3c>v3=V=eqzFMB<$g>X3uq8Q} zV7@>AxYGLQGt0b3-aVDG?19{2AwgNb-PX&-=Hm?tp$|qIS{ws+`p3tI;8==Ab&XvF zECY0!Ds2WK`Ea-WLy+}CxBuMCZcuY5;P_l~9xo062AV=?Jl5t5F?PULhsP|g(ZZ0& zk`t>M(mzUpj&v;Es`N|pZyjZhmYm`+*v-Qa=OW6tEg}7gy}1x~L9-p5K56~&Ra_ldI>p3fqvQt#gqf z2$)3&r)QWj=IyU@C3w8Apm$xD{!B6TMsJD{hj}HfHxv<}^13%aSH~p&r}E2M?56vh zCfeJa5eLU}TH|WjSs7LaEZVg>IEq60v8r)Xd7)GmvBsG3 z^WA^0u+BGsB(4YQ&jcx>x#*&{{Q#VFoM zG4=VYL1WS?}Lse*cujjzI}G>XhbPdW-YfPNyIzMu!>Nn}L$ z;VoPU$?JKPTd5hgCiR;xuft=L`rjf-Vxh{&y~46baBFEr<5<*&w3EW;1~R5Zf(78t z{3FPb>IT7q#?@-*>m2|U$N})m59|YQ0#pJr09Er(7=5BI0=LBh*n_{-3I+h9SaCvo4f%`Zc#ruC9J1e$kLIafp~aHd7*BmkdP#Od0u6 zvfUqAH^*T2(juaw9QcGeN}rj2Hju5e?s?cGQf%{b+(W)htko zpz#UwONc6~ot^<{tS413jLrZ`2WEam(LA=vv*;d&{4gO}V%>LGQJHDQtC61P1|!Yf zLS8GmV~g#NVN!A9Qs5O}2eDJ78F)7EDvEeLcn`D&cr8uO&I%yW+N7eq3!Hc84;xqX zJXJS{W7Z#jW91a)Of(Ceg{Y4W{ZxX#=QdQsj-Q;RdH&?(rlqwHKw7a(eW37Hq_PZP z7Lpfzv>HAYtXkDnWI03z?+oPZvouk0ArEaFPkopEVKcd#l7zI61(ifHH#E96{;I~= zzc3#o$7X&T$!<=U$;#(o5-`^;m#K{Z{4=%@%gVTJ%sb+xN9`OY`ihF7SFvMa#6gv% zs(I(l7uj{(mc74cs$1|@mejCOh6k=uN(>Ow{__x_B^C^x+3=~tQ;v@a&i*+|VrNP4 zlYCh0gv06P{&47o7e_@EMKugY*A~4tuD$$HQQ%tFZ)o1~HA?ii@$Qb}6k|+O?Kn4+ z2}{AzR-XgzLzpz|HKDD^%8oH-@K{HS#KZo(b2KnLIl{~Y!`@vJn7^-Ir5PWfc7j6L zbpu2jOLlHgp#Door3NDDRaC=&W{u%5Sza|;sV2G4O-<^L2Xtox0+H9Ea zH6SEOcgF|hd=WVohQ#q0KfKf~jVyi=w6BSNqM4uSM&+yq?)! z10JY$#UofhY7o#@7CUJwW^8&+5G!pDRz}eDW-=Ot+)~9Ef!zNeNoN_>^#8u^_ZWgw z!=hoR9~7j!VTgouNY@a_NsflW5EZ4BZUiYw>1MRj5+g=8jPCZo@9+PF2OI~-9&y}z z-S>5!=eVjpctSHx!ihQ;)Lu`5ey=@KDPl)=cr;8ND7Gh_GGWo&bh*>8ng%IF-I#Iy zYT*iAnwO-UGjTblXaOB1spKqgO;#KXtMdNgu9?2qAVXMhBWh|DQVCaOvq11sdxjL0 z8XbVXt+m7+?%rT_`KW|ItdvL-5uc2CrrCopZQ;?B+W#=^y%e#}C`JHrv<95DL&*QL( zDbH%w%!P>f#^-;w;*|(5XVY+-3VL0N%k?EqMKbin)KtB@1gB1+(0>WNj6kh~p@)-? z@HO_N`beL&ykI%1o85u++id^XBwO>&0<=@61XTH!n`!;2e|oGqA+db zv_H&?|6F_Byx6%uj_POLtI)jG=dm+q&5v>k^F4nuxnA;H5fZI^DL1<fHfQt!_-8Erq+fgrEO&2xpUyvWPnw0(~#Kt&wTTbIs#lGB|PgGOW z{Ifj#t&iK*nkOZp(_fn=Y~?OM_X(ifBHBE#p{Aow0=Hz@z%xVIYJYz1Zhb=q2(k0= z4WpRh)0Sm#QqMil{r)jEx6mN39sYcaND2m`+*G%Enoka*1m^Tto!p^`fswsSX4g|l z_+KGXu0-daThx{3W9|fvY|i0iQ6Cp~&;H1>fg9~` z<4>}FA9&e{@|UQ}oN z$lW)WK9JQf!gDt+zD;=+Bq5!NA>$N^hc-hN@P)mvx2!Mf%i32Z?E=M$d;P49v~j$W zIyN1ORvwthfk1fpm|gGDQEGUEde7)+QQrVhtq3)=NC{zJ$26UIYkS4~a(P6%6nw>` zOgn%WTpqccO!7(6UQ&_1^w_aL(MyfYYA1g_-_ve+?|I2rf<(%-6q$NSN6)rZaye#{ z#z@ry13%)`6dWCM*c(zP>nd?yqj*o2M|!WnqWoPIc;40gFzquA==wWF{jzJFNDSbTp{oLRCjDa%j6O?8(LmE(K zY%_3PaDf1B5MnxwC2pqbM!rWW*Y(Ega~$NuyAKFFn>i4SL#4Qqt02cG_?cFiv3&xi z$Q1L*%GFM8>;2j>;T(Qlm(Ap`mzj`EGB_n`wu3l#Ei{*DT3n=%UUydBl|n%b_7qJC zHuB{L+iBSe%q#US`Iz-~v+XQ**mHd6A`#2p7zq<38PS3Q{Zsi|vusT6Z=M?lN3M=n zJ22XdmeH!{)W+XR2ieGhAi^A`%%?=~4{m5_3Jf?A)CFS54)i_Vfd#o~Eeif704%b7 zDra)-@;7Q}Dh^4e7ewe3iWQsKa~gM?Bc8~@saK~V*+*le!g;8_5&&Ker515f{BJ7i z{lIuzU+uie1K1aSz^)^W8)*+uI~ff2!$@PqDk*PA-*~t?f#C58w0+z{NGVzIr@HrT za}q6vB$#0@Cjp7r;I>Cg8ci6T{Hp!%EZQAYZOy|ST@FUW-UvTkhOx#vKM}SL#nu9T z2WEDyEVw@5|MksP5rGcEXw`4bN84Ucl_*$2$=dL#&;Fl!Q{;tm;W>H$J&#ttQ_+kU z1LA&Fy9guj3QLB_%0bhn%`+hUo`wvTqRiA_?RTraur5xpN`Mf2BALYpRLHP`^C5(V_`($$ARODJ>fgrj3 zPVrmty1d!mjCKHjs+Y!#{8fb7b1jmK9rvs$=q|W((3iSHvhs#~s((}F5J~yq6WOEF zEfehhB~25@fQdtz5_^wQkor_AV(wj_9n)rbQLCHhpStg61skx*tc~q~AKQW|UA)KfYfrZnrtbJaR-hQ`MOmCstQ{5w`S6 zv>mqh0fNwW><0_0IL>-~ca(^Of<56mPVKCHIriU^w3FFH`A3I6lJ2;)$rLoAC&M#d$tZiYjFEKn#hE0JRSKuWOnQCp!5?vPg za1f6Us}GT=vaYG2QwqK|%)3BIOWU&Yk_8m@B}I~AIMyEFdj?1d{_n25>uQfut9HRP z_RVDU2f&5d@tN(@Q(%yja_wG%Afss855Z39?fWZ54$?((;I&G}e7-5Bb!iXqw{nqw zv)V|((2!c&3?@m0y%y=M55)E0B9clW+MW7O^pYoHd~ch|i|pM8?O90K_1{TrM5T$` zj;o*mqJ=+YWd_Ad7;H^)&qRf(Uic_6dPHKiG~QB-^_<7Xub@4H6RWl>XEYjE_16cO8Vni0v6($icjZi1V6PJ-|5Fb1Q0Sx zY3Ay8wEAD)paEV}3F@6;QlG($1f|`ES1b*?o<7UXj4K67&R_j`c%kMOT0DVAzqaiC zL?z9FftpJ73{w*Siqe4X{d3s==F zr`60wpGHArbggWy{XO-c($HAD@v|K!g>${FSS6d7Z03ZcWg) zlYbI8c|(tRVBt&$3w^I#Vt&B#l_ackx5r(s1tlRk_p~n$S)Bph<9$au60rrVn|*&E z%}yf#F$B5P6$TGAe@;3`o7ru*dLrpiVjm*fb0;Zot(OnEp|sk|EKRz?;vk3PnroHP zu63IexL~OxSTY42MhMj@TNsN9+LC&J%TB4bzu96Uh))=w9Z0o9uQaEznV4e6w;p|P zeO6ol{^Dr1itY9@Gir^?>!uo)xi(ABQhN^4^&tZ1y3*DOTh&<;<2URB`<19l4#y5C z_P_ooQ#TqjC}SEYixQ%vAIvb_>^<>af?bp1%Al*bn@!Hkoxq^;EPx@fr9*4{keW3! zBV;72%=ql4%zKL+h^}utr)uyGBZq`o&i%VNg>)#4d}?3Ma3D$4dBsM!_9?24$Qc!N$YnF>ad^ z{7A+xIEZVk z!x<715?BOQmz_(sL3_xRBUw+Cp5vjL4hNTU1Nte*1n}z9%Zmr|-TM9h1uH=o1oA(! z=mw#~kMhC8t4E8mQ;BHm3G##YD@nnV44#3Fk?`r{lCKZ(UMk)9#xpe3qbjLB zgYyN^O5OKs>hp6arx9kr%OXAO+;m@JKQBP%5Z2C}DVHfwQ{s5-bmC!#eaDmJJkNe{ zXI+s2k<$8hKzMuSDKG~c5mL+HjVOP^|3ngoMi}RwWb1MoOWL1CyADLO zGax%kDOxq7;X{@98du_RcW^>5@I$|v=G64B08#8kJ#AVjv;IhxA%{&)iC>L2?<)ym z-rfRwu(CMV7l`(?p&QCmOsZC@vM@uDcni&Ij!;ABRLoD&X>YK;CUJ25`BwP2 zI9%#?`&I7hv*Ldy^&;vKvHO4P?RBfl{u_z0bsQ9Yn!3w8V99KPY4H>;Jq6~d#D2)k z%VZj3RI!f{?|qgJTTg;c7{_s`9I5yH8t@`Jl?|rKlM@fhVSQ79X}mHfgg}C|*;>j0 zrMa1FNpDE&q;4tAa$Lec?|CF)&}u9>&tFMP-G!gyg#)r*T;0+1zoMCQsM>PwX8+jo z@8D`({v%}^+1NKbBF|V4;`R<{rI{E^5H7+v+Nl} z<_u=;zprq~I~MrwG%#u|nlM!#(mQRRS^Y;A>xviuzmPTVjsJ;xy}Lc}Ri~VtHn}`v zp=|G%{qVdrUW5S}AoHB(%D<|x1ridn)Mg(U3c+cgLkR0`l($$qZ@p`V`WG|V%Pc4K zQqKiKcy^{YE;Lmd)pr9Aku+Po@zSiW_I&H;C{I#|(0Lx0^O{}dm*Kbmh3a?sQ*?hZ z_vF;dU5~^LYyw+Vajr~ z9dUq53FLuXpV)}!ZO^W|zs<(Q$yKo73c*IZp34V2>F{Z!bT)1&Pot;q3xCq+H6etR5dW4xK~xko zaZhDcA^beY|ujzTQ_sizFnkk&y%P&I2fSb)A(^P)@#@26xW#SyF{S1>ZAUjYi&r zPM?DK-twP#AEncWL(ezkX4QG4%_rI{F@aPxSEDf5(u=jY8yR}JAQs?CZSWO@xV~&q z=5o&9C*X@-O@W70lV(19$8R6G85Jd2c~zJQQrJKCW$(c~w0|#=y-}jf=#UZy0s9%( z1nH5EZ0AK(1jCI@S^Q3{6?>~~Eq0sff9KGU>`*8((%UnAwy_!fD?|WlQI7Eo%*Bh1 zcpuPx5UYVa_RZWQfHZHy)4w1GU6(2|2F6wnNOBkcO6^QWNIHUmm&F5|SWt_)X1}o? zN0hsWqW(^Rc(csKLhJ$4kF~?|n{&UCRSkpEA8DzH0%wr3fyK(%JCs&M?A-?iM%S3n za!myCRw^V+#)MwPNzOOo5Jj1%WI1#i=-{UKbS#lkR0;icL_kp55smRJ{V%~2M{@qL zwIv_*bANKhnsY9S!*OpFx1o2xeODRg#&Q-09?3fWd*+ht(&)8>Z*MtF+ntcr=|+)u z_|t2XC(xfVQAuu{mkBNS-8AEIiwiA$W$WGK23-sOf8BNoNIA~7wv9G|!D(I4 z+{N!|jPPZ^S;``efpvVOd-mJMBqT||Lf0={d5$~qpFEu0C`f9GKqnh(Se$2OJn`B4 zdfmBJrdp0$$*?4f#Be@jC)vxY1%L&U+FAFiwX+Ch#DGO4Slc4UM*pBeK_38j;B)G5 zLU1n7#NJZu<7%ZQslg=qR2crmQ8gzuKE0Y*w0zZVB$Fm@kJyxS4-^hQ0v(0CpMmXC znvX~j1dKE-)$dJ~lIvKytoLD;b0yZ?6x2C5K;`cZxGj?=-x}NuECUaTE`Uuf8S1;4 zS{yCwv8{aonvBFa3%v$B&MUd)zk-H2LisY|zZCwl0k*458lP1C7h^u;&mLlrV^ByD zoqu?ND|vg=AQAn5^-VvJAI$u- zrCs$03z5D7>2dKK-^CMtV4WQ~QMWWYic3HSs4kkb@+T=08BQ|5y`U^(k|fG19@vv% z&^`WuBM`bMRueB_SmCkwpu><>qaf0w^}27gHjaFP#4a>tAdNfEZ9IQjal;Ws^kIXc z&HE|S?edoQQx*#GBZm?+PSc-7YqfDNC00|;mGmg}TDZ-+(Q?(FJk*$p^E`lUN9S7K zDw(do*xC{hT=4;8#fFh%MetpY1PRyH?by*ubHo$;3`e;m(TyXOqLULP6_Z3lOXXKi zm5)0nIvYT-abFw;X?(FAFYZ{1@WDya-G1i{UiM`LBKAaZ? zQns3x`N5mbE2)2*>#BBP zaNKOAHXV-sex;36yhXD-XGZJ+Dk7e$_o90pS1GzK!4W-kJbJCrS$M` z!Pm_j%?+Qd6{5Z*#IbMdsKR9L(U<*2HA`nuhd5CGeJ<|gt>QTAhScjnQbdQ7J{tdo zif0hBo#*zFqMIw>5sZj5VM}1|C%z^qRzj5I+JOPBeSoW7Pb7L!T3nB6OBBMhB{9i5 zdQ=4Ve6$98(34`Huwfzlx?^&)^EN;sLZ5o2NyeNX%Qod}{$%em#c8bupwqWOi*(~Qf> z@+kqTbxE?`El2qd1630%I@e|tx469%T1VE~b9L4D=V}rE?|*p8hTUe#?{)VtyCzJW zo2&yTteCrt5C89o>|74I{tox$ejXSSWN*>ctbG1g>gK%c(q(Gz(9-hnUiHWRj!SJg1{lZ&YJ-ke@~C+fmCGEq?cK+Owq*w z(v3gk*xg4p*IR_-nsm$8XV7|0bN>sF(YRMrzb6jX;`@|yMyC_jQl+6J(qJ|T09&4K z22W)tsP^k$h>tS6HL3 zHnAp*k-gaHaifMye!kr7$4I9HD|_?ZjFVY@%cz2%CPxV@VTl)hAT#sLJ(#}}iN$E( zlO>;Z&ju>Vc;l^;7-ZQd)p}k7lL@r$vSI+A)=3!P&vJvL&Olz`Ujyg1GNlZ)88W7y z1`j#T|5aL0{S1DhwU%P@gq?HXv6fCMbKG1vv+>Pc8lucB8j@&=7ZM#*xss+4&awf} zdB)C=shy>)Op8%PA9>5{J^8NX9(T~YPoUIWHhc!_lU%9TVM!Pl&o(=kGGd8I#3C@& zUdkt^PZ59viS(m1JuMcVKf_D>;)Ft@q;y*frqu@{N-8Q2SE;;-0S8GA z-mTDa6K|<2Ls!i?e`8ho)Q=;9d6nHBZ{D>5l3iUXAf(*Cc2vjb)6<1&t?C@|kFG6q zgKT(OmyDb{UB7Ff;1@49qMAoYN^A!s@QHoOzV_zERo0U@hs1-q3>o*#xqp%T5Kua_ zy0WoO+fUK)d%(Y<)6(XPuAtNZFfEchwM%5w+!Wa#x697dK6Di;ZCH>2sL$cm`{C`@dY)ey=S+kQx;89YGS;&ZD=|ojN z$TuZPiklrckz{Kkl8O7FYZkp=Y~t{-vZylbn_03TTkdgHWROCz(<{$URNeyC6;&nk zD)%yNy}Ci#ez@su)78u(f_j4x7oTyn)OHCWDriY31KOJn6OFO$(cn-v7`p0M6XaG;qMo#w7~f>~)3_E)@^aM8&LBGz zsV6*MZ|2Ad@LPjl61gOWz16*XGLmRu8Pkd@3l@pnGZ&BRemHenGnG1AoBYx2n_2%Bw{P(kmnIf6#oS zw*)lCbo9FhQmg$8pquWPBuD1cJK&IfMm9mXD4_g+sh}krS=G?+$j_lxUbsxXmsE{t zSa46J_YoAo-nc^w{zX^ukdzJ7>uWbSedW-?e=wp6Q#^Tyf%44{jRG_20yT|O78eQ( zQzU@O)p?q*?q@Jfg-~qviXUc>mBX>Hzh%{OPMeA+&5^0HC05hOL_+ifeMdfmw?d4q zV&uNg@4m^@g@CcvK(s|)VTmaBcm&5hHgTofkq1VPF~}j+9Whr&6c$=jWhL8ku$8Ly4Z`tr7HV8=>D(Box}39xGl{!0>63e zKImL zoOe{jgj>4Z13EQ@y-AU@l;-{HEJ`ksuJJHd_;>By$S|h|7UEByAIagIt#W+C@6&M( z+?@ik|49_gW#=cVBog?R&Nq6w>d`C_(HK-p_@SjN%9X zqwp9RovuyKU~4VrbNJc0^{qrOQ}*Qj&KK^QUEVFni6ozkWqwY`#N>1!!We6%I>?ua z3BUy<<-bXu;zGm*Y}8TErN9EebWX--%5bc>onvG_5sZKnXG+KpAL^JktGA`&F~-GD zH{6Z8y1JID#?50ScN+ygQG^^cZF%j-L;{l1ktBlB5CaN-NqEF!vDl+dm(CmNHd61W zF?V0TJClceI1wC_vf^RC=?y&RB?P^Gbu>RZ*{T?1C`xYp@W1&xM+3fSrwYDlG^11w z3yb=+?{8R-`14PpKjEKsujJ2EUK7vJk}9c;oia~0*7@U_4$3`R(P_TD639{Y)Gp%@ z@?79w!N&BWlao^lCyr6i&YXqTgWa$t%6PI4(?4-hzk?`Wzf58#zMmVOP z9UoGVlM~`5%?wE@_5P~wWI?9E!R*QUU>@jV#NCh9)OVWPqSj^dVA^l(beYgFdfXDY zPUW-nry=K?`8Tdgl1qQqGM^b+z=psDshq`#;!!FuBI z$bt``J{EZmXm67@cpaZwhPAz!m2xM!ZG(ZHkJWnFQxSOvQVs1El2YKFtjOjOc{^fe zEImiPp*GlVJ3~INK3lOXzKW{|;OT!Epa6ps5Y*WTEv#N|8k6(JXti8C$=Ed3YE7eO zG&KMsyC2Whr>?3uJ^?RtdX9#n%_j%JD5_aW?@q1b=@8&_K{jDP4lUDX27V&L9*kdI z#oo?54-;Tzg&;aRt&}xxd~I;LN`K4@%sVF#QVf%NL!|aFAYjk9WY+tC4u{&ZbtK)7C1*r9<*8|VAmVVLxj1C(K2?;A zQv1^IMZG_2Va+a)lqP#&p^WeMZ%E8v_rFrK1G@~r|2iiSBG^1LzKRZ=1SqtEy?(s4 z^F#tcy=6gQKI98~Xdk(e*k*~J<^{fR`stQ-U4SShLJGh-5j)m7`#j5YKbe1xZo5tGbo>2%h-6vsTe zH#*=&xlYam*HE)uhJ0)RcgnYUl?qmNBBHxQ*54%(2Xl-2F`O7hSRml0akt2cddAH` zV`P*vRbWMSTXbc~lb)T-nh#CC`GUJpU*iupR~Pq$x$K@5(UH}Bf3EHyq!v?&59pJA zl^MI0cA$KHcunP%BQ6{YGApz%F zH%y5oEn^zIzm!M$n4x4Teu85|PlX;l*3(%OWRvSJN>Gv`$}6gD;0#0bD@4WgfO0?+ zLs>3rb7R`YI@L%JQ;1drd|)q%2uk8r@2aGP^Z|9YjBiK7S=EL1D{C})#gWoxy~~!{ zLo&f_?&0VXLrE&9cD9Y=v0I}`jP`<7eTE~|1ZL(`WOXIpdUC9BwC)R$5%plbP`>uA z(J2fC3#yfvQ9RbV1e+>D3&>9=i=G{T2Np_vEjNos$vAKpfcw$?kIJibpNB4T&-S4&nqJcMvtoEEu)LA*cH2)Qs{b^httZT z8k7L?4xr_I*HAAEu?6j!=9x!NeyNCeQti!inj+M088G1$b|&2&uW>@V1Wquy))L{z z(%{rkRp0D)s)4%~$}QsLT9rblb!g|h*thXEmBo|=3jx>@!?Ba>Vp=SRb+iHA3i3U` z7V|5A@x(cFhu-{`D8K`<=N(=*dTrzOi*q23~R(m=jgsW)8wGX z<`^mjw^*HSd347^D)45a;^fctsY8ag9dX&w+J7o#`G#2oDlLgAFFaojq+Ef{W&h$fP-dGrH^#E2H_mD>po0Z1L9YJPPWcpBZrw7)RzSkeeQ=yWs5}^C z@OE*UUh>kedo{V_KDX6YpAk;811B*eMQBjok2g<^H8A&I#n{5%eEGP2JZ@2Qn*Y+D z?H5A$L*5?GM&RkDXT!2RfX9Rkc<5g zI;wF(+WD}102D@yxO1wvQK_b>nSvW7h>hBB-z=A@Z{gn6(zUXAJeDW;dB31yxXG@W zNum_EdHSoC2}#=;Ne9BBEZxQQNIdzbtZ}?O%L8Q|w%Rm>Y%W8qL-XoIG)X-)Zn!IGiEtKZV+nx;V$_7<@wBUV6Uz3 zF{aNV7DPvidtY%K$)vc zDsh!nhD+JmCskazKgi+9p--?BHbXnDWEM>G<`4RdV zGNZJF5_1I3B)y#4U^V;u9J-70$AbkxR@>Sr2-Q#&@%_rP)KX^p!omL3QlfD1VySC< znAl+S#Gh`XAk6jA^!U=I%eE&xlXGr!q>@Lb)_25qPBZ*Mi>bpuO(xA5vKff}3=66Z z=1)pWj~i`kd>wXK5-8i$xO*W=bwkc*zd6q)gfcu=gZZU^^DrcDgH^Esa~ymidiq8orgcA_`6w{4>!oUa#Bnp| z6N!tx*pRj=-e}|X4}Ei?%v;zKl9bO! ztG}bIOFrOl1$&|aNe}LjGMiVuI$$25v7&F0)(V8&OMKVJr<_TC&inbK(RXe`ChiSU zxZHu0eh%js%>P{YF}rO2qVnfb#Ph`g{c+Y775-;&I#?JiQ>iO^rbwkJb>w_V#(mSK zR@vIWe>)#LX!@=Q#7wky^!CkGY^!WIWYdKa43jZanlgt=276XABL%IhH4?kWBEkC< z#G}XXz0`P|y@aqpI%VdFuyP9!fL^7z`P-bFoW6SNb|DRIPKlK>UU^(pi*s*nQuhK? zo*GB)XHs1){h8#Q!X(BSN5FdJGYs400TUvy2wyZSYG&(J+d3G*=uLfGbx z-?#d)BryHBN%yb3M~na+c~_EjSu@#>@vmkx7HRrs4mqjs>|2;9y3$8({?fpuxKs9t zk}IyOyA0iPzNs6bU`8F;$!l^d!w-ehCF<*EO%qSF@q=se6f#xK2w&2-4l=8B%3kW- zue!0*03slGObALnqR%Oj>}q(}6hm(P05^Evg3O3ur zcN0>s@y8y6S+zZeDZT~RIE}##<3AJLS#SUNz*Pb;<|6z93(7ZCUFa&QAvdwL z30rhjQjXE~zseI)$Dfg_i(=?+AmG(F7Ku=mH_{0S zDEX>yCw#nB2jv_FZX)G3>XsrCEwSzXNsBqRJ%$_#W zHrx<67uZD_W5Nu?ML?^8+pPJZYcZkoU4^S6FA3($Uv*mSbm|c;9sx(~aUI!FGS5Y) zUF5H92*D=jU;AztsPZJ~R#Yu2=Ks=3Yh?(%i?FGLpwYGypWa8;+CGbm?UoA&F|)H9 zzRSjqUkG)tVnrW91+vWL%5sBGCMwGnjpl8+a@$%nd^2vNUAt@izcBH?XshnXSH;>f zI(7eD2h6c%_O2!`WYx9LOwetfe)h1h(I#E)jk3#F7}wF(d0`+pWKwi)0# za&!;QvTJ_pLT3Mi%pBhLIo}9*J7ky0IZt^#P%&lqM?cVGdFM1HN+x~~$dbW@BuTNZ zq%#xWKC7+qlKVOKGgV?gsPVXm{9p%H`Wv^~ls&lnr*0o9z%R&#EU4_W5fDh|PbQkz z`Tk#lPA6Qt!U6baS%pB}q99hDDyqA>#acv9{P`#AX)Y`6pTmTAvy?6+L67IhGFwY$ z3DMi}!SVFqA&dMX?Lza5mIJ<^zEFPqi+cz^eu)pGUqCmuY-#~z0=!XY4E z^kAv;&h^D=PqX5}{m$Mf@H}rlt$#q^F-?HE#hm+mpG7!`s6e4LhmeVTd_a@1YP=m5 zdw<}53dGKdDy{|~zPv|M+?&!F1uFq~bioG#wOkHz#*CNXb5rwPTC^_)u2C?sa(L)b zwgdQ+$L;o>tTa@M)zn=6MDk>iu9(Ug%xa@fTnz+cX-;>+CS*NB^>(B~bE7|W0V$M? znns#Lp=AtK17YPIL9)$I^~6qg|AdL(;vc)li1w-!+_LNjbm9LGbeNlGt7IiFGj;p3 zG95Y{`oy4xGnkVAzhWHC>#9Xo2`DRxCu95ZG7o-Bd&E##nW9-~kIa&wKm3XtQ=uZ@ z@fM}Re;*^<84EoSVAS5yN;icc_u>uh;gHc;sOSSoo)2F?;gL;P+g3zD7G?b?(RWH5Xi@&L}z9eO8K?&cMl(F0e&jI@;em3sg@Y?B!kj zr4SdQkkL+X`cf{DZnY1e5%3xhdeNL{C#Bt5)A34HDHD_p$ZUSdmcMTGN7=Tq}#pRnA_wM&^yYf{-|(Vi1l_^|FlGj z_(uVNJ6${M1&ZwR&k!=b%vvSCXWfMFw*8762-YwV4_bg^BC||y{B%Eyf{1P)wwZ)# zPaqnhcW9SdK<02GJWAzJn)HH@Cm+kk-)e?x3xfM6n{fhh z3j2H_>D>o1?8x@DW6hd1Q0>(j^-XN|Wpn1q1%1%kd=e3a5J}*Xp1)7#b5eBZ%r_aT z8~t`*qoK~VbLHm%y~}G|!o>N*ke0$i` ztJCvJJfm6+M=O!bzM%bd>Gsh}oLZ0;4%PrH6B5F8tqkLJJ3?AX;CSNO9z*{Pv0(IU zT&J-2w`aU^D2B%4hYyP0@pXk4Fz`e=UX8n|_dUE_%44#{k;coak}1^{;Nzt8^JDBz zzXH-EEg9+Xo=~-l>rQ?n6*eWBsR82+=ACSi2ps)YRcCWp4f?H&tFnMKv1>9+|0Jj!SwM1J-^%}6KBUTG1JfE&&6j>NAX;7@nOE7#MbIb`?(v^EsIhawhE9f z)kJ+o_|gS3tWg!07PoC;eUPuHL6B{bpbvKc>ZhvQDX)FepZWpl+GM(>1WU;lC_Qjz z%a!NX{2Cm-`jLMe;jNFEsg!{piR&9DexX8W@Je zDfvPOa4m#g3n9;Xd^1<`xatCm01cJ6P3;cZiUSk++2`kdkny%l1)hYM zFJJD62i`PFU2avJ3`AE#b#nyR97|poG;=LNo?)HKFoedct45J zv#?Y{lK)rEy{_48`FGj!3>r%KgRDhzotu$_e@~SqGz)ZcRE`ry^MY<7iTc{k2A|6s z1VXzqUhX$4#U0z5LUSXuUagRf#St&Cacmh#alcNy;k$-e8aq7P`x{pe3J}_d#u);A zs{$y1n$r^f0#KBc^dlkC=k!2cn>^S1q3@h%GPm7?BiV{0Q?U1vu-SGtS@JsBS$}xi zLUoTAASUUE;9YT=Yl0fx?ikKMK2$RUf^4oe@f{2c*o)jzq|b(aPxbLzx$*4C>Y!&gkSp$^_{N4L_0XK6*W~o|PEm31cE4j?*b3&D@_er~ zSZ29{R+U6p!IG67_8cgn>~DxQiWYRf)*eVlDeh)X0J$}msF+Fr-%pYhdac_J3`g9O*VucJ!OOVp9XZFq zyB{B7)aLJpYK89Jz_yUZ3o6V2i(U+3sZ_R7#`X$=+W(tp}eHmZoiMN;bEKa{Owe zPXBXOpx#cv4K67(D>m7)_8TbOrHD=R6!7`{o0DVk)q~PCOT0?o-~>?C=YU%{3URc` ze4I&E+XGY()BAtS@+WuxfJUES;1}?@?;tv=e@x33SFmPrNzdD?wt|5U4JOZCZO7+F?+LomcaIdVbo_z1}mM$r!Dta$t}b9;Mzfz^xC>;}RsSd$FM@@sHRk-cb@*+VYI z9f@YRBq;z((ns!Ks$QBM zhneHH_it?!b4m`0=9MHdI);LRVV*NT>lQ1|7n}9m=Od~+rQU3mjkiXWAUP;f!EoDg z{a41xdB&;ZK9(g_lPg(eH;^QPQ<&M= z1m|dHp4O{w>LMUwM$0USu)$X$MD!Mbwj@W42#tj@ydQj zR$jL4C7vWTE{u(DtSJV@{7#Fd!{T%r)EODy2q_-N|KxvnE zsM9``d6IN4GTvYRjG}Kz%`M$MU@{68Y@;q%E<;*2^^+^9v+>0vE4+lT?+B~tYN|{b z3G8!9s%V7O&6m8WI;MEMgv}(SXx#u?ak@d#D~Gw?CY-!IeZM`D=o&aCbL_zmpcOIF zRI6ZzszAeALe#H&frwu_uz=YrUfceQ5>(k?(UMba`L{u}S4M*Y4atI>@6rC0(qUZ$>=ci5{n}qZ+!TcLICg<18@Z2UfSLa@YJ6*77@z{(6>$cMHZN`;cuX z*~hmCyMm0~B1+rJqCxmH7|~L-i|HNJ``y1enJR$rjh(?Zb*B?KRNB&6jR`L%ffEs| zIicbQJ0;vj$8I9el$?{ow%nZL*4(F7A545j_0>+$R>ZWQq_+8Hc|iuxS0{S~Nl*J@ z`OkDtL5R>}m|p-wg2rNU?TQ(6g1nrN_5v(@SR`vr{|(qN8kCyK zTv*tzO7G1X(Tl)Aog9e*zD5CAS?6?;^ML+98p2$yxJQCITVtZ5JE5O5ImEppai)Lr z($kij;oc`MMcC_Ch6o{JpNO+a~>l-4_u$UAl^)ZhWa(7qkP^wALZn*Ep#`e zh&nTXuDckW6LBNX{!5I1Qe^dhmL@fFI5g9#Ng)1js`}t9Gh4FZzy3SFf|&3;u$Dis z^=?+uyFJaUxBF`9s&ZwCtXE3yavz`FK}nYVfY@Iw#|aHp_ji4d`1pqZS(6j58|do$ zbkikfUe*@m(m%R!^kZg6rAl8kA5!aldSb?*|9lu*&WZQM3OkVlF1yw5?9ZzrxPysA zk6CV0PeAyndjmiGqFBebZbDsgAA|=>up^EK^0?4X&Z-Ss-)x-z4A&bnnTJs z;2$zyA+n1t>d*;UJu|V(bkm!8X7RvP$2ymVa0)ZVZ;Vz?+z@Z3LFfw>k(5CtCo~99 zCFMHt`Iu?&w47zF^v|#mMvfH*;~&ZM0&kg7U%GhzQ;4l0N{po$hmF@O4IH)?KptaJ zY0YWZQkH@3GUqOdqFZ^S3cr}Xtg2ckaX+9CU`|O%P?e`$z9=pf@Wg+6a43$;VDxR? znQ3r_&naDq2TS{#3`TF;>OtKiPQ(cY22ikx3GO1`NE>?Pv6mr9zQYjj0cZ8Ghv0)B zi5NX39&Yyj}<@?Tdm04g_Mu5z8?dr-5F+LD&?@Gr*aR|X;ye)mDH0e$@f)CCrsjI>8 z!|Q$5e}{oLgpacj;o5DtG?lVQTwRJ;^cUOGwTs}L6@_+>oz8%R36-(lXK|D(BTLk* zD=6c}M#yEMv!B+ix4)E=Ry_n7mp6{+?U>-c<}!&@WV5Ad1SHW*Xa_*3EZ}%Qq{ceO zgx`f!^qZk2(eUJqx#$@fmTfvf7T+c^&OqW1)WBC9OqKxMcp6u|I@WWAq6pCE2iAxx z`@I?8ytl4~3xeweijtTsO&*%qWEfmuK+Emq=09QTp8T*$qaP-pDLB8g~;#Zzdsy6g#$qfrcg>dSynmBPYgVMSW`1!$-*=iB*}`m&BDeKrES-z1ethGno91QDj}` z@pCQKV~~n*@+ye9Lx6RDLB~d47PoM(GHd@9m>~%=ot~VcpQa1{+xhVo!q4$xLX~3$ z(`_}9t!feqlA{W$=@IM!rR`m{aiWQlR?qsH$`UtEtWi|aTgqr5PBg~6x{KL<(;L)Z zMpkPXt*d%^Kv^t5p79Gm#qT+lZC;^eXU*)gQhe`Q$o>P5@M8y!6L-zs9e9rB9Agy} z#p*17Nzs_s#;{5lsm&oy^b;=`X!<;bS#CQj;SK-#8^%~^YEoE?*E{G84616cxxP93 zltvH8X1?Oe0=@XPOW%S#4@c_6N`68^*u6A?G;gi3v2mL{}b^zv0|1y$P*_swaJ&$-H zDSL@Mz)U0MQS83e$7#Q1kC8+2Yg}J!0XK`{Zr450+i7|;oQ%HPrGG9$jbb@zj}CLv z4?8FMk#l_k#LMkOthWD;qVo=CyKkfTFJje7r&*(~YO6N2Nwj@BjFwWwUM00htRO^H zJuOAGX3e5nV(%T)s93f4CWujjAi|sHuUxsVw>hv-iT|O=3;guUYZ#XD_c{eTUuOFElwcT5!as3ke`4&L%B#KCUi5#q44$A5+}EI zsNqbueB*QC#AZbab5}Vo&7`mTev^t7wprcS=Q&CM#qCvF*w5J;)2^C12u2d#wFJa#vF?xukChN}nIlV%=`5V)T_ z+;9w2UemZ@4Wk6k_g^CDJ(}ZO-A`_ji)d_GI)vFVR@n2;qHl+v>7!M4O}O2|PG>I# zE6|jZbh&|TRthCJUwtc>)XB{$bT_DnMkLvdPJTXg&M*EHr=XkvGK77%UG3ZxlKR%s z;LQ4goSjM{6StM`7cG(O6weSG7dN6W^^>tB>XAUmsV7DMmgna@t@!R=A#@(mN>-W( zX~X=NKcQ0XEzO@btTm;RxE!D4!lL3fv{)iohM=tc#)Qm$|BUDYf{nMiMa-lTJUXyA zM{Pl#0i^r=2?Nl)?S?5B$*=v}OF$lGd;y@q0{{aDex1y1bk_|NC3>e~S)`}*jYbs@ zEbNhHzV{%~b9);p-U-I93`lk@5bY3L&|A=%+8Wax=8MciYgh&qVn_}WvS0l$_!)83 z6F>6BEB6kcsUO*2Dx%=Tg1g zGE?uROKC+OwJ`~HTNGv}ZSN4d-JMm*73Vmeb1LE7SMTL39`-v6ztTrqVgTww=pb&BL8^kQyi7MF z3L&H{>Jb=aYagxO5KXO1W6V8nq~hV;MX!CGjzsMUq$JJ&0hNGHD7j7cd$s9s|9ZO`a$71E6voOi@k@5JmxLdc{? z)I*``d&fZnw4y$qo3!Y+EM;~`*AA`m3Ck|Uq|?V2%hh-37`P*m(NS8}lwQ)@1m%kv z4P|xEfE~7vuf1&vnGTE$nWg)mBT`OIzo$>TK0SWsV}6i#^;Gp)BKgLb47c*%xfVlO$WaOj zF+LytMOnDkK|)tDoi92xuE);6LLR+NSn?gjkI|J-ag>b&!Lz>NyVCHe&O&$hMQVK-(6uUcP-{rJ z!SK6h!RzWkuAAL>W^r2C;e^TLHz~OIregz02C%`{q;NFEB?~ITJAvls7O+mR4rt~h z?{&LaL#D*qA{a)mk=Zmmc=ARX3OQPTH-)JH6VSeqaLBOsY0sfuuXECIImZyM+@*`> zG0#P>Iq_gW*~qj1JAi%X*i5VZW?=oOAXvjNDoZQZi-TYMRVFlll?oWy7P&yZEm9ez z5jQ>^v=o+_ux>h9)bv&cD^{F+xUZ;9`-ie3-U0sDu1{OpB#9@{TrwMt)vm30RTNa( zVKj0NS6utk1`TU*;upHTt(|PJ`lHatnBDe&{E?Q+Suu>_P68VDHF6~|_br6y?`F!) z_xa50q}hQ-6cX4E>7?!47ojOWU%6}TkzM|p;6b`qa(;ED@6h#wBgcbc&aOrhm4)HS zGG@rIH1EENav(=TYuMh+*=L(JAE9viLJ5OaK0EdPgh{T%hQ1Z|{`<7pV-00-kwq__ z%q!!OryPKH0zHW3J(%&=WF`{;f*@-do(&x)J>kDXV8uoHVu)*e^8(w^r`2}x#HoL^t99~LCU21wzjTMPm)&jm>@T0ff4=}PyFfO~L0dBC z%ZRjOZEG#e<9Ri3ZOs_e{dEd5Bx>ZBp@kG;28l*L8!1Q0mOPu{A0v9NJ8V27(m!7MU2gK=sjWx`|(m3N*B?x=_goZC#TJ+k=IWINJt{bAf@2kY9}AXhN!zPba;_TZs#m z^|5bB2?^N|uzty07RIY@)w@Yq-w2L61WwkHD7*>1x3jBrv2*L}hJtgz>Y+rIZObPg znLB1fJZ%Fj_`_+s*Nh64goHj)bZF$W-t2zfLU;Ek>O{ zb-_iQ5(LKGOeK9NZ+82wf$?V z%OeHGz3@?5kJ#2P>emf1Y))_7-4TLlPy8fAPtewI$xU#-P2MqY=nvPgI`vdePEPue zRkchY@jp=McsC{_wc(RNu9goLV_%xUbC%~t(?or=r3%Z5HcRJH4eajbQrx!g|E#R^ z(`TvVS5(D?!X&^y=Q5 zTy=4P?#cqApC7quyHUcRx*oeDhNl(m-E;qA-IO+?j$FZ`%V!d_3TOS;H_gvx<12e5 zkQbr?=Z)%xMO-1QZ~E>ES!aSly;P~4C#LUIN_0jG6YRCg!D3diCyQ^q@sHLyJ>S2K zuME&u;Z1Kqz36K^%W0r2#w>p%gouyiK3aDY6nw2NxWsbp#|7MlSW&tZO!{@){(Cj) ziyper;a%HH?BpLcFGbQQT0d_R`qL5(@@C`Y5VN1Px%z*PI47=*j+aC|*X@4k@W;HO zZ`DgSkFjSOh_(m5-%HcyYqH$i{@x=?cDC}A?zQ9|@!#XiZ&TGn9!px(-7&Be)-N`)N7);?5iOY}ecUjxZ7`Z~XZ;M) z_ODvakuT-+GxJ|cc{wMy3EQtm+OSNnN?-abu(f{tcpFw!eO-rSs827Up0B2N^{(ig zkVw3r3Nz?d{G+hJCHuCL7*!*j-6f@!tJ>9SAUMLqf(>932W^L8B5ZJBTmCOX?r=3{ zguo8$m`(Ox9iC35qtlz3@wsvpvC@bBzc(y?BX%>_z*I} z7fIG|PU>$jIOR6%39H^9jAduUDDC|t837_sr}mnTSNC2|DX`ucF3}}gWmkf>?bLpi z-=cDi+;LO?)A zXwAhBti`uW>A5?OJ@n0w8snQG6b4`of8_PVg4$@TZ_X|F{n+C&kaYDBXTdCa5*%T_ zNZ#GA2?~H0H|Lu zeO}ivx@Oy(uIq^2NZv7Nj|)O9V$SgA;KvJRtG#?2t)@QGgWIEJ`v3wcGd)o@3Aa}h z;v4MQv&gnK0s;@-fK&y<>00Suj5eYC@KA7PMBJ|jPl$jmZGI$O1k;ORzr)Am~`UV$5b6GXo7!Ci(IJVw)9LxMi zi2q~pRjvw{8=H@KyiKFd5NN0*;IUcHi|iD6;wyvCZL%q5CcPIIMCnT6<6 z?Uzb}H&S2MYuF)&G(2(6nCQON)D{<&h#rx7LCH5rZ6qV{>K=*lb8r7gM+^9TTb+>e zsyNt&1mEFxfO$~j4mBR@6M92*s@UK_vs^usQ&`RBHfj`$6_l?BtJV{n78U|tZGXum~va)dkaD<<*(fiUS?5=M~Vy1t+fRAr;GXIW>2sFxn>r zeD9_d&b3n7J@y+?aT9Rbf3-uLV@bE4a#jPQ4&@Kr+v_Sj=h#=jLTxX_ksOiV(E&RzowlS# z5XG!qlH4Bg0T$W^k1jR;wxNHGKy=pdot3hP#dD9={m3Y_an;_tAI~}F>C;ZjnrhQL06^b`=B?w!;vZt>JWo`>7~>*y8QR4Xg9iRy0dO(< zCcd2jEunM%;NThZ-0W^b?ugS@`(~p&;WRg0BgN{RDPpn@Y|)btDGw9U0C28_U_YE| zFWBX^>*$95Por1Q$nqXS$GwGrx6?P*>W5@~9KTlY%qA9olyFSM4@z9iO|yt|kQD26 zd7L0$ls~4JaV&*eHJ*zngi!fw1I{X@CuZf=)|X=7cGk@?^u*U&M)**@yO`#Bzil2N z=D)vc(o!Q0=I@w)D=K#HYMo9^4Ix*g2A*5gdY_@wsw2IeU0!y`2fO%oV1dQ&J_=T` z>*g)ks;u@hBzUtB2q=jZn@@~k%_>F9r`4P6IjjFh9r|1^LAZ8KlD1vil(v^_Le77j zc>DZ=6O{C$xcS9I05O-BphdcnAwo{W?tzeQ%^|eU>fxvU!;eL(Mj{B-N6CNC@}(t0 z562{bM{U=BA{xK4EXL!-$|@^`{dQ&}=SO0euguK33GO@$x#LY>U1qJose4?=u<#I7 zE25nAOpuquAkbJyUy#ra+QT$GXb-WsftT8#4EL{`pUs^MpC9#y+_tk*eC2hTPzli> z85;wy&`yss^=&6#u$%yTUvj|5Om}{o$HjGj%h@k6k85oJuMk!+wkUBc`acXFY2b5? zwva4Z+Vu@wn=2~Zwf69&>_`af^_Q320!N!RqnRp?8>olqv!qrOlFZS^Hbh0=vFgJw zX8UsdTIUYRun=IvqMr6As+t>nvsYLla_&HO6^!`F!Mv`Iw>GYEH7?5?4G?yZPslGU z>f8WKQAX1YHIUVrH_$rBWpGlY*(%T)_or(yBZ9S*QAtr%EPV5g$zJQpTqn71Z!YHb ze{%T_?M*e0HMp=H@`=_A-w?j2kqChu3>$z+Y#;c(aJKrYWv}ChbYU~qL1e!WvL6_K zt3B-|wMNY*V=b(iY$HgZaO?72F7_tKs7k{ zoXbYQ|BdPwEBYsq^VapNWgOhb@~PnkZeS?SNuF@PXFK26lM}#;5 zAt3djGGThw%rDkhU20`BHEO!fK}b6e!Az^Vya{5=;`HrF&xgSGYPjWKHGQ zE&)t>-)%U{F_tC&yrXE(3y51MtIlxzjSb@ktzmYrzZ#b%S7-zSpB;8tUu!N6sJMk5 zOtc)8{4-j}wSSDnYrr}{*s=H1^x$>Fg4uX!TwHk*12g^bs|0FARJjV{@=F=w8%9~D z3HvQo%);nsN~i+nF~`Qx31)Dupor;MQBfr>Ib+aEBS<2R710A%Le1pL7%orD%F*85elD}igkcfdh(Z|pv< zBaKNwXYzsUGc!c7#MrBV#k!X8G>6`4aCv{JL-lt%tTfb6RZ%gj(cM#z;Al)5 zcEa8!7Hxqmd6>iH@A3C1gq;Cdn7=)B->Y<0H>Ju?5JXc&zjF9L;tmILRna^`2{Pd6 zKb$Mo3j9yIQWq7Hc*45R!U7?4+nyQ#P1@B$qC2FGCZ}YM;p11 z$~itv%_cy(04-&^;oelBgzmhwdg2P^3xME=^9dZ9H&Ty~Qz^2w`LjBagS0FXpGppy2zm4R^WvU`eINcR2JbU|FmKEv2KdiDTle2JE1>fCh{oh^UD+I=8w65e| zWtE^dTE%ykUuBbnh+V(upmOmh;_%s%{+-9wulo^`3nslalL1Zm086s(*s=lv5!k*O zh7fiOFReS;RxK7hp?tYJg2*+icH<%8c5W;nzR_SD<~KtN6zf^Ls_Fyehi$_sj~3dk zB2_)mD414fjh{Q)n!B~V^U}&z#P#2oKLs8KIrf3+uVkMh)I2W1`u2ntSiOUF@GD-2 zgD_cH+qb(@?#-@N(|_l(-t)=PwyPPnXDe1`?R__dBtwoq_aXnAE!98x|6W02m@1;_ znp-PAFGpIn?PqsK@V-3ES!ra94;&AOHqb|RR?7U)iCa8wV9ee16BZQ+w~x+OE%H|` z&bb#NXv{))OUws+>ajTUHbiHS6F^0PnCXH@e+B2~y1VoD>rRCYjAbKvdd*}@AZx`m zRCsM{*e~N?G0+9eQH)(+>S`qxZYXE6GG{Mv(3C^`wj1Z!BEx(01CR_XIiV zi7Owlg_8LEsy`BjIkNJiTj3_R_VNK6fe} z;=`u#yymbma3>voMp<6c?TMSPxMnm^5`6f(Gh`#|g~O%4EnqN^#y20cvOPo5|8tg( z-la2Ct=jwitGNS5K6Vgk<;2Tf%ZDvx?d1w#%8dplETjvN9l5!Kla$ z(0d?b%^u?go}YVbm3`pa(H$>dhNkO$q262hRDQxW`e#@LvU9Ow+^8>-5sj?{m;rg7Eu zlr)f0@3(6P-~K9)IA(eJ@pRi57B_dkZM?Uq-QQK55nw)xB1oWiXb=%qPOyvIM7G-7 zA8JmZ)u?td(w)sS%_W?lZl4=lhEN%fX*&uLXJ;Z~|Eb}%7OmR}_ciYr>HY|AdRuX& zE9{Y{$jZlRqi9bc)};t6vie@A?jevFvGrhFs_2LL%g#_AqL>T5 z60y;r-OtrcP=~)$I6;4CW$Hfi{U3XZ>dyCC!HyA0a#Q1-v)I=LQ>(LM2;;d3A!u-j zP;@|0Mw@f&?Jw=l0x*XY>w&b6PXZl*_%LYGoP*G!$x_L)Vt>m$={fVlrXOru{^Vvj zU(WQeqZ}H?oD$9-Jl@soq8F319=?qJm7h z4_zs;yZgE{S&DFkUhfkz;%g+Xdbrg-kFrpV#ArytH^C1;M{O)$L&ehagE=L*ac@^@ z!`EMg6|>zkVahisq${pqH_A6o%rQ;+%wOmnm@Q^z3IU7?Qsl-GYw%mciEOW@)q~Q}j8nW=ZrIDq%&<28K4Pq?$)^`2&vPhf#TA7Ku18&(;~ z#>V)1B40K3%i*Sz>xSBTU6Kf_u{qfODdCQ=u_Sx)%A>>Z(60du=CX;yszk3qzoGei z9W3UZrhKOr(+bYW9FVSzTk|`dp@HyNPU_c0*DdGz7oRpyzkIJfrmM)F`&vit&HZ`! z>1@l%44wn_qW@r)lu^;(5I<1lT*jJNy<%<;t^rk)hVXC+NgR7pQv3VX1M{|ZEnwLG z1zS$8W?W3vCB@$ya90!5MvH~`f!iR=+MHi($!u#Kdef4CG^WHRCzr^k{t-YlWCcDX zbCui(3@ZioBnK{T$>Srmmkh(!x_PU!mP{&9bpb0M_?G(K^-0*7mNvQ!6jl9JMm#SF zMBtE2waG@*3y!I=1!LC8t*mfM;fpfQ5=aN;E<4#}^u&GXJ+!<{mC zuK1XuQ)SZ1-OM@*knf3BSh#IziKXZU+N`R2Og?Q#7=E5GTrpRpJ3F8faKh$Ol3SG3 zCq{ZY7da_OYME$fxk+kmT5!3sn$%F+gH3<`Ei|hJyvh?5-h8WnFabJM>AnoU$nb$) z(mdtsuma!7w2k}5w2m(A)R}l7PD}#fT$`QdlKb_8EoaY`#F)+=(}qG5;?DWm&Vk%P z1^P+a*=!1JvF9&0DV_Lcu<^2E-IlUQ9jDr{wsA+v}QkIP0C|97#u0^lX~+ zM4A2JF^i1c_)twB^oU`h&DOWOxn7!k$Ent!iyF+Vm>TAT(Q~5& zPfyKJ(7&9Vy}43GfZ30kgvyW4CT8pHjLwZly?5MP@%h^ehKE~jc?Ib$h2 zzWGcSb>Ij4q?jI}UzDycQ9rr*AEHaL;qML8HQ$-5zfDvz8vK`pyIQ1Is{#zvUhp*n z6z!e7UP?BRiyHh+TzOPNw2C;=5{Ye!_TIKSw+Mt+y#I~UwGBP1!p8r#uQ%{nXBIsb z*kif&z$PP)Bh>Nf6q8c9H2G7csUSyjM(!c;`SZENYPzn*zQhRO7Y|Gp0ZE$bUti`_ zl05lXGVtVRU^4D@mteyB+!I%nSX9ZMoO>CKHYMNfDRm zV|DYduJ&6w3xl{y2_H%a^1L29^rZ)#5Yy8O64R-b4f{RC%jD)jt>DuoLHv?#kZ$n# ze({Q8^YO>j;B$55g00g4qHb`N<-f^15f^GEY=>aYH%Yv-pK=SX1mLz@{5{z-j#OH@*{Ib!P~klCE4YooRx zNL_ov)cx)td>4AEd%mv=9tu(t?W^WH?Cm$;KBOKv?(R!p@8`NJs(U(%CyQ1vt`*+^ zy5wJ~Nf{SQ2d(xbgYAO?^pmCg`fZeAJe@HM)NvZlc)hbx%DT7A+&cK ze2r*V7k6H$8k*1eSakoXhLna(?sNkP<=|O7c8@g_-s!B!;voNba^yzX9?eq&1hbif zeCYsh&f^kz_%+o@rq>`BkOSR4@HddY><_Hrr!0J8&j&u*@{r9Xp55A0(uc?>oV=n^ z$O>v3Krr#izj7|Lx4txQY)oOtEl#r$|rl7a+>ekxj=HKmEk{$V)Ys(EmQj5N$I7N2wMO%hXYH${M0dp&> zD*0J+vr*5DAlv(Tlr8}v`kuf3lugj4`gC;MJNa7Gy6PnG&IezgiCX@SfE&iRk+dxz zboF#qK$6pn#`rNDqWI0+~<-+Ei`@J|WDe6{eR5b*9_K zte>?^3M?@M{raB*B0+ZZHb$x&s426o?a2v6S7^gnYI)4$n9OZ^FDiEAfX(TUiyb_y z5%`p%tw#qRX)@j0){$Sy{?<_=r%%NBMW57Dhu~>zE$mRGkFLT7%F&3V@_c4!GGwxX z^wYW9pS@!^Sc<4j_l=>$Zl;%7S!FgPr$@h6L15WhZ;*ao&}kz6Ds8k7=A(Lk9PWrd zA3%KU6GJ3dp&nmNaA1q=?OB^`=goww0!Hh%V{a6Ny3W0xu%8KIoZUFCrsk11U02^A zfK0)qEQnepyv-E#XJe03z1KA7Fj?J!^SzAiJ&1d`K?ahosz!vH6v}Uj;IX<;&vW|ikU65a$|3q-dOEdnsNrDLY;W8yMr8Z^rIm+> zgnxcZ668u@#qFH=4i#=9nt)S2w$2$6<~15@(<9jy^mV_->jG@|8a$XdUkiF zf30+g{zUfR=M9Zh;Ya!nW10TNOM`-sZ7eho(klv|tbdkjlW%~K-g@pBNkG0BB!j3$zw>Li%aK>2AAKH@=^$ zgRf%uYVDQkckN&}deyo(*O}3!E)EJl`czJTbOFfhDCh~ldqVHmC73dzG2c!iJjdsj zyKkt@2YNZK#Wg`J;}>>ic+$QmYHqdV974n}r0_U#TTsce5Dwa7=#y!|45AA0VzHT3BP*MEG>Sv0|- z*7xAu=>nwxcX|Km{ovimjNeyuPyY!%8R}e)fSslX5lVN62lab)Bdra{kz->6`it!= zp~6@6Ui=X1-Mc*+859uPx%iDDOb`E(Lt8;BFs@cZ+ZXAMWx`il>o{n6bfPKsXKH-o z*SL0>MlyCnKWtR_GUnC?PRds|0j@8&4@m4AV(XV067IS0`WI7A%=rL^)j?nHRv{J0 z8R~COWbNM-3yaWeE#O^>{oxRqbfRFaqkx2JGQTl?Q&^!|+`L09MJO9}fsLG|gMRj1gGm(TLb&mu+>#f(D6 z$8!3gSPB69nMVExETE$Mp1YJB4{olez<`>MXK#1ks!wy?%)5<+X8({x8xYM$P~`Ba$%{h;;7-|_}672SW3h$lzpbg z*F=`|*)|hS&!-%lBU1kr&I0Ck`aP0`cc5N~z0h@GAlImm_i9+6Aq@vOzqlhF6VITn zj|&GZYD(I9x%4>Pj6xj%155yh)|IRVQ~$Z*`SU|~Y5E8Q@S1aDe-?-9l9x8>U89`# z{0M!iA&q&gAt`r-_et};KHPPF-C|a?<$3PK>it`Jzk;-jMFrb~g8C6xD zLq>t!F(RO^YfMJ{3S;~?SFm3Ub3azXB$~4vUAF{R9GNi8^Zk``(&WMsuMQ!F6OO;k z*seP1Jh(NzuPi>;=rQ5Zl>FN7)w*mOCbdFwyOt91_%~;+Jk6rzcEXd}siE4~E2D=V zJ5FxCKGVbH;g6t&tVACTM_O~M2CdP?WQ^hHV{NCbz_vDjP^Y?U85!t-GdWw0RnY8V zt&49>lFX9?5*CPwg}VFaXN|5C;9pZF)o0*q`nR{F6(EmL+L-p~25)b{B1e@if9JOv z3Co>tvTB=Mm%feH?pc_4j)D{wQduomFX2OIhPU?MZ|Cr{snJ8=r*AcAlXsGk-W$1f zp-|8mkG({^{}nLVy26GwP{butyB-m3P^nGw?e+rvj7Ri{g?y0b5f5dg8B8QGr86D_5)sJzC=)7 zN*@p2{($s*jh)ZT<`dL7H>)3Rt@ib{>sLZyO9buIox3G+$l*CDK$w`mO(fA5L@}s; zjg(t5%G-L9-rQ3V4Z3rUYl~zcY-+6OwxdLDRO|GA>_Y09SnI09bJ^Q2fB%yBy|>jy z8J4%=JeuK(?n~Tb^}6dr`npk^nP?gC+gemj_@p07<8qQ$8iTgBw|TkVCh9iKTCaP( ze*M%EwGuyEPDp&D$(p)RAl387EA~d9XEM%)ao^0sLSBhkaQ;-fvZO@l%9Sf#Ta)s~ z^I?!p2(Q%IPuO4D1~@g~oJ!upH{Vpe@t<$RC-s41vuF5#k-oYAvu>_;Z8bUfitqb~ zv`0AZ`e!Jt1?wg2X`)({Fq*%v@A33FqfjQa9bnoogzufRrH!rXIe|Ow3=re*HiFQP z&t9DJ(|-beYp%U+GU)Jj*>sy%>-XtqiU#y-O?YCY?%YLh4$8)SG*+E- zxSPSo=8gGMO@D-FVgK7mfmBeRC8u4F*XGjw9f;`f4kzv4N1PveA#L?L5D0sH%DtaR zrTE@%9jLpT85yL3U>FFqxUuG=aY1jQZSCg3S9h@}QYOzX^^E5)qTMBvkI3R8j z(%#<6nYXmg`fne(t%%~-beg^Y2YxJe3YC#PC35QkOsR^qv=;%Ri4;k$Q5NfBYU1}OY`q1? zkG1haxos>ql1z!pYit8u^WU2eN&Hrdp7(>)LUe8b*Y1iINBn%ipBxhVEjWB7NF8D^ zmS=d+*p1y53Duz1vcGZ;;~3UedYM!O`FULFgJ#~)N^&1dAPSS+`VJ+i;Uq#E#q)(A zmftvC8V&e^fqyF8?OPA!ql0XyOdZSkAFXB6fZ%uG`JNNsYjPM_4&^wN# z3fQ}*dp&TD;U~fI#a{yms~q4cPIqHPn1a-2IawL#$WGW;sP93rP4Imd6T%s}WvlA+ zxaB{=+=vgFE0oz{W4CyA8nhhl(|ED(WTHQKl&NmfIGAm5HUe$R{rm%oX6X!KVgPca zvg{lGZh)$rY5vVWGQ9#nZew8rkNvTlTL1lIHp3rwI%0Nf-zI~z;}{x&irZ@^{cUWF z(WVndr*b(q!JyYIAByC9#`wD*kasKm$2(wRd;2U=3=QB@Ls4<=hQ}trgQC^w@{}>>HXNr0Y{PX#TVHIW z+$IR_Tm8Qhr}kReG@fRAp(~s{Y?w*YO0mD}f3KHt#&YXHMw>lcBM+plGuGdm4dS#c z%5NH65iToZQ!`Q+=rE5sEV(l-hjV?{257>YTD5NcjVvEu0q!AcdrT;F_qru|H&A_A zOk!@m-#S1Up!It`L4d`xEx}O+5S6%ChXM1W;-7RVp;tyDkhgQuw?5H>Es0X>;==4Esz z(#F^en0WA9YP=jW5qlh(#g_7l4Wm7I%k5b*63`Xrv;AHA<*S^teHEuE3?stX0;Fuz zabe0lKC%KT3PIW_@-wU{WAjk#y5p3yb0c%?#)N6{S`ug-_};Veb@aj-{VT?SUrDRp zX{?cQ`oDWslnRLAjAhN3U4_z(yn_<=>XLgub^#BpIw`>-bySJT&X$4WX`C`+?Bpoa zdaG~s2}v&Tz^SDdB%S!3c8xL|jNY=?%DWH0JG$91U>~-;#>FWTT0)}+4IE>dWFT%J_A7 zsI%i0_-9n-hwGVwi1(hCZ>1}nfL4bpT{e=7uB~nbRafk=lCG$@8>Ec2ARV&w@u1P< zitB(7rSW6?<3>6P2vU|9`phgqQrT)h9z88Cu|7u>o%))pt^oy4-s8t-ZaNk`8N(gc zAI1>gfLc|g1k|wWwXfX4RT6zsJT;N{z2|wN7W{&ow|_I8j*U`Q>@!Vg?g6YM!7<4C8HQwShZ;Ouv4*V7-}` zeov3-TmcGOYSg1IoN)a&zF}c+qGd$F%nEpnfvu*WuGo%>$5$PsD!?Nhp68#K7cb|z zLS;z?dwZm2)xXuZ4fC5TtZyAjzS%jU60&F-cz03o^)5>{+0mbVMQ{}rv5-Mnct%rDM&{={dUh~!$t_TQjVYXCEyBv3!>N9zO7K1DxS^-NA3r{xWWuD1KB?fJ z+zC0S{Qi22w!F16Z9Lt>AA*sm+AXxhXReCYlhBZ`FZ3?q3)0XFiy!htM0Fy^K7HYA z*1f#`WJNi@=w_FcBlO|!+)J7xLp#VJgcoh8C#01kDA*~Vp8jP{OmyePabr-^eboDm z)Ks0+uf>sZK=abR4;aV@UJy|gbOZeUPB?At6fS(w zlLm_rUpVEbH}x;5R;O!Q=j3ICs(8psT*;BBU(<1*eS7N)_!H~w9G6ZD*ksPyv?zeAR2(2eVN zCvk?x&Azd0=JQt?sH9i_c0-5 z)cS_$&ou6=t38rydGw$_){B(i)8C7)JEOKgSdD2WJv$yT(Cs=PD&|-^uPbATC~Q|` zf8))aCbZV9|5gm`WLk{>`}g0d=;+^{bx&Ukod34lBV|zkp_!AO$f{ncVWvik(uFhL zq5nW*hC=gd#MQfoWXz1w{p5cjgcxumnBL<5M+$ zc#IzClmJrqwvK+rL{zVPR%Ck1w5_D^{=otMlP(!N=Ha60dWldtYm(;c^Ea#BNqv$@ zgBA#0RMW^#JoMp-;(YteNcW|CPKi!Kw105MX#bU53TkbKGS7BY)|3wRiB;@EW^M(i zhMk*FHa&XKEn~dh(5uR=zk}w_(S6oudObF4rMjU!&cytSmZzq#g45n^qwdaGVi{cL zo2!&iK~Dcu+8`PgW&+&~IgL606GKL|2JO;tM38Lx3w5ltM{_^VDaCFN#Vy7) z5trnOngw4n6%lFdE>sYzDG&mQ<>_-&D%J>v9skzlXt(1T2+M(TTx#;9mR;RrEvqjV zHFLH=d4%+5rhUAI)hgu18j3rxo61CbUy21E=}Sl@Gn6=8(l!Ae_bpmxTUHR){>qDT zCA{)F%GZgSy*T|Xcz-_HDZi!tBtL5@8ZE<9z@7#ZAS=htpb`DE^(MakTH z9Yk|i6dm%sephEy!KU#A6fHLSB<-_hp34C|ZPF;bR;YLtO#e;bq?v8FY7-+MbTc#O z(R|h5o4)dniPHpjUb^VA+TozpyETS`DruFn-E=o)V81{NGLqAmieG1p8hwqkNQyUg z)HDTjO{GSA;SeSjBP>iqU&9{fR`bZ-vPWIoBdKa;CGiC3Vd>i||SBFDe1XkSN z&|rePH=Z9I|JeMS?<*VM){c2=y{(LBq+cMdtr|m53rtm<+$}=8Zpmjvthi8lV8kLi z+wL_Luz01jvS*Q*Fh*xZd`iL$jRgT$0nUUgq2*YpE5sxEr1#C&j&jAME2|E^w!btU zi0|6S6q)v{1=>D2titT6C@8Epe(Bc=_Iys@8P7-HZX@1MA3*_a4V-G=S0gDsew!1< z)b;?n;XfQi&2wed`U+O1JnGMQQrw>aPg0LLNPaSTu#$<6UWpJT%Q4;N%UjdtL+n-x z6%D<&o}Ka4fgOXr68b@1)r?fWRCk`Rd78k&`XBlnD+)U0yi@-`8vQsO4teY1$ zI3qLRx|<55lsqR70RsKn7b?@dGv~vt(-+l6S@C|7p~-%Sk8j91+j)_QeSPr-iOVOI zH>SYYM+TiODekgXrUKOs*zEhc7OPKpOpGUOKFX)>GfI{nn9u_zBl1h>RDAlP_$NVp zJ{j14o+T85Dw`pvwDbx`tL7925f?Vhmr>(t<3}oR#wtB854% zsy~l9*_x!E1~`O_^3pR1D9-ANZScOdQiF`~uIez1vXq?J`oAS%i>v`h#wp`!+ z-d4n-R<6rH29j(RpI^1I0P9wD#)vq7b*?r4WK?|HFpRl=wA!IuWGmj@WN!S+R->we zMF|$=so3ysOK}hN^D0YOQ`!G!oSqdmoPSq4C+^VFg$^uGr0_Y-Jj?j_=Vs7=zgg3x zd$^E{f3|hg9*pU;!ae#r=uds*h+=|ow6mP6>`+mSoJ+gTCIgYjZs$e`&=?E7RB zB!ilr5x|OO_UO~V<%gQX>F)httq}tn2SC8490sJT|D?fH&`*eM+F^`Z^SNuxRpq-> z1m&V=Lv?_;c@h^_z31O;8w#&+^W6PLfj#YRE~zUt!sw2>i{&Z2O^r1-za?Al_?r#_ zDVtm8>kQwRNspSXlSB@E)*m62mo_;joNdpY>m?kBTPXV(m8DeA{=je5lV9l$`R+H+ z4JC+OLkgb$iaFB`rqo;Ed-)V|XSQi7I)zI8(-?F}CGDM-OZ~7+pe0}YF8pMpOllFO zJ?PECFc978v9A1_6)&xoYe)zLIk3O@=`$$A;I%^CV^65=%Z?4@?;o2kQwUe-9%peZ ztA6JwUfS^V^wjpbO}n2jPrWDVSwcqmbD_Z6SW97hrn0Xqe^s}i#)}DRz~#N0q8n1= z2qJ8pOM9pRs@otH)&7uH#>wD;BvT~I+Y~&EHLnOrc z3QPI2z2y`?XcRtI)gbGKs-`OC*7JZEF7fdt*7?t;SLriGTPK zdp531J`J^17&B#*b#?V!Iozhbg5ECvI+#9{!f&BcZ~}O;C4X$Yug;pEHL+2{@pHCf zZce|$#V|;CTAPzV!udVRCE69xsP2Ck-!~P}{dQEt zT*N>ymx}b$BK5?h{xC{smJ2vYYV_(SHGN*@;mYLl5U@@Uqq6x91}9Z&G!6!{vc6K0 zG?!j-y5j8cZ1Rs1mXD4>rWtN3S70*)hp(vvi zxLGPa{(~UCBRl^k8YKPUB(1$Hq1&R@^g1$Iwo8j7{T%nd>GzU7QAD+sSH4c;z>^Jn zmA0*&&5Ei#5(B0kDm_*N1Owi~KM%kaSqFw#`N8i+>IoYqricW-{H<>ub%$37Ox`*EV zcD)zzNt-{tJX;PGkuf9M$Ug->F7EE*lLH+JKF(=TmCbpTma7pyIc&R(HoQSyL2H2> zt#6x<8%i!#hP`wOoO2}(em-k)2TaWD{!w20AxPw-v1~V^i=YXITa{5;fe4wQ4*H9= zwYOAN`HUD}bHrY$o`z?qj>wfu%iRs{si;L4uARvVJ)e>m3z=+cN$c&(PcO39UUGD| zb%Br7y*`FpP0qmm0ITe{(#9}DSo)1kKAg=V5`w$-?=u410DD0yysP}+PwjjU_6es7 zzxj_qBZ`@*L(gK`7R)uH)T0BWlgyO4aGCS2kD%vV1pGj)(#eDf{s!AWUmd}l`nCO^ zsIz`+@^Rn(Jw^!<77fEdL=cef4Sg#j3X0TdM7q1j00k8hB&88V5Ju<70n(+!MuWsg z*T{|d&d>A1^9PI_$Jnv!zRv4BU*~{=$Ajqup5F?|YCW%Ymxh+NhG3v(m-}p$uO~Ez>gEsl&w!!=3FH6y~s~-PZyf{ z)k<|*Fy3J`aA3`E0p6z|MxjUqZ2vfzCKVDtj=snmqZEnbmS?Lsx{J{*e2}Ieb_P@% z%L;>b({%$1&8fn*q@td^BZ^IOdZgc_KrFE|wBvAKoAb=$1!YHMFWb7W(ouh@xy7^I zgq-Jd@$+aFRLleLG4}zBmH4B=Nv26E7*RdM{|L7=D##UsX4> z0nqCTRFvM@x7Luk!H7Jj0?fxz0M+KGy)KxlvAtO{&jFd~GMEK@ez*;};Zit`^%Sv{ z+W(k3_Yswn+u}4nU4Jiq$?E4-4een>akWwTL@Vz^b!F8wpHu%}53%{U>EtgCnt(%` zzcp4S7Oy)ycjJ2sPK2mVkY_PrWC}iM-Wo#km~U1*1Yx3~^U7E6>}Kc)>&gdgRvPJV9vVGYnU|&36;AG9<@}aQh@7IX`?$S+;i>Pk0cC5hv@*`v1?SwpgG~tzJuHy z5Wn}0Q3{n|ba74PX;aa6sl7YmyjGvf!zq4~%(Yh>GtFktkQW}h7DMu0H!ZkXjJ2Z= z+Ek8Ql~i=JQ$-Q36qi&sT3@o%-HN3f8ffydR zHyb7*BDyT^*p;yf4?DjB#Hy_lHY_;G0@!t4Z#p5lSNXa7f#9Fne>D0@7cL z^3iqag=F}>be^geXlt{SP>~UW`kmD8wm}eso~!Ayd&hrP!P1!}cqRsgr?j{HK$jm; z-Q5MUR38U1ApxyyAn{{w*mF1DE*r03^Oq~l5aLH{__A8d)tSMq_;{O`d8<_kyuQ2c3iic2<7!y>)$q z*~MR#xe=%PUiHLCBT4pi?@=9OP=+A7ivl&(IVllnwb~Sx7eVquG&cpglwUSqH z11Xs-H8D9YF3xbL-S}B?bzjixud(MXq42_& z;=M2X@9I&7%%@q2VG_r?jY1tvQCb!PETx|VtL7Wf^E6L?Ca_!CIE=$YF|rsD7Pl(y z+I8xt76vxGcHkG!a=6#MsW-1rFFq+U?dNoqR`%{i)%d~a4gSD6!HaG&YzyNv9ai_| zEZQb=XMx9iO!;)U65(EH_^`036eoA$5ztclB!Z@x!C8vipt((;wBjvxWE)@Sa3$uw zKPc8VQVF98Q`>7XuC`BsE531F^%Gje=ax!Y0j!%oMGZaZnIgr~KJ)L1{UG3)D}Ukv zP=!3c=s(f`I3R-?optY$rrLrk;0_~opqKUXY<{qp6OkzVZRdD57jXi{W#2Hrk+l3u8 z(7-U#++yZ4`0{~=CWm_|A@&A2Z=A;3)*oicm^U}_Hnj~6w)ykXr|!2FU7L)f<(oKb zP094I>E}ovRmBMNs|>l~f+-Fo}wnD|GPX^yPKe;g!G_yb$v z1N{Z*G_q!UNr*nX89gROH-Ay73_l6>PN##SCPtjQx2UyXI8#r0a;-qZ32Nl7eAub| zXv5qDrEQz@2$!GKzsu*=$DVkx%-Nuj&C1Ss3Lkx1T}%w~QrRuXV=&g^uLjdwY>|b} zm2cL0e@Y_IzDQB^Mml@TOjjU-KIkgpMe4=vir>Sp49F6Y3hQb1JT_rFTtNP*tpguv zZXifNVc0M@sd~SOa*UZ!iu`!&cP~}8Duh9PVWO#GZ>6Vb6@9<(vwsuP@k6J77W$$y z+xNo3Mk{cLbVfzClh)^Hao0aaFW=nTfakCE`&mI;?9y#b)+|3`6$FIV{LFANDeXez z2F3P`y6~@@lKi!~gBnwmbf0|wSbZz)l;jI-@?T?197+ZDU_MV!ZJiLZ%z14<62qe#MWN=J3`ScOSx$=AG;bf79BiNfJ@iC&kvnPhi^lA2*i{U${wnk zLK?t1SLMd`8jL@8va$4-6k#r&*RC~)wb~%oVH=x1anFT&I$VRVc`oh-xb#Ri`#&>9 zkQ8@2BAZ8idgyk)s0^!+ScMUg)gxxZW5&Nw7trsJ&`rKxWG(1%Eof$HEH?MpPTphH z3GI8JjP~6OLL)X}r#N^MF9l^-fLQ5Wxd8G1T2nPr+BS%`C%?&Mff`e0R^q z89Fi2MlQ5==P6~Bl{_z9~5Vf*;<7_%$#ufWbSpSW`Z99QgKvx-7t0!2e_Nwm zITQ5F5Dzl~@K$K|rGifvqq~1CzCBqMJQs*oJ}@~R@Hs0JE{ZOi55a zQWV()VgBT)96g?`Ew~sPN$OKk8q<_Yyt6*M?*D77Re?nOyS95{dg$O=ZKFDXY#=zv9dAeMIrG2-(!H1rId2)V7l?`sKT_`y_ z%cmHRw1^fHjN~~=G-|#Wfws}=SomB{yG-+2`>sf`hOV&&)i=G}!*MK0QKki_c# z5n1K+Ty(^Fsiq86(#{X54d`>_KC1WTqCq!S*#E{3;LG7Vg}}oEcP`vWWflEr5AmcH z-9p0}yc$Ld13&Kjgt9$_DHyC6flb%2OlfHUrEHYZXATYXa}B0X;fsqNxxa%Uk!o& zTqF(c8OaupU%L|%n0|+E%~=w#rkGS;9cXx4JSD4$jY=dkd99b=@-v7>ms!|xa zbT4mh&=+o5!!CugG#51>tm#L5|7s>~&?hpv!c*bAn9Bp>EY0w+DD*-pu$TAMgb9YQ z>tCGzwYqRLcCQe8SUu7`P6e}MDp*P@ibS`J`cGdgMAZ2h85|dmk*fCj3}XBZJg`*{ zmG+lMH$uWQM&-jiDj0`pM~n7LRR~!Rv&_Q~(oH`INQAo{hsS-W%})DN=;kAro#={) z$jP*H3UVPgvZ^^-WWGsnvST7kHL%VnZPH#OMnX(Me?s(>s^Mly3#va9wL0c2127zL z35-uWYFM~ESi@hG=rmyVv7-nQ z6E)Z)JO|PfUaeN_<0rrcP80Gp{EKMYfHy@#`|}N>7oI(9RARB&u=Vjol3{i&A~S*_jV@hG*_q_}bfrT~PhWpy8o9M`TTrlHV?{%(F`i45 ztdvkG{_{+NYHtBBzY!;PCF?b%PK7>QvlFrWSMB;8_h;R^@7j|kZ5Ef3%n~~x!BeK* zSJ9%5w9bB^Vb{;U^ao(CvESgphJNFIF z5nZJ@1FwUR9)3R#7z$LFk9=5+m#O^|?_XuDch>W+0ewkk+a>6s%zluYhm)?}q!Zk1 zv)jG!x?){kO|^_w(QpFuMk2#*#O&D%)3ej)rBOmgOhSV6@tx44(&fWHYMK8bXH~Zc z!NG2qw9qEJ3lR{7-uEYx-J=?WrCmCg-rwUjOFc_0i==HP&J3QUvT@GjA;QGf^U}or zWNvc+|KllUA7U+w6;Wlzf3)6-kRLC?P#H~5++ zCgJu@s`rwA$G>~`$ZvlMw-jB{d~Z;h7>fq@czNUgez|nq!gBubY&&AM*Cm)Ne7xW= z=)h?#>OV&y{#G@xjX_4FQDtdaZ9_hSkhC_*#&u!U2VSLTVR}8JoxSH|j))(D#`(Vf z24`|isJz*vx1MvQFJ1;3;J!%+zR>m?8MNFuM)0N$FTAnJ_9uy3KBJrX80k-2Z2178 zJ1^IIGPO3kI<)_>W~4Bj>uecgh`MA=!%MlD@WHj! znHp-lIa8?Ch}zZM!?l$>bZI-?G4m9i{+p#xal2n`)+h4il*y+ZpJ$fny+1=>X;EDz zW^3Xd~ zZ{Z8%C=A;1xlOuEh1{w9ZJ4RD(vt)VdV(<^*U)RrC_DsJ!1#`)++G#A7ZhvZ&mshuf#tz5xj`v(=f{e9Qq?Dzt zosqJ#dhPHIdyVU|_Z%DsvN`pNU6~k0EEC718bhn(G0pBB7!gdo^G&hFABf@-5zeDf zjXvvpHi=7pDW>&zBPDY}msD0k*p>-Sy^&Ic&33{Jn4fCr>$NgdlZmQOke1%#wO>7K zn?^=l!5h1eJQN#fvupt-OfvW!XahWI%^V0-EEuSN$%f^0AKVL!|KoNKT&Mdzf^6yJ z1Mj4D)e*8{(xXDz%eu)MmiZ$m3Tme+-7(%U#{m+zIEw`;!lIkW{9>dDpj>Zckmayy zELYPS7k88Pd5XsCIRU36#9ZB2kDXa}bFo*6-E`rTHrf|d*rH|K;nH=&y}RX_FawW@ z1^jFF8VpP){kF%lacMQ^iy=}C_PjU~FgKV6lce|ydEq9*fxs(_je&LBqwT%1=XRyl zbq7cjnCUt<*3%`xq_?WdnO_Lmm$;T!Bw6fKr8$ZveRN#qa$2o2Hk2s!{CxbIWT5fO zcrN8@qmHOeZcK6lBfFUTD>5c6ITD_J#p6%?%<##CK6dN?U^`EXG(VsU!VJyK%p@jQ z%pj}1y=AP_$j=nWmik*;vy&SHw*bDm*ebwaiNQ60!_KVisjRg84}BBMd*H>+hWocs zD)TCSkt+7`7?ss7vHmd?cfHg6D^Ii!bE;`#x(qFrVouR=vbXn_FN)7f7ad~z3)!qc zmnC*(IIPyimW;mHn%~612iBGqB*bV*D}L_S>mgLVw7)E-qy1O?f5`jLV(qw!OX~gk zO1tR4cF0o?SUL_UI?bFht9Mw6>6=n{KwWXWEpKXL~+?i;dHBVY#@200HN8o4uG zDQA9BXgAW>6rS*aj;TDcZ+2vv3GKG=@$?~xaCOXO9ed4)8)mRtNvb-pU6>wUwc{Fm z48tTk4nd|XFs%moUr}41HziXAr)3SQe$@$yCUA<8({1hyYIc0?^~g{~zSS2s`F#`{ zk_d#>!s%?M=FwS$(LYoiW&@9t!NF$#c16Z$g}@~GxkV`XU)lq{{lZsv36eXPm6(*Y zQSYIYLP7i_f2pv^@as?+7EG_viO%}|?#cc*19XgU&(Z@-vfzCOd0xug0=aP(lnN8FI3>ihYWw=AToUb zM@(U~8sFI(IP_6}iJRBz{Ya$M_|(i7?>u26#mVx4~xUsD3Z9g}o;=&Ns!#US>c_16d$!gJnbxPSC8Et6weuP9f!poI z(vunwa@wExw+w= z>YDcU(*9Khb(knSTA6QCwpcRWotZP6URk$)BkL(5x$%@7ki4Fs5Qv zkez~;%{Yq}D1gfkY{m1RzI1-Lg9))lT8!1aaTO*yS2*h2mL-i^lt&idoa9y(T4KN0 z1EQklr>NNQvf)DbkbOK#saT?fnMqw<)&a?6hv)OX#y=492I&R!Vy10vO{$oprC!E} zwIW>x%Gpbq`LD#>+-7Cf7J}w2n8x#_bDL-SOIu=?gVvWv&E>(_rLV^-Bw)6HEhcbe zydyMufO|9X0+<%NkEXdLEAQVnr#^Lw`&a&w-hN$Z>U>5ucHri)@wjMzWk(g?7wk2Z-A^tw zY%I2g^u10?v{Z_+Z$Y*=cJwnQP9bSPGo`jqIFKy-1Av0Zm4+Xu9lNvPd;SWv)0TaT zRP()}avIK*@u>H!?pr_DtqyuoVx*yFFIm4N(P{QREk4pOZ_t|ek}u06)+|bDqmt5! z{rb#+Je}@UVL%Vm);C(PUXL-&O{;M4Ym;#f#-$6u4*0|^Dq`cbE&gDjFd1xe#XKNK z7jHqsTIz%z7LWYIyzQ{UV|)6JrpRR!5O2jK0{-g)6POJbHQYz(lu>f-@r7iLMj;Kx zS2E`);Y1Q3)ZZv38Yk4pr-83S4tEk>u^TJng`dd6bwd&cd%X?lSSDS#$a`)JPuDahV3Xa zGdiRp{%wJJR2BMxj*(8&#wyp~f zs!|rQsq>z6He2PS4qXg%)msiwCo2>aqRT+{Dl$P^a%w0#o7sAjmB{*|jEFR46huNF zC_fMZjwaVvE8I0ZXa1DwTrA%Uh_$)ooVt!9MRbIF?##E3bUiK5iM~@S^i^nPYcAKH()i)>`OBxje=RII zD0%RozbcYe-#$$_(qR!pNLjQ!DBXQ1ngy}GcWiMfHUSbp)_^wFER_mj9Oz9F>#g5v z5*}0`qXNm3vzn$^|LmuvPw(tZ5O0{zA1eGar;4@TJ4@H;Y|&NUwVJomVz6hT+-)NK zIN8q~TR56+OU+`BvVl2*(JV=CUXmP{Uo+#c5i0`jz=;^=_%`Tk`};x$7p^5jbVNln z1^Xg6diAeS2kHRZYxA^U4<*G!BCavW3oVnmN>gh*Yw80gVK7Se3z)xAId0oMq>Zio z;Dt#y0e{fb!=Xf3uI>6o68n|)GijIUj<^k}si_v98kfZ+JuSM6AE;axxlmni0#2yj z$fH3VAFEw!Zw<%~N zLivQC3hR0Oh*h?=mI|+SxP}|(&6RZNg&Tv+8t>xN)ZVyUvlx~?2LL7DO^3!MXd{&R?IR1+?3au;<1P>&klsRw_0G$L#aJ2jreF#ZH%f`4 z2J#tyGk=6iA6PedB|KXDtE`dYMXru(2b2OcW9%S|Zovdyt6>rB@|S<0#!3(H z3bJMt2m@T6^>@9~U|(9@Uz70soBgJObCO((m+9I%;PoK(UORFz8kDf>bs+hH3Xvog zY7x0+aj~riVs*w}CS}4JEr9o+342442YCH9$Jr@!eru}6J!I1wK6X6`^+L~!h#)vcVhU=H?#L!9g9&_D}bx?aI2y+isLV2cK*2R0a{HorH6zgb5j zs&U+jl_X3ubgD?p3r8|WYWJ)WQEsfjGb*y?-L133q1zN7N#ewet*v&aaz+H9grCi$QBJ7S&{dw!DEG2G_B zL$!CP!V_(jmKkr%R%ix$MUwYpOe$6$pIJ`P7*(VYw^Y@jM$eeIIo`LIdfyaenwm^8 z(xBULqcLvbGN(j3i0~M_D*n+29jHtYnBpkuJ{hS6H(*Qc38-DrSUjT#mYF}fMJ@d! zR+sWo-wNCEH`oS?J6tFZbqi6Hck9JG%;MtD^P2iQaRTeNT~35q|d_LQpiw zWPBS%G?S{D8tZ!glTFf4Z_VyEUD3nN6@K-ONR8=?jl%tFD7IB4FSpKB{%6K~HiQmO zcKsxyKv}TbCH^wm4~~@Y9Dag*l^^yxD5N1(qio4@hatqrNu_2N{6-nWM19lAlvfm z6qbxh*;v;Jh%=U1>V0mLbE+~{hJv+Lm65c>@Vzj4b-2C0_`byoK%iJ&WP;Lor!Dnn z;D?e&T7=Zf9|vEJGDFMqRPW#r`e=gkW!5(s^-Pm|+nguny9^Z;IyQE^N_fqv?G ziAf9sAJU``sAIl`qn~6em~~ zWr`XURq*KsLayZC7W-vQDTwnY39G$7zI?ev#2?}I?*225K1#beb{BzLkma5;Y`U45 znp$xvEaJS&7w5_Lis{ABe|cOYFsRH8DE75-WD;p(!)Y>xwcvz~H&r6FpW*yI^G}8g z11z~((9_Bja`Sn>?t}j^0L-3fDeb&X#?okO`VaimF$)V-+0N%(M{;^_9y&qlc7jfs zffh5r3uco*2O5`8@e#RZXS+!s2G_;vW+<*2PzEFJHe#QFc#9I*n5FbYL7%9vSQr~5 zML#strKcE2l?(#EVCqxBL}0&1!gD25)x~;cb0#Qgwk=fg{7Y@lRzP8Sb+rYyseC+b zGuaM4JCXSO^jTGT({;s^XodV}pNA{})&6n7;#SC6S8pR7?U&JS7ERmvI>J9FPlEef z$pRRYpo5L|^$AJVBUeAPV1nWEg{`je14|<^^`7VHs(=UhWCDV?En94oNXMcwa%kW} zBTjwBTz4ig-5Z8{A0R^eTAdZ3FnhY^TTuy;QBDjff&*kGoH>b-z0viS+$Hp5bjSnooKsVZfpg<77S-D*t`)u+2Ue|KzD{X7sl z&+x5U)sOEHA97LU!h7P*PNk}XT~plh@W>K*eT{xg>js{>Y=D^x)#X{tpF?DH-@v|4 z^V^CS5w(8fXVs4G#(I?H5I}P-0XQ^iqZpSCTQN_&sGBg zU)sMw^BtOPKDmryeUT_q8BoP@UMhq`(jBj)56)=dSNHX6MeWz6RLe9FLfV7Pd()l zak}*H8HZ{R)C}q_+d_gi3M^Ka`d((p?bger9S}wbqh^LP^Y2|9fPbA$Dr@)?Hl=lvF5LQd-psTKXv+PsYWVYteBB>SYd1s>s+y&3@&L;;eb>a+K!s)$co1DH#isJtw@JLe&C{*DrH++;G2%K4HK}%6MTEVBiDHMg z>pa9A{)wQ2gFl%yw$`<+y*zGp&G$`-kZwEkyTtc~Y5N_!soaaCOq)-f7wvl^c0@0C zfUcgcHJ=ssKN`bkIru`T6284BGAy+2yk+POhh0zMsTVLxRR(7rcw_q*xLD^7u;ncx z`|gh!7>7d(`}Cw8M1}ejtO~E9D}QnE&YAYl2^qUoOY>naBI(yc0VSjag+2y1lVnfF zJaXXunZU;M8Qdfxo8d1o)8cBdXm4O#5;ZE0+OO*K*As#kZrx!Q$V`@SrQ={&c5-^B zGN)PLEIyJlvyd?Ym-axWqccYpLWoN5tzlPTe0l?buRpVP+s4Y`7*lcz#~+fgjEs5S z5?>aVcx(kWVhvt#So=8(ty0O7 zw|O2#V#+rfuB#kK#T9e>H)`?O>zTprU%D<8hT^@}xl<^#R(d9JDxYRI`0G|zdNWk z!-w~+>dP~CHHOQ7oX*lt4SOEY7Kbo34VN3s>Q9*ht-IoEqM;xSM!zX3Me}&S_W21J zy>o9pEB&hSdEh<_Gg;5gJU0Qa5q8?Nxa4ZtZpla)bN&k)t0geQ$sy0o~*NMzohZS%YjZf1onD#J{vyW z7Uf(~u;ew>=-q~CDjr~3v-n+9d_|mlJELMQe`TT=PD9-~;?+(gg_Q+KIT)IGyLDhR z2f$?TTCg{p*QWd{Og62f4AK8b`sDbAS9(CY#=$i^%0^zR#OQ9wC)){gr0x4z>e|h> z)WC7VzVYgSRM0W3Vo7JZ9@elPT$HJTl42+?*w-Z*mW1Ps;NYDnhkD`xCMa43{)C_p z0giLfIh~2t^6w#uhBe?-`-xz>EBci)k?f)q$KWYP9WR&F+Ks+te+#SVotMnAUF*|D z{l)1IMJ~HIq*wXJMewAmXTg3u+^|{c)so_wuda5?*?B|_9ob!Yb~~<& z$%lx4F7LCM*09sTZJoGlM&YQ&3M&0O$es0&2*GDIpck~>bMU0Si_a*C8-0y1OtV<( zgE=v~G_%JRs&&)Osb1LcHU~-Swe-w5MvUl%hRBE@l@js6mkdOxBYK+)r_V$!qJQ^8 z%&gnfg0;fi0Ot1%GqiT1Fr~{-i*(!tuM6O>t#2nm01Asa1SlM>Qw>ON7l50ZNYb;+ z*?I(M&0b2^g}O`+ijaOPt#>NkI(#pq4A3J-hHO+{_P(M!ZGA4jm9A?H!W9hJR#|yj zzN)S&dYtpqO4#~Z%wAOg^9sl6rjBTp33gOkQE`u?)>#A`2;5+S$`;QdJOKiOCm6NW)F`!HihpB(bi2Bb*hrKBl4qPwVS1BhO*ub+^`1_Fp`iF*1b5g~mjxK~vk*6q zpJM=qe(Nii)qacdeXyPKx-Uepdf$Y_~a(s)HF^r z;L*9LkF=I%u_^jG<;zpta5Pouel{f#c3w(#)YB{0P3Z&L=G5x{}AcxfeShvW7WkBYe!Xe- zHZC7pxitKY*;!H_Ly>uRkA&Tvx6n%QO9;;s|MLL-u{2gH)Fpy z^uN*PCcg*e^p_|!o^K&9&ewuZ#lYVYdpQsR#N*xF7ra~d7Wa|Y&KCzpBTh$W19+1t zQTlCu;I|Qp7!(N(=^|WMXbpg<+||-nn2(tGe*Y~$m)^dnb`p!=Qq*h&r2q>;TSq+Q z_S`?T;1Ga=_x3v$fRnDs(IAMH+|T~+)s$Wj9>cpAhuZ@GUbB!Ee=FWd3%|Vg_kr`v zzEql5ca zE&Hz4c6y~x^@Qf@YHu5CfUj1fUnW~gI{CP{bz}+H=T=ekcd4* z!j6yC5ng(HeDwnM6j_wd4Rj;b9n@x{N}2V=xE668qlH+ecc{XbahsoIcdKsb z&4qh8m9FajJ|3KG0G!IJ@%HfcF;FqGX!$1FfnHL2RsE8w22|2sal$*jI^?>{QRQZbsy6oWX)te1otBX7$=&Z9h!a2l976!mSXO#A0) zwo)m-mq<-1GcJ)^KjLDCq^}Oam+6U1kglup#iRDK>2XuZx#+#=u3ZRLG^7+b9Lv0N zvj)Y|Z~bRNAWB(BXaMcs?|=O_CmWTCqQQ+fO-!q8*{O*ZP|ociYxkkb*&cMuxt2pg zjT58C!(O1TJWXED86x9ocjXHsnSG5mAD5;ku9f@f_61bHW%c_o!MxLvPWRN{{F)O5 zi}>&H=?TZ5%O=8Y%v%oZYkH-{X&9#bbnw509vj0UAXxMHS96vnP4YmEp zpE1C=t0RYV?l5b-`y1D)@3wsx!SpDN?hN3F>p0Y9Js+)XXb{_kn%Ai{h6kx735F7Q>k^7UeH%6icxR1_r~}=iW{CR>Rg*_pS1aK6Nmx9^UBL?I{TPRSTk}BuhtsHsR*y z_wf7I{g#q5ds4+Hh6A!x6nlv||O!+?XRSl2oRs124$JZA* zaBYLHDxjjxnt$aMJX{=d{pI13eShuY zQ(d|!L9}z>Xz1BZzm5H*eI7+zN@fwy3r}qjn>>i`(MSH9o&c59m>4Hj<%wS2LCe*u zzvOFG3-dX(cQOhi@|o{iw-3xhuA9m59k^M@6_OBzrxUwR$+5@b5X{%t}`ODl&IFv`Er9b z+Uk~Fvl3k?;6lvj>OLxt?Jozt{G!)jmw+#HDZt?!mag}VulVa9cw>72tuNK+8Mdh( zSYgK4-etw+#Lgv=-+VC~S?n*k_T>vbc^0#zq{FgIR6 z=DwnXq9$5QiqJ^uu0asI*0a4lJz}&jC43)~`%c|R5Z1S{V-Ys`6fOVrYC5;AQK|yl z*hg)VWq;eR{^KlwpTX?pkTCHAJ$+V{g;SMRgF>`Iu=6?SBgjTV&1($`V=uOK^J08U zd#jdlyYp<^RF)B8P)>b^#_`RGL093L%8saG$fapMcdP)ebSBTq@;M8=dpn8BHa`G^ z{e!0IV1UGAf{@?6R;|^GQETC;)_@$IsW;LiuI5%D@eQT`|1+V2cKS=FvH033zXm_l ze55o<$%@;YMWKO_;&l$C)MJr2OS4RA<+u5do`0I&1i=&0*}+_2EgXLo1Z}fWrnuSWjUlo z&-2uFs8g7{G`;?y;dMzN?z9W{z&dL%qm76}3tr$+KSS;S4RO$aK4T32k~+nUm7n#x zLnzIYtcL8(D$1tDiR$_qpa5N0w7H~1{;@w{`iD|c3P6L{3}(tVuN!}0|6ZGaI_%xs z{wV0ciz)4wHa{Cws3ym)mboK^|M;RQ*0&=DS3WXGnwvrA4gPmqo+U%b{FD+~TfBi+q zY)Mq??XAK)GSqMHK=GwQ;@lUO>43Iq0Y_#;d~)aWKS#C3jsChb0b9xeAAXhW;Sf3h zvUkF{-@aWBOFMp;yw~?{M@us53<>5#Fj(Zpty=WHJ&x-MKLw5+n#sy>G7b|4GqnOu zgU4z9V>jD6s)H8HFSTuF)j_JClgSNVy&FNjk3B2hBY4w%?Ny=~eB6W5!26^$Te47TGIKQxbRf86P`z*O)v4CN}OFK@T>k z;wBF_CxcwPo}2pN-TY49nRQQ=oNI2{Pi$_QLICPzViqKkW#M;byBZtNMyCAC$AMz| zF7eNI^{z}%Ex)ol-`PWyY`{BZsZ_CvGp;&m5&3ETs=AB>`+k%Ke!ma3dNw;ESy4o|j2olW zM8%O=ws&1;`Sk{@9udKVDhD|(D`*oLfE81ne_HS5F$Q1==iAxFwMZJwOHMw{M4V{= zoR9q1XORwi6!Phl>8NDE!Vc@8&21n%j`6pxSto$}pafkTkU+L zpFsEHq)}hVEIWJ87ws#@Cwr$q0xJB@Ng4IIP)w+?uEj77P%+-)LH0e`&4ZFF6U^r&PNUF#)5dG_y^vq z<&nhle1f+#Evs|0*?J=as$0$Obn#`1Df#2B!Fl%acF@vHwBXB^rkTww5c|O9bX(1! z48-)ADRCYvmnJKgG&p#UK%dpEG!Ej-p!JU}vBCr&J2zGPTolSn!`&xOD06D7I~W>z z4Tj;I@ZZ{_qni^H$-8vm>_8_}Sx1;PnNP$w%p((6BHYgR&CaF8`y=Q;NWOLA-`ZZY ztceC6nR>_mB+J#+m=~hzG)@)W`vlc@{ zYl`VqPsSi5(PCPO@-2I-U*e0-Y5gl5Kgg}6LFuT%x2ZTUVq+-b^CPe!)w&(7ED$FJ z&}*`0ZN;c3 zi{ZsE|7Hnlmo7ywO244zXEpc@=K#N^micv;FD9eqHO7`plwGpCYG#Nq{1rX|HWk6M zIZiFLhPFI6cnr>NJ-r*ly*-P?7YwwQ?;%G$HT&FCsu!|gbo^8b^1a@`YXvdc5_NQZ z*#T3n1c0(fULn%DVx9GvvZ#;}Yk~gJ?^Jd<-{#`jkUBZGIL*ea;LIPnwNf^gGGot( zF)W3l7z>Q8^->AboqVFTxUmuLW}zikIm==qEuB+xxkvTGfVRnXML~E`fal^5m72Wu zEgq}K`_u2Gr=|@4G-i2xo0u`2jS#5P6gdQqTU=tD>)D_ap{6oaD2xG+eP!^#5fv@1 zPh)2WW-A;qYE9Elb5MezuM_%in{4>SlUCgdRqKgx`0{Yo{S~ft$CBO+<)D(0s@EH? zmVF$clfK46yk+nlE$6lqoank?&RJGKeo6QSTFwt9P&Dr*OK@(6TKihdAjYHa|NsuMFRjknqAJgsx~KAwlQEXVKn=v=YmrJ81+f~eq08bDTPTCQB z;K?Vm2gjKHD6tOF?wwEJVxNZvqEgX2qyEUp{S!Bc7oX)hY13h^$qS}I!`3TH@h9|6(mOod+u~v?95hqO;#8?KMLtwoAT09@#0^lG8E}UFuuVM8E9r`ltd1636x1 zWQ$ilo*brBmo>iAZPpD-#QEzw)SFuKz&F5bR|;ir+l-eu6ByU>7baNn;Z0zY8x2Q? z;Vqjc6R~cipHd<{mVp?c(h;3TO0mUyp_Jf_vIFmIpQz%YSZV)^5{~a!hBGe@+^m66YWjX`=O z*>_hXwVu`t-=|+~ql0jF5mYg(N0#enXK`9*SC`1IpaT&g0HWlocR7iTu(&U4mPDkm z$&!WH7dxViBqZ+NZW|t!_(oKU>*qR&5WsMzOM1{a0$Bro?JdDS%ELn%020uAW4Tu+ z5(yn@_0@%3jog)&|J|3%6b}4xV>KV^P=8z193iyOp}@aU+a&Ny`4b-v^7|)!Z4&>n zboZ!H^#B|D=oe-0r~};OM#9IwYZ?;i-97y~>OyuLKxt7xp!y-4FA|w{Nx1}B0--|9 zj3$=Mk@85zxWpFVx+HVO`$1R)2T?j(s)=G!*D z=+g1&aC3~=Io|Df^YE->imR!>W(p*e`SS+<@^|;&G3=~gz~`FGfWjp;L?MoJX;0v% zi^>3jsqG7M+e@{s)%|0ZI;$w$-!`?MW?O`;?*~eEd|r@O)c4m1-9%L4mp(*h;a+el#~Xm+eHi!*xpe1n-U}+$>#Vk?)M#DFhCo?X(;cb7W6HL#&T81 z!u0G8c4=iB*Z<@*zdVq+3BOlg3&4C?_lV+Y?>2hmcuEN!T>FAOSGHV~{*R>derNN4 z`|urm)7IWpOKaAiLA6!1=s@gITkSnUR9jkFYO4{oTYK+Nd+)tR34$OZwkMzO^AFtl zCC70c@9TQK&Qm1H*CxAxwxcu09YJeSytlOk7j7e+tG>MO4&S>7=88}oh5RTDI}_Lx zC*fWtIc-P6QbZI|fST|abDq4&j4`};t%uLF2#aW_V=Uz;nf|^UjBGT`2qjqqD2i*S*yk3F zq*l6AWraN>zhWElyKqf#80v+cX{6n|<|=!-J1eyAt-5tykMolr?mQLR1!ph@DYQ{7uTn8(q3xdIRLKNrK`k9HBU#^u7Me+Oe>*8pR%h3J zt<_I>3q(K=si&nSuWdI-rDYYxCPpEXs}cdYw1%iW-ZY!qaR=yCxXb=+$^%)RaAUj| zK@I8U6YyjwAs0+%8v{23?NSNc)xP+C0kKmW+SuNLr0J<#DNYN_26>p1Je!sh+_bd` zc6>Yi&~;#f&dweitGXJHW>M- zPWnU#jlf}#*!)xPSjY<^)upI!^MxBUUJrkmu+pCDB9(z z+nAQt1rYaH?MqZvzfXf|H{Ec0&Su46*lP{`AxdbvuGWIPbm{~^m|R{$Yth0ZO&^c5216cUvZ09qP& zm~NKhni|5vglY$q8kra+i?@m;dG6;jA>Da)S5&!QlHMh--wE!pN-t5Ex&f%lTak06 z4$VQEZb(~q%g5bIRhUQ<i_%&~zlJM*;o{_XD z)r(>W;>XlCM}+SD>{PK(=cpZ`^(3e3NqFQ=1EY2}t74yGWU}pc<}x&NX2Q)+d()1Z zpAZh;5!x9Qu}crOQjL8?$o>;$^(~c^YpNPP?rHwxz3p6==>t&>Z5)}~qcSc#7lYC$ zhw)70pIwJ!JL14tCDnj8)2R*AeW<|M2Lar^?fE(90 z`1_d6;TiKLAGRd%;UtqznpW`L&UL{StOXH`PANpH#b@tl)7fU~{{r_Jd!_NQ_mPnz zW>Gxyc~ zrd!!k@;DuPl0NT&+~*(#SrO~D*IiPBREj|Qz2?(S_4fNO%2!B*AQQn%Rr}7+&j7Ks zk+UbLsUi>EImd58IK4y7g78)|gKqL4o%HMU{_Bw<1j>UqyS9mEkXXC=n-x_qfa-4x z0?#<=rr^c``iC^&AXGz|GE@@}G!;%NHBDF@eN``~bT7NIQoO!QU|ilD@;()x_&`8B z01Fm_RvLl<0Qc0Au$iFH)eK((zbZ>SbejRQ`!RD~NFF)g%e~ioe!Kss%v&+uE5zC> z{mwW^-(R0-c>|j3cS9@&9vRt^rUF_eqZNTdlJ_T9cYIN7(dxT*PR8DsaIaHRic5Ow z?F@d-`0`<)$;VV1ey%e7LSy*k>+bvF{u4)SX?Ynv8S7@~OX)e8e?v6LU_t_V5m2dTT zFpppyh@-5_Mtc9P^6*<^J-?OX^%@xAR_TK@mm@y5#^;i*1_$Lp6oE0Gtp^(TD)s<~ z*qc9(bZ7cZPVo00-@OEEz|7_S7LicM_?IsZEL`xYlMiwIT&C~5`Kkj=7A_Y)SRdDC z4BO@y_5IZ9NYK`hHYluUe3dkBOkH2ODB16g^D*{$+7X9n)=$84PE~x>uhAc3QHdZ{ zT~6H79Pp?SzZuP`N+{kS%(`K5ZgsYG?)g&Fy?x?1SKD9qz^wx9}fO$*4>@I z8&KEmmrjaY$j41v$7CH3v^8B744FI%;aW!Z!tV;gG+NCCj!w_D;lVd_yT`OQ2ei;y z8+^R~@h7zKp_{$8$kJ!p?)B3{V%_h)#3X@rF+Pu}u-* zXve?JLbyJ+`%_63?BdNO#lGk_Bs(Af@r(hrl*}DPzFerb3j*A^i?`c1q%f41yjbNmM8TOkq-Ut= zijv2X77o2a`;YjCq>3tor;4mVFOf^!Vx$?>u#qa)x>Y<^Gr&R(?M_?hM7W^QED_iK zddfdvWJgS<-H5-8%_-_rLqZ1OAZ&)Lwu;8CUi&FRf6zkeoJhc+l-}CK@rCBBLkd1^ zVsX253}oj$J8u?g(ZUecYM(0C`k33HaUNAs|9kskY7%uiS94URRNNK~Hg zn_}Hh5e6^XZFalL$k&iDx$$zs<3}yFqcq7Sln~OiofA4;HkUx>U~C$5&Tr3=v1$wL zWc0IpuKOSG)5cmAN$CXLd)Ap*ky!Goa@AreZ|Lq63kdjv_W7xAP&z;6KYdO$HgR5U zRx|;sDeoE&$O~wY0i8hzxu2eh;@ISC0j~vDXOUEeg;~RN;}br+7f8627%Jjt_mplw zA&Eg>Lx~aXx*dLNMqM>2m#MtjW!zpjPjc!d@@bK?(<2vDC$Al5g9XD=;*B2NO_5tv zCWiH7?HfR&SLL!iFr6s{GjbT0PLS?47lyJ!-Rxw$%Sfvt;5+DxTzG4)Vp17nZyj)X zS!wT?eYX}TUCmWTXUpZ5sIb{~+1DBALc6U9T-76)6Zu%)%%7Z74quhr_zLL#DUHMz zu=g6*lyA<4uZF4r%iph&XHaFkH|ezfC@v|PQxI65#9T~l^d}AG%Ak2P?5?zmbI8xK zBEtEVX$a5DWiKtFlRp zE1J~wdbG03u=e%VJ*ANU4E7sz@VF*_l)4_70tbV#0NfxsBR(nkh?ZSr{j?#H3x1lP zkb}e;7`hk27PxAo!NsvV$L<=={2MnFMuaa2F29c(EK;l_2pUiUL`$p61dWT|U%b@D z@zh0w&z}qQa3w!?{2n_^nprkInLrczKm(tSG)Ql#EhCghr z_c$SCllwCg8)LKM;$GKEy&}Rr3Z;s|qF3h%9-Gz6nmllcerVLN@u{b-IUkf37sHh} zdfG;`7Y2ic4pDFe+=;i#31p=`OouWqR7%p6?%9c?$Dw3C+gQJcblKVsP^@&UWesdl zipL4|qzzF5nUw_0p@AlMndvB9Z4X61G}An&AbAd^{o*gM$Ni$lRc}8h^Jgi%5UW+% zfi^BuVEyL_b(5zn_1+JUuJOT@5dg>73-=7Krf6Q*^wItGb;Z2Jl*gT!Ek!3RkC-eu zT=r?EBE40(kezcYB+O)PUJe>1->9^jXXDF9E$gMdRF?u!&JU7ck+wF?fu=Qy>Nb_W zTG9eR_y|4Yl@AHKf*pcHZRd7(*8sMdwL ze`}_$>H1voXeRnvE%-F-CgwjK@9T$&=b3|cc|>(60T!Z31EL!aVt|Bhg~yP^z?IAP z>kfFKMIeo@zmf|~_KZ4aa(nKu>}_ltUjB389XzDzsDQt+2|REu$Pw2d@baWHsnY(T zD1=;BJoQn@dDWd(sqZJSDA-4OnKUTGN(VHB=PJX%D`1Nj(prV1(Z!OWAX@CdxaSKY zMTd}zz_MxSOlMb&7*&Lz<;k}_y~XGSuAj7fk>MAY2%mLt=#yXAr%X$t%PrAe|4w|w zd|zc;U!I-c9px;04^eMDy|Tf# zxpBq7{lBmd=aQ+SpapDccm|Ml+4vlfIVq(Zz_?#8nKxI(y(!5wGqL#{gWZJKZ_Wv0#rj6r$je&sId3@KIKo)ie@bxCsZ>KPJ<7^p82 zP6dVsj^Jiz#_K>^5u(t>#>Mdog;pgATaDwt@$=L=W$zUp#{E8SBJ%ab~-|Jv9aX8Y!5N*u0|l=|?5&Xab+c>Iuw z*J7gUx6|w-)OI7=v;Exa3oY5L16RHIwW1MlNv(S&Wm#_qR*V}a)QZ9i8ssFWNEIY` zK1+`xlpQg-SGi=wWjCKWN)4=KDX9SjAjRLlJ^^o8ca_t9QAst!_^8zU{9+ljGlSst z-3{Glly=mTn9Qb1_@rjnNt|l1Jm=BAqrZw?>zg4tm$7BPy)(7pKKx^grY(*yLv3tX z?@jLc5&1sVW>iQ=xXk)R03r+tKke@B{`RQ--LCQtMwvh3Ml>Pz{)(tD?fGhUiYSp- ze}tgq^A|<;#m+9>+SC$~9t{+(y}Oz;Fqdi>H2?DH`G2hEmP|jFqjoWFwR8AGd}mG$ z>kqlo`jEc%6{+#?PFJo-a5NJ<8$V3qgAZeQR6I9~i%*2lEjLOR9p*8&wp`KDi2$0FzDK$KN3^fS(x+{< zk}vZ{uEj=`A)n_bf-P2Q4f6kynh`xrOJk0UMC$b48xM>f7I9ccv*y%RHVd}gY`63} zwOo{&$oU%WF9vdR1)r9O260|uU|dJ7@V}t}A!N5F%2Km+ih^N}g?@kg7Txnn0^L80 z;p&MQLQno+6Bn0oD1q@aNrk1a`F?>WlJ|j(4yCOkl$ARs-DGY>1YQsW4oWGl8(g|?s2V{}QkIropxOcu3shLawOr;2VP`udX*^Jy(^ z`a{hj`Xc7?{H|ArFMEZDdK?2GQwp`#*%G`8Y{avR0=;{SHuaT_4^e}KV*)Q(-=>aZ zC{_$gYjbigZfn7jLm5djW*6B_mupV8mIr+aPMfT!2?l0~TuLXxXREX={Pf81AFO{6+#KlG8;v`7d_7Ge?IJ|!+e;cdPn1f;{ ztet)F>|tjS;cNYeB-fxkxvf%ue6m9*B)H5faVPePJRO^VDCj|;U8ALoi%g>6rcrFo z4Cyhvre1jleiba&pCHlTyNIa1y0d{Y1|}}`!GDl3HY%cX6gz+b-)`}{23gXRdcCauntW;J(_F(1A=%C%j$G?&w65 zZqOnpaD#;J$@(J>#Sta=igsL^`o^KVC96IMw52ZK4E*VEA^gB<1}C;mDcUqb%b(l5 zu6E`{3+lpj_kZ4Am72)BJZuU(>cD(**p=A)0c9O>FSx+%|9mRxi7X_Dm~D+U{g=nU zTx#0iKiSW8%x*ityJA!;;?#d0M5s7+%&@`}=|r&)>(7k})r1sfE2_`|vzG&P3k|_~ zWgR2}ABjZ?FB}b>3B~Fx5?AnkJ{XV#`_WFguXQ_6{bCH{hF6h-TbGT{5hGVdUKtB$p+HKA-HdfZG-~# zY3O0rQ0S0E;zf-YBAE#gE+VREDQh5M?nzs9td8Gk4B{42dArFpjSyxdO`IK=6x)Un zbj-n*2#s9qSrfP1F!Phw6-&GA{YfI*4P|J^UAyfvqX)?hJ)gE8IpFzR({8o>=Y+p3 z<>*?4O%&St1NOYV_aLI1utNh6`5QfBrq+SSwqrsjR?t`}>qXehMR^DOLE6xo$mPwf z$MDx^){zGzCZ(oh(7$u>rd-ZV)TyrAhAXuU3@-0O zFIhL9Ua_wU1^Fn{O_uDiI6K^6G2fToWGE3nv8Us`xD^u}pf|u1$euhjR9C_j$aw1d zPH(&c!s|7{5AAyW@88VJJ-fxW1grb<;YQ&lOpIjI>^YnqgsAp%9!nvdGyb2o*3&j?l9Yx3u%h1$iVF{ z$_UWRP}foG(j?W};~670wLaE1ERo0kvBL~D?v~mW^=U;Vu010-{ZI8E-ammFZn^EWP2#yz%=p4NMy8loJzx^3-jOqMbE5?bPg7(B+&Fdg^lH4#X^ zY*W9yEF7)4HSK$*02E=$%*lTE3k-(Y@6Ra$y=PT?^*(X)lni;F{P(~WJve`XCEu>< zQ@NUMlbMFCW;WzsueOd#Mlw3F7dY`ui5=wQ`um@3)i*VZTpuqLa7enk{0fsS?jEaO zqmYFs^}f&-F>B_vTfR_nS*p8_97;<%`x03(Re!H=kEg!5k+%-lnbkdXpV7~#qR}kg zBly`cxcVQZI%nAqAG0>3G^}aXH z`tPf1gM(fJbOOW67rsoiJ7=a8!CAq#Qk*{B3&ya9*_eGtUE3@xgBgGfXmkR-q$^K!f zHb8dc+j{ZtBYQeb*`SYE?pgoZ!zpSel-SX zld*6JY(^Cw{g(e0`}f&L&<&6sS_c&D~YDl39T~kP&4_j~v*oGvs;yHWBZhXP0DZHliu?R(S&p8FI9k zJb&MsnaJb%TPzfP zTNbT=G!_$=Qg1KO8p@hdH`V4pArefs_p8ir0R>hiyF~?4RW}gA-CI* zCS83>bFYzH2h0|`H4WY@? z#ClKvev`k;VAIEssHb%KzGu$yk&NF_GZBL@%H!$0q#GayRYPbt+m(CytWpl zkXAAO)MG^*e5!;=C#dGD+H=d(oUdxIFv)`J9KW^KGA+^f!7}eQQ1i>zKL5?RoNy2* zZXY@$7!{q*-^srieq_^rEP98CIs8I9t5h72mGtUedU^IYdiV(>6{nIGQcCPNKi`-w zdebz$&q7pJ(_pFJhUbYI8X3iwm%IO-V5?|D%q+xO{l;foW)XauE+uL1v{-+wkRXSM z2ttaYx0(TH696B{UvuuAk3`5+ z%yi49eQHrgEk~0E-0-JlFek~F`)S@+FX?Y?#5p%XXc;W1PL@emeOuHsZh<}*kn0A_0GEwf-Ap25vQ2-^}R=MV>)B&2}pnr)|JQg zj+smbu4ke&s~k0aDlW-~k{(cHdnwmP zbvmzQPjvFbrikNq_`X*UY|E``rfffcpgC`zRDT-U z{8GNz#vfJeO9i~Ip7YplyN5@4`%+&ABEQvcjO9{#9IidRP{1yBUu$Iq9g&|6x`v3{ zoE5w7u$1n$E5JVil{5k$BEH|U7*%}=SP+2%%FsDkG&{t6N8GW7Pws+u(YKCl)at7~ z%4d}~oa5%PHf?T-A`g__wtQ=;Vt(`b61az56nqd8!kO(YKf;M&9<;eJlX@q{je8ZW zjBeNz33-b!k9OjkZpyuk{Tl*7wJ(Z_KuJSGerXw%`f*mdGSJbL&69%o`SUNX+}~wK zf6PXxLs2-x(%_Pl4VB0HN+U^pTGNNP#dDI?@=sqv51Kj)23)?^7=m&kK{GDs)BKtiK&I-BNTa^x_oKdvXEKGgjdRPf<;6!x?DLB zT%1{y7oVHFmAvAmTE$#+PYV<+)8N@Tg6I_dL9QvtggGR(&M)9KCl?Z}L?o-wU!NjX z82B+|+)ZTNX8lmZ9lv+1q}6^s;U70IZ;C<*~1&t;rE4j^=b!yiS1Fns7yY zI%n_a3TINVg~ot|lrt%=K;;wca~1iPzKBpy&!CeB>O6+t(~}^cOqQrBd{U+;38V#* zvdX0rbOdxE%I(z-TJxQM*!Q1uTt4FzBHlTL6&-`&snya*raWsX1B7bkkAoY%1wFuk zdG=G)Sl>Wzx!;ilD&?3^;9}=aM;Uy4t1x_zgc0|Z10I9u zy-brUJ=|6AKXdJiEzyx{$-JoKnOtl78whh~O|X5ceer~&2GLMDt?y4e1^wIP2;Ehx zB>O`Ago6u1N~9pOu`sHy_flwkdr7*sTE4W%GT-o9rm`s$HDRaaWXUhgUk3Z?m=y6k zSJQbC>l~fdpA*CawF^Vrbw?!q6}9Eky}@e~J^Dk#Y?(WmPm5N!m!ejh2la%P#|ww< zxO@V!`1tX-f&i`z#W} zu}<+x?}eh47hEfm$7xpBVUs5q#b1MY`>v+^Fy#gPN^=-(`B?Y$R!vHK(|2>E`Lu%} zjv+8ye%Ivp{qFERO+U}}ztL5_K^EKYZ;*~!!{9(i-@wTe)&nk-tc=7|$R<9U=xDB{ zrgk#>34L^h4E=A$VDUS9d>^ej5Etdy?j#(=_KfJDglzt#i_JCJ_#nrw)7(@eO#aJ4 zGziWt+qUBWsvRk({23dd6d1Z5PIGx5^Elj_cz{ez9gG=}*rrYU-(k%l@y3-QV^w4L z?7yEVr#HHy1m(~@k^c<iZ3*)aUQ5)NpKws1}*zb8^755kQFEEyyh$B zVBfyhmW8no^|)r}g*MUJl_9*dc8}A3G&F!_gz$*)U;Ee9rTvVilM8s?yy%Uleqs_9 zdVQCn1a@QXy&Jup@UnsSX>cC_@OrwdD=+>lF-wCqAO6AfU(LEVA$8i?FX(L-($J1bXTfNeVKGCmp@AMVe^Aa~*U0N}dR^Z;LPRKpLWU>@b` zRU95jV;>Tpy>} z^YBGPMNmIwg9UtM1Px zvdpB4Fa6n)&<)F_?=XHAVJJfpdS0-D?QOhFPfPZ(;~}^?_dm`Ec#P-F>%EDqyb8Vuu9L=LK3=VZsTvV=M^S=B zk={La5+nq`GmCHK=F$aBNgL{awe9KR8Iwq{YiB{T*?qKq>+P0{>g0eJm?qdaBI(`$ z`i|v{AbgnXD{fWSGQ}^AcKlfoxE*nJ8eUDZg^CVeKO@QQoL7ewM0Eec&#_w4wM(d? zt0H?>C+6M;`TFC-dIfgEBL~F$*Zy2gd7YSZH^uz|$&ZvMKlmDknSnfAW8dSH!9e|j@tU9y-r-Bz_`N?~*Cj+O<)jBtkF ze%otqH#RXw#vQltorQ};8z>9epCV^(UJLT)!}YO)LR%8=J>E8a%Tj#|Q*PDSl!vsl z2|8Z|5$z`a_@%|f*CK12XEoBhSXkwdU zG9js@{@6yqid|i+)$8so^$guDt`HWT#v9J|Xq{zYF*QJgy%w_VNNSKG{jc4tWj8rW z>uCqsGMYjUJazfJC~Z=@pX9)j;g$*>(YVkr&FdC@R4gp5K8B4tTyK{eY!;vw=hnWMNj=5}$FRCzCxK|mh-r^=fwMznV*nba_3Zy|8k5+pnvV*qD`XcmHOy_MU zrx>P(_4aO#XM`OLlBgWt1*dL`*B78*-d$g@f2V$B)cQ+tSMHlUth|}gdU?ebe(&!O zRFbpyj!iLb-5cbj>U)|1iJ9++N2PO2E5<4^C+wazS$4FM@dKnWtNT6%^Fk1?iu&B3 zNVzEGT***lhSKKket+B9XrftV zx%Cxv7$yRaVWC$(aB+6-onv*0ZjhD@p6Rg`7gtge{x6G9iI+&Hx*{Az<8H3eHyI0V z|62r}7w+KsJ7Uvbt4ulnpB9l7B9}g*_?5E`pItHNLiMCvN z{P#pEii5#^T`pk*C&JsS_&#m4IVmb>Sk5tV5WH9fxF)bD1L~UfX2unfq<*#md;x?A z|Nml0VplfC>~O7*0XW+=(A|8#!?&N&s~on+1*feBZUC)zS6-o>CHJE zck6QSjM|5VH$Ju=6GfM%;2Xrii*H)lLrho&=;?P9LJz!b*R|5BNO%kbyxGZ~m;Oc{ zh$>wrrv>lT+E%0STDbRVB`?T;ed9CA((rN9)H-@Z$c@_UxLiZPc2k-%wkAy(S3-@~!=$&}%TgN^Owo?QMi6N#eQ~|PTC8@aHfnamnXKDi=e~`21p>5f#66&XPnH7IaZ8^nkFH7W zY#grt6yZF^MkK0h#}n`h++0YHhANKBd}0G5w=E*d2Kb#%1mYu(FQ2JD+c<8_-$-CG zPf|vlsMiN=SC}+;bs|RE_qu6APL=R_KX{KQ{IdLoHcez@0i&vH^uw^Q@3Dm8-*0D* zSUv?ZAAY>hzHbm-XntXFwNR=+u7Wwz9p|nO3hOsc4Nx-aa?owkQrLYglY#t2ZyuSW z$Uk+wvclT8_Tf~ZDQDQ3J7O^5YyA~A@#gxX9SRdA zKT`OzMz;dzDoU185whYS+WqjzvE_XI(ESk>^K1vb5$vZt*c}){$J7kDOl5}e)FLm| zQ2!jyu$o{Kx^WVHf{Uvuw`91W4Nd3My^BY4Pd8%`7v-l<;RQ#SZ38jlQHDRsSI7{@7pM8o}yE z4wi;^Za@6yQpE^j;D;Vxcd(RwAVL#uHF=jR925NZw4D@ZZFT%PQ~@$fNJlvIsNbad z&-;=cyR&cK7wQ5G0|wKCYQGM3qBXVLn!i?yd1CA55{s+9hk`dbnVEZc3bd-zZY^XJ zTuSyC{{C$=85OF?RyZ^^ySIqX=KAYt`WMwDP^aOGT^3CGWS~1ZAADD5*3D*pyqP{%wif8*5dP8fxg|L;ObAkb^To0kuPOh~9Wdq0(SXJ~4EkoqIlf_B65m%FR0mh^N|uD(gk?phtaXJrj( zB4a-O@Gz$GcIBCh_|%trYs8rXtxBKS!jc!jjvBhGKx}?6#H3tU@8y4E@hh*h*C%$$ z^`DP+<`BGCuCE};>zLzRxwk$kF0C$~L_)ID|@-^S+F`q>1G&@<-)T8*k>m+9p9V zzDbZxBlO4VJEhB%o1N+K{GXb}x$FX4k5+B3IFSRVehmcE%~B-$*77g02umcbp!Y`oT21Ia_G1GJRl=z zpF)B4L-46gUVF^IC3i3F?MqmBU7bDOUD0K)>*{Hj+yY) zYemhlKDrZ%^|)gJe?$Sd1qHx4!B*O0>1I|t|6_I4xWOltWKhm+NY$lok~nsLzI~4K zW~0`w1QyuL;85F0LOnF}qQ9-}!&|nO+r>qi(v8*!oTArFYU{kMe}lC-kJh{G+x~SD zWJdbxa=U1R4_WP@t7NsHb-V~+u37J4p*vQcv+W_Aec9;!oi*~*Nb?e(n=e6GtJ}Tq z{uh(Wn#HfBBSTvQ|9RS+gg!P$!*2$ZN%zA!-q+C*%ljSZ=ua;;;=F?!Joa{;*1N4L z)r(2;)jsRq*zBl_8XoSSu<9xT0?6EM$&~$hk?Ye+kxAYvNYMQFlLf>iQa;?I{Sv_m z=O?eg&{>dCos3)AGzTp(J)JGkIRtlIaG5C=w>8AYOGX!UJ}DVN6RIq~D1UD`#WUdQ zuBv#^-aXskIMW!NF@&_S_R-fiXO5*rr^hbe?CbgCnms*Ec8Lw~1i+MS7Ntt!!<(iZ zptWh@Sjc5>x34r98xNA4E-{fng@}T2U$4SYpD6KbysZjDP*cF(pQiI2EfU~+^zv&{ zWwH&$ufPxO95M@5Zi`>-bEE(lBLNla*EKkqzJr7KP|nSv>@oL#%=tPshHJw8@YkCE z^_;v07wIPXX4e!?VmA`C?8G@0e3Ma8ghT``)XVklmVOe|S~{!u|BDr6{NUm$^)Fi? zT`ln@wiOYs$4+EoUee(H47$@F&BN%r{^nlpUgM3DY?s^hLen$%s$X`kNGXRjI8)N{ z2F3v)GV~qa0oP@oQsp{_{$tIq1Kj@0{D^*J9!f*nI++ff!r@T_(nT z70OJrzNXpN9(^BX5eBFzQg(L#b-k0*iBj0vd3stPdo4|+sRq%>pFU7~U?H21%L?3?2@wIPJDz$x0Eb z&?P0{>PL;|jo>|?8M@%XVY%fWUC66~vgO8L(>6t!(ln_R5`et68S)UH{n3(B7Bp^k zP5(I%70tYby|F_pFS9p(_cA|d#HVG%FvrIOX;aP7E~$54y)L{L%iGV?Y%m)6EDI-8 z0a?nc?IDUeSh^efB1f=2>z4O*ZL;6HJ%CZ)g}d^r5bNai0XVP}Qobvl^88Yq0N%5q?3wqYs9W^R8lQxyX}%k-?eSE7BEK7|;-N^>Dsaq0$9o%{qJIlKQm)NqDW#bLCQMMHx! z^X2%sRgi{izj_W?NjX=h)DyN2MX_2da3?%FR&sb+^d7*}^(X)pf)lXx#NZCFRK07|?8*hOF8axiI3`kLKv!IPc>4X9#Kg_tUC_IZT)bDsrKP(0 z3o0_Ea6L?2((vkaDp`kZFk$23JSAyF&!SpM`fG1Z_pg2rjtt*k=7Z#FFxn#xM>O1J82m7*^{o(KwA@~dzH0bEf0nEzsxdE^Dr{uFiLB4a??(j**IxzXYkYwui(o3hp$Z(@ z7&hbWqnm2sLC4xSD5HRGX8NZArBkI_A#vkyTqprC1rbjKB|@U}0<=sWTHL;TaR>!n zU;7 zf9YI<9PJr&_KE9R#K{g$O;9&eMLFs~hvmFK%Tb1IOnVGWg0-2y3i=QcQmZ}VszMTs zMyV*R_Jdn4?${(abMZ}2m!>;;&QrynUqN_UxvAZBT=9OFR^`(%7cZ}mB__@HRZ0Li zp^qm?H(M7+f(-#!`4+;`m^{GDaNDi%VS<*_!+%;{hiwHQAhkdCHNC|z3V7+^FRnHS zaCJ~`JbuX-Npc?M{GjGZ<)s|ELvWmX+$NI+$7Xd!MW1KGkmvba=pj{*U05K&zuq&M zP5FRVAQ14lu+Zsv-&l0)6=SP<4rogL_>&LC`Rw{uz2I?ax2WH8nZfAuWbHI1jeKo* z-W%lbc+UXQ%g>wk0X%#^<~G;JDejHaYa^*z6M9*Im`PH=NX5*+EWn(NzOvu(jl%aW z%8_K0offKkQTx@E38dI}sd72ubG2G}Ukkz>Xf5G7(ViZS%&;3io2PhZA;ea~et+?9 zi(c3+;!W_-8KWmoH2*DVc`YRJuQS`3O7LI{BB40HB9QNyMN4w`J`Q@Wt?`(RAF2 z`^Ao-w1Cv}uG$t;c!QJA{3&+bT&4#Z9>08Dw7G?HG_-1wLKX>k@Bf3FG-ja zx&d>K6ox5h-KrC z8GW|eWb8^_Gt#s@O+s==b#~JITH!KRX-A2gwOwR>eXDM*9jP82JVq+{VCA@tQuKYL zL&FJn!@R>D(Hb`KOyI+Ea(+u&!F?|Jq0jQzz7!m-xbCEd72s%N@pc3NfFy~<|V$q=N{s6AYL zd4@E2ASt6g==cnP``mGWHpl-mafz3p&wyv8e7W@ikIfJxN_K!&-?vfGfF02J({j`C zf(V!&YZ^TnRddvZ8Nh?(JzJrP$;FDL$C-SF7d=RdpQw~|e5?F~ zF#fn^Of-v%_cb^AUUcJEvIwkVCvRo^Kc#5(ya(-pW^0e!oeP6r0{uKYTqg|E^e~PS zO1HaNlv981&E5e~`@d*)hq&g(-%b{44~&k09v)B)YDbgjkjLElfh=o5IrS5S{!&&k zg|X$Ifhj)O3UplmnswLYe>}z%WMIHnF ze5}&Y`Tn5*Xba>+^#02Q;jIV61^@j2e)lAsW(z(lgj| z-Rw0pXmjeH8h_d9c?a_Afd0YNw3bR`+=wglE4mhO02w)hE&$^O^xq@8SG3&r-_TA^ z_~Vt@lsXCO!kq*i{)}ey3*P<}J3S=*B!2njA&r)MEk!ujQTaiN8!E#aLcq)3?5F+lB%%Z& zc&PNnX&RK{FeQkIxwt!Y@!@zmg7a%Z=u_|%@#WKF_0zvKf2W&Gv`0F&h#hEEu%Y*9+ zbU#wC#dpw`_oLv`C)6LMNTCt&F||IH4HW7@kxzlZ@vAOJr|4()X( zl$8&9YN!i+Q9chZW3~BG8Ch@^x=7c`(hiQpBDUCG6r^)|_d*$4erB?g8u;s7&8Uw;Yo9obSc> z_;~!&hsz!b;wh4XcL`SVZ?O3zT;CtQ89Mat)s;`j^B=)^p54)-Q=55FSGA?o5ZvIh zp?H3ahV^Zx5fsPE4rM~ZpVjY85ketBDi7Z^XFMm3dfV!Hc}D&d&YAB7ze~YA?F~}d za}_%#{l$5GB9}$Z>u8m0@@p7;6$3syP?GoGluYNUSBa|}m#n7CI)g;nCR$Y`Yrf%2 zXCM>%`ShX1o!(+fpo0EjC)9%C2emA2MTP116D}YB7(Trc(!{gL`8MX@;6{hQyW$6_ zp{Lg7P1uL@{K$+_O5r(h&DDH?s|lE^rnUh6wLfAdT(Y%bT(Y&R^m!x;;=~O8uvi8> z-)~EEA1bj~9y2sD(Z-w32G6No_JHA*@q zMmKD*0nfg_=bYy}|Lp86{@U5=ec$)q*S$$mL*npJ5d(~dvq9!Z!pw1$E&BL@G9?BX zY4#!GeX1lUmKJ`x!4|yRhF@6`f%fy1pQo)Cc4FPA3UcD5;LSEA5PHT-c6poM0YoYT zsm^B}-g$uYT`9{o--`QL4a?E{tNUltv)L-w8!!v;BIM$$d(F!GVmC*^cn(jF-l2F> zvf-6hvud!dx>Qo1qjc}#1GHgnR-?Nc`M8#IRpY$jyKSCy`3Pwa-pRa3QW(U*XFqvb zz3myOD49O|8AQmc+Nez!Hb31&v#H-Hl_kjbkx1YEu0zh8P;DbuXJ4J@!3%9YC*@U@ zq%?^o^`}p=k0yd~*6(M{IcU`l0xWR5UaiiFkANJjqHL=ToTS@}jqf9~#moqCRrB$= z40|q`|7%(~|G8@48I2D#x@*WI$a;#dO?`U!K0rSFjKBDMRP=shMj<6#sQ@eGm@0aenW6t> zG3r~J66olD!pf7VsG47!px_iCAKO=-jyXL`AJ8aM?Yy9StaX)Ml*QFSH?0^@)4DuW z%)jYooTFC2O{)@Nnj0lv-Qy3w{Xidn=o8;{FU!O$+Nnc&$2n3i6Bhcq`zC#F>;(@Y zqkpMMM;vpeX`de0vSm{d-K*BX(ei88!Pa~Ohk%d3KW@^OC#w8n+6k7@zULO>F+Mj1 z+*9O!Y$V84URo{B;25Kq;Xk6qUdg$EtfDfdZMk>~Alc^0?nG4V0sWq6>YuD-{s8=t3*SUd}PejUrVi?eQ`GX13Tn(w;9RuiU6ehk$N=RIP z&X*?-29Uw?aq`G3a<2X{$G77$;kq=ok=Bqb#S`@pj?o7lgxC#GO~xPS0pD=gbD>~dJ z@}+y~CY9~z*Dk3yy%PMUqE;fS1O^4jipL-98l#wA`{cj*=gd+PvMzTMW0d8LcsnLr zFnwd+_jO~dFE@kXPzRK@AC-fcH4`z&V2OfoDIYk8{C9iU6bdoBn+R%YC8opPUkoX0 zg$pkb)oeQi5=*idK@`Y z6ia`a8><{g{qV-+)xmKGzoTIz%ZKkd`YA~_)f)du6X_j_VJ4kh?%|g_SD2f=j=K48 zPXSnshY80HFG^$+`Q&78>Oh-Mo$FBWb25W%7&HIy?oC=iUDgav#-|Q2@#m_)9irU$ zn56s17qSP_l6>WqmBhp>o#nxHf?`I%wKPeFBmiv$fc(<@%4v7LJIzNcBXR_ix^%H!4- zbk=R?`lT(ehE$e6(!AUyKDwN>y;u(9Jdb{H^eoZyeq$LM*L%6|IoZ`}X43R__1^}^$wE?z`@nGne|{+Mcb(Om2c0-5@5@ZK!jq`03tv~ zwNfbqzb9e)@+R^g6>mf*s!cB$*uQZ5!5=!)${CB)6_*tI=c%8$!WluFpfBLX5y=kM zMw`6Hl0rtUi8t8o?39}jhi+zAiGo`i2NkAoX4QNbOuL**dKWn8wLiUk16CD?D@VRv zPyz`~K6IyhCJ*ybv%6UdVW*j+UoZm&1OePw1;q19OUz#%hNqNgh$};D67t(EwPVT@8k>`>SJ(+x&{sjTr)aEy>;#U$iG5tKPdz z8Fv!huHoxlD%aa@oh}LwX7)s{KW3CnCw)_BUwN2a2rV(jVfekhsfJsiHlSST=n%3#0Md<~<+Cg#M#h)^>iolZc zloQtucTI$2wm*xzI1VxT*!5gp8mk753v$(CAsp6gO zs})la58AUgOZ}a*d0QIE*HM@;hc6e<5vIdf{su9ODvJ*$fFjR|)Xoaw{uCUv*@AvpEnn+m zK_CvOo-ijJ%b>>QUpTYjr0j5M(KkWVigT?^>Es>(br%?qJRm)rt(6}4&9U*v^_H+I z`$6FAp=4WYMMy7)@Sw8--xY*Rot!i-4uK76{&C*t9=csXna9&Vc9_G}WKt+kL#?!{ zbES6z_a!c|7mRy!5j1z7S)W;OS^TmMJ$z8V5Pv6R_FhAB`ArHnMEN4^$x430B7{MG z;N+B_o?Wz`a4qCXB`7a*@wuKNy~6le>jbUQc@tdV*DK5}%St=-lS_p491=Iab?f+% zqiSHNb?yvqv^s3(C!}frT)^*65eT!}#<7A6JCp70>+6K9>(H!z`mhJ$LGZS~I6SE6 z0yii8F$U#>%k8NE_I~dDLdn6AS65t~f>4P_F>_HZVoCbJ`9R7AZ z?y8L5Gtp_Y_e+5jsmSZ$Xk}R5UeNsuq>sjV}d#FTzEluShUFX zvq_$G+3N$~B%3UyNv5fRvOVDx(tlwv(L`j|lOWkdm-+Pw$IX zD=1RMIvU?z_8eM9)wg8%#A4aKSB->ye3sQ%UUsLPPT#K zCJ33Y;R6q-GAm~cEw@j`97}74K$Gi6GE5HcjgzAW)oM#T-$38@WAut0o3AZ1x!!?) zHFBIJhp>YW(xH7x_G6y;q2rFDUZV?S!?2Sfg>;*v3fG|bn@yyxw{`V9d5yH>vyE!X zuHH%2`n2-oa_X+q)YVy7q(wpR(Pesnb7}8Ej%-x!VL)1HjM19h_sYRe zBQc(joxd)A{Kp_C`!s29m9w;bgoecpocM{8pV<|mct>9S(?|e=QO75+@&%cP@!E3m z78_5bszhP&`#6T!zh9P%ZE)JZ8!fqZ9$DmEYta~Al=QUO;&h4jq=c{9gYJJ}zhoOG z9L|)Vq;#gz+H7^tnS!iaiVg;Uw4gH|WEnQ-F!&CcN;!(YjeWloGS$R05Jy55+(r(` zF7O-k7+k*N#_QA1q&;mAvC#WRSJf%woVP4hZdx6#XT=3ST zl316Qg@&;rt}kdT7jW(>1P?bO0ET^%W@?(#=97hQL)-KS(+yk%(U^5b(ME{|MD;`t zSJQ%#(^FHow`H+Ns%_A7Dj5!&jC?)&Bm#6b9Q5R}5Vze0AVbj{`QCl!Y?wtYVI7nw zu*NUA_8@3$>@IQ1_|Z7LU?xtoN2hC4g%EQL)_UvL`k=)@-j)Gn-c;?`#8i6)J0SxN zU$vAER{`x_kb`u_PZpWz&NKpJWr6_D#4qS-`Z|T2=|WC8XxnUDAek&-zCxGmEd?zF z-T2GgZz<#4qkXN2%VUbYr{;?jpjT{miRCCkqLQ`;BaxxrU;H9(FIy(i`dON4avaQzP)umR z$;sWr8)oN#;R%1OUs}pHMgCZi^lS2rZS!PpyF^hFD(LA_J+JqA+Z_3&bOTJzA|1rw zv{Ra#ns!_iHe98M2|f#OITvaibMI~2@^tU44rVJ zn8OcxYKablfJ&?se-_Oo7or~e8}n0AlV4IVb_Kg)FE8&4DWs;7urkcViuK>49WXs?S0epb zxj|Jrrb(A;tW>d(v3XoU$+CL;?v{#mF5f8I{+soZfNf5l^yHS}yWDnn z>P{zav>3`;DgOm3hDK9RnJ2$Bb6tDL#_Mi+>Z9WYWNOdXB>ctnwKC0aezk%xNsy5})eNUL=HzkKa($GBNCX~!AJR;@Kvf0aw(F44AQvO`69Uyl4Nj55G2V)G3=IX zR2GVtR&*;wIg`dPZXE;CpK?+?)6e4Q_iILrz`P2@r4!TF9&36SQKou2eV8=QVgiou zeaszrL>K=Zog5qINsn<)n}%#04s%q|6jXg1c#5~oZeARh(fgT z3g0iKvSyT}!)Axnq=M8rrF5*QJYjPk(st6@ad{)S{8RQi{Gv}K4t_G{`GH6Eo;v`1 z)^_`AT-jvI5%tN^;DQP*|Appq{yaWGh|XfQTk43VhE>By)hd)zB(Y7Z%@=i<7*m0BLGKtcgCY8J?jZtmy4weJNd5iCl~Updw;Teq@e zd0XTWW&qh|mqwlYF<_7FPW;C{mjc?Q2W!&n(LEIB%kvS#WuGSobLQA2Q63kfq~8gH zGa(y~yg&WGYt7$Llo#|>H*HbBp{5lXs}-uHXx%BPjnb07_?{8Vhp5&Qx3@!PC1{8B zz`lqlB&>u=l+u3u7n7`iL+76}Gv^XT}~;A&^c3;P#CB6cxDtXje*wa8Is%-efjY{4R)=eyWSW zki}5|Qy{#p!+(XyGhd;3{F;5ZmXhxdto1nk1CPuTvfJuhF|XE4@$N62wXlCR!nYZ- zt|hqUdF}DmNox;v`?l^+c$rdf+_gHe>bx%e+6i_w#ovEIg@ca=;T}nNm~{<kY?y_B zfgeYr(TcdvUMLAd3vL->EzkT=H!&vS(2MJXEmJ}1KT)i2iqP@l2fyP`HfgTXq% z59#1A1-dbsmJmVmapt5W9R+!s(~oXaS0B4RykqkMHC>aWnuR)O_L@$tn~wFOmP1mv zj3X`k{Q177C3iQfUif(Nq6>e^JbzAO_U+Nmq}#S1GV+rCxLPirX*k_I=xczQ+`g1Q zo)(0;(M`5>xzK~&oWT3woCaNkkJ36;>)=;&b>C@FpHPt%<>mF?vb{YRb6_5-!13im zpeo1&7#V2XJ#puo+o#x|bIN{s5IFerHjTd~(71HHi1#R&E)Oja}nNoGicTZ<|bqk=T+pp=ANM3L$kk3U~^~ei%f5H?#U%f)}cKy1LFkpfS7I zo$95_-N(ul*66)-fmmSRUNaX|aWI2%IQPo{Fnvb3{diJT0Lb|18rj3L{m_@-%PATe z)!+pUXeNSts#fbJrj;8u3LlL82Y6O1>_;axU04>2F=bBehDMFa0)QU2#I23`f$jxR z{H;ItKD}ck3gbUkVv!QPw>$+RTvSC|U$UlLT)hYK0rjs}x>Z&`rwg}U#sHT=rgsm% z{fXhAu2+X*TY;yZ0UyA}DGV1t!~%UPBLWbYCi()Kr7-gBA`J55|s`PE}rA zHz`Q`or!5zN6FuRvzz}|n^3y67d<|7`e080XKf_>Ao^(moQjSq1+l_7#NW0*6b^g_5a3@25N&(Fk;37i6nDO1BHGnt*g+$R|8s&kWyN{c0Ihv67 zot*TRU%6nrrr2qq5E1-ZPNlV9Kl9Z`wC5`D%Q#x-z4{P2hoI8J;OR9YdK zBp^(0(`xO#A(A79bzJ@ZeCqC)Z(Si}W2L5xkbq34Ms}QOS;VY7TM>C{{iaHAPvGbZ zDZ(E_Pd)r_ktF|JM(jx*(pIwY@zxkb7GgarUM?+y@70JPbbT=|<4SPlH#%xner5wc z4QdhDsxrOx%N=>3dGz^Ouk;a*@ zbyu^?;R}RCdIALe_E)d>7^bpA20w1eea3gw8#(^lH{Mwx{i2b$@?C$7$lMH4NDXO4 z-f0aa%}D$=xVIt@;zS;(alpyx2Gf7@*-9Y9aA)Zqstc|GLU>hKzUieqFMdV0#Bswq zCvY~@oZk`O_}BbDl{g1cle80gBV?6P6jU-##^@3aN?7&mnlTYBXfq*Zf5mBxP1MA|G`Jj#3@{o^{U2kKovvjKgfW zVrN748Fj9|y)<7w?s31=?D7heSdfWW0Xdd|454G$feM2E-IkTreJ$pi%Yp~nvf6>%c$Cl2%*H5zPvD*g+ z?3uSQ8UJ<*Vk0q(a)iLu2FPD7H1nssYpCj{oA1QnvnZzG zIcOf}gM662Rw#Mvv!RiDo$!+!ZJOBN*pIhDSAHB!C8IH-`KU@wIF?f0%I)|)NI7Ut zR$103T*KMPH6$S3=}M~{4y~B2XCm}AKZ4yDL`B_W^!`+U1^@+&SJ;CwDkPO@i}V|LPqY#D-x@vNXvueh zJdFKc7=Lk!NXPH0D&Pp0u!E9uJyQMllG+aWY~=lFtrVZQ*=~0*@DDai$t4lto6z-c zK30Z*mVM*Y>hi`Qix|rUozW!BhGF@FS75;uE{;0t3MbyI`$Z_3=3(a>K!b0iN*~yl z>`b7^(fV5zg9@|StP$Zu_fOT%G&AZ7i0ES9n-(^rLYaGb9tW=9yR(Hd^ny>k%bqr? zVV-8oz6q&%x~XwxXQlJVBz>bQa0cbP5jx5mQ1nH!<|=!P#sycw(Mg(mOx;Q2$MXlJ zRWYINRWuD#H7a4~>FVZ;{X;A?Z?got1v@CN_;C_Pjj2GHuEo zzYNe;^93y?!Jc)~)&vY?XV1!{+l=_q@O3Zw1oCaMo_oYxTmBqCxdl}B9!~!0xWeC( zIf6aFP1uGblc8bc-LlhJN-k`D=-M+&=gEMDg^3O2p0=#?*^sJ>k8rymIVO(d<|(&> zR2v>aM>m~~^IiCv=ImJOvco%@2KS2foJWcIo}>HH&9xe%WnLEwBI!cAC6T$48*-w& zAFlAbdAU9JiB3dHxeHE98|RL&(0o;Q@4h!d?NVu6)aUjV-aPE;8#<2g|58_?`%=`= zeF{1!j6{4+HDR%Z9aDj z#M_?QFY*dI#8lP~E>b$~FpLEcyOEDil?qIppjvh+K){b}El{jWpeK@>de~fQkMz78isQPU z3&g3w?BozJj59IM9;f=OeyzhWvYj%ErGP$PX5nIGx%&Bcs6+fESLRiJ(C6JV5QeRo zv0tG4^1ciJ9Wh(P1#8X56r(LH-=`<4zL9I%l_7D~UP@x0>=v$T&+Pk7A@(DzO=f%% zkxX4b4!KK4FPnxR?H=}frfJ#LQ)LJV-)Dyqq8yZ4gWg3Ii0cJO!pHNT<&$|Fq^9$zNA{iV zzkR`3l71FRB@^yzxmCqGtNE|PR|C3m4PWO?RS53C%k4Ggpw%2_+9{#3#l5B3ZazLWw^7FqLPl;&tbRZ1)sRw z;F1UI|BTII7XCH`YErb(lhpThX zjiSObXD}pBicY=6EU>#vBPw`G+3V6NGI{flV-CuXXbIcj_q}vz2x?h%Eg)vBfuB9Q zV)K;|TE_aQ{IBK5!$YZwvDzNZm-8q#;H#;)$*rV71UC zm75kp^TFb^k!Vt0+hYv?(PD`OIApJ1mH}W&VBY;MaPZ|=n|WCdb>Hr?i!#fp`m@(> z*)*Sfy{wzR?Xi)$?El%X!hJ&fyEE)a?H1ZP?{SHGMaZ;65QP-Fdbn(T?Kr|%3D;Ed zq<2k>X-x!wTr;@-6;- z3n74H_A1$cF=pP~+YOlu)zytbTI0`q0EO|j^^OY0z1`0*HjeJ%S3AqIF+6iWHjTjd z>Z{9w{Tr(dcnsZYmQHFhn8QRHktb=YBGsUm73C4UnE}SOvG)b5g=BuW>x4JeT9ed( z7SB<`u8|L4jtQk|Yr)lCs*?@tHEZ>o{Mq$hXsz`|2g)rX({r>sQ9UAHnoNGa+Wpq1 z++pQ#@FtABv#_52|+u$&`rsSH*=6 z?}wce!nP~M{maTdE7muHYc8%B;0yO(vJBYwPd)fBGFFZnrEOtekN6s(AG3M%86O-% zk+2&4#hVp~(?4%aYK|7-PkP1`QYJj^WZmO+7LjH#eqQb7YFUCWww%N9MqAu)E|I#= zbIx=*D|bo9KoATTvh-Yb4W*GW)do}%dQl3miX9|2UQ`xDCBCX>tfty{F=FOUaRhVK z|M(`k!!ZbQH@$@AAuuyPczVqOq~$I(lU zxV`uLl4ATiV#WXZFJ6R1v@HZ1 z%w&hbQSF}=-`;{mBRXJO46((YTDjJaDGaV40#K;EsEVB2&yjC&p`E)GI?sz{v8ATF zt$Qz;I_hlSR9rC5+cHNP8!Hb)-1Z3*j=r)23RN+vGP`oW^g>h;K0--L$8zQlB6OUn zat~ibU3k~cuAq}f)ZD&#Jk4m8jg<(xSZT$SJhtXac^r(KvO5}0qo#{)~1iC%d0)BCf_@-+X_T3#LGs;rkbay z@@wMIa_iy$|lvhi4{QT+G&0&W!(2w3Er!Tth}V{r498%2EI7 zP?50z1&kK)6u3a)>H|f{@7^;4b%;cX8jQ&Kbm!JJVtExb0pJAL?w#Eg=?|0)+1W+Y zzFKw4Qmp(oxmxF5b9nb26}hAkbk>bJ*P(lw5EV>Mo^O>BB)2Wx3_kUW^VpoKHty%3(>LhQ4`FyG{xXN9Y;&ikNaO(H3Y#Bm>m$=8KHJ9SpX3nMWHcns$0z5L8>5?A6Jgnxn(D2rRS@MsWyzu z(p=O(*D`wI>XB@aLFrwRj_)TPuTUl=8RQ5=0hI=Oi$_)}K>qf`s})Nt zD9e(=@Vw-H5vJ+TW~E00tuTq#5IWs868v{Kelrp?yREJ~Yc)XdI`nMUphoz5>It3707%|{~eO;hIMW0zSf$MQeUHki;_ zhvItJbd`Yq=UHy_PR=eNe)eY!-VBzQ!3MXdG6%dX#4IPVNuOHh3>>U`8XNmXD}z2*rgg-mjO+48j? zM|!Xk-{7jGUi!6JddE9qY#O@Km~+&=n0K5J7Yr8(0wmv;r|38CJj?lZN!gVKp^(Ge zfSM3lg#xMX>mVK16HAUgA2n(6wUnbJK6(3W)ztrRcHsA1cxQZZ^ zlkh!>-aM@7Wvm4k2GwJ5$rxl#?>b>^G!`YMQ~vKzJ0v2)1;X$Cm^x_= zkXtIwh#BhqxKCLsNG|rdP7g&?e1bR&{No|~+^4!o2cmz$5^gXjy2ZBY!m7_W$7iRG z2;t^p$}wwvqriFyaGKqsB}xdDSn6qKgWrC;nv+(*M4R01KwoLT4ttH9r4I1;T> zPFXEjj0l1;6<`)YVegQqS)|VU(d7_3S>Oe5b)K2Cyv{nGeo}^Mgr0>7u!|tkNEVeu zgVezHsaK+0!sTbA5dm!~g0g$HD%rccG2kwc!EakSNlNWa3C5xpR(oahieQhU=)2c{ zaC<7VY~zm~=Jm~*~5e4$I9y=5A9*^yC-z??V2Blgm)baXQ7eH zAQr!fa>bFaT?An}#0GRZ63tAwJOX05;!AVeT)L<@0-ZYg5)UTa8a!P#CgP)9&#qn* zV?ERho)s^>7P>9IWx;ln?eHoF!;;JVb>2tm=j+{5_M+gMI*wTk{GA_ncv0!>z509p z^Xm!8(@F&omKByfGO`;|RmyYg#L{@S;D}F4Q(m}&L;>k3gJQ#PfJR~&g%Xa^2bcM~}^bg0-XqnCaX*er|quJKDL9Vf4eEy1z%~NZtuC!q}-0u)UI;aL86mL^J zl{FlBo14pA;U4g2UtY*@Ew@?GNiIJE-r_BCdY{6>1mUkr52EfiO;J6Bv@r2A^Q#OC z{DRKGX+W%p%Rw- z=be1@+cUER(ggDPN?K7?PUIO;X1WT`uX?a^dawv345SS?mzb7xPQ7l+!(#ha#%|j* z2KN?hNBnroE@%3c*+1RN%G!Ai^lvq!VCKb!o)t2Av$GCF)*BW@3 zaU)CRUQv7B5OGRUUyHp(nEnFrzM#$T)i1%f^qf1X2ul2QPO%)z%-v9Cxpjh3dIq{9 zJw-M0?B+@LY}E;=S)TRGD}{ZL%_ZS-AG@fKSzD_ ze8VJoCAYQGdzNnmx?0w77GsccdjPT$1#E_x`;eLhg6?0^MHIn;5S-l{XD?JxLy@TS zyNh^S^%+bm2&N#kpA zS_YYOI-1!ZI1aisI(^`f5a-JVl5rFS&H#XaS-`i|`svoskXmQ|G7L$0{je`|z3%j2 zIHQhm74@KeDy(UF1%wKqjhlDHlKz}I%!D6=+R*J!UlIqru}=@OAbNDlACqclCsjZx33m#)#A$S%G`{%XCyX2=M0)*rzZpZYE7*k zTXi<=+k5p1^)(pum%RqsvR)|?sLZXkG2(Po!3!Q-xf#$nF)%9woiwLBqY(H*-zN^9 zo$h~@lMjgh@R3@o*N~nl0+=!mfZm!e-$E23AE&ZRGqymnO4$2aO7tri2L332W}KL^ z&ONNU;^`US;(Haavl7hH{@rr9;8p3<>Ox94VW-8Hok!7bq1FrHm^wl2^i#`q_o^1V9UO-p15af_K?rNV2Taicp+H0#(k% zRrAk(zYsw>R2R)e3#fUMwVrH1Rz4Z&=$ayso^M0{w9#Nc@7G32)>!N7Qr|0hK$HBc zvcU)0Wed|hP;Loi%!&cAg7}w-`@$_ZtEsMh;n#oingBOQ`z_eU8j&<9U~EI7ea`m^R(9v|S-~1YF2$S}%KAtIMSbUA>5xBlYlXs{a6Yha@KOxVis7 z@GaWEDL@Wq4ZDcszTXUGr;PHGBQUv!hmOt|PPnc0Vhu9B`vtNyn_yDw6xFpxC}TR9 zrb7*n<66D4q~XviM&){ZD>Zy25({`=XWU^10k%J$B{h-%>4vY}8khTM!gY*~&}%Ok zkN7^Wr?{7$b!`w@umkmoi4kB1G8}rlpTgvH+1M7q^@rGMzKg`+YlML?C|PPcY<7D! z?M38DQY2xZ>6~mBygTl^8i+pAGF086Q*FTC3?}D_h^727&j0&H2{8V>{qQMYpr4;! z&h3z=<%t=LONac*CV__&@-yB&Ke55Zn)IlJqP42if4WpM0(-XQ+cN_h1O%+~MQ;JA zZP#7>Wvj}zyF$tw$v4jPIz4}0LGIP|Tk4C(s@vKf$K3m8v`O^(e(DH{vG`7=JU36B zmNQ&ctw=gE$+QIkit>#0xU$Bj4HqTdH#&mTT&N_a!FrI=da^HF?2h1H*pAhxw#H_jD2zY1~j^LW|b z(IL#ZGv7)Qa-7@VKBGE4sySCPR6TsgG0atb!^59#Z+-g}HGhc+R_k=_CuR~r41Y7M zY4kq7qcsv_jhXrD?>^7o0gCriT|z^` zz_si51}a82OEvM{<*k&e9s(SIl~3Vks}9Soa86r}2hq+QM~di;6ji8ecgOg6(6`Cc zG-cJi(i5uy!`ssD#6z2Tjzd$imA3gYb!V0{apZ|&&%|lfnr=n=7aQ{YztR~}#vMsf z#o-g#p$9w;_orpjDRp0I@vDl`lUpOR6fwzu2xb~^$Ld8$rAjfz-ae0^WZeCU3EL$1 zFhws=B}kCQ6XVVC`MwqS8k2E~$ZFYM|Fl%jej%sYGSau9@9?Twz`AvI=GtkOS0)9r z=W`e^6hn3-(_@XD>x5ct1yywad}K-Sz4?j#?Iju(iUR~9abYXtUMK|!AN!$ zwtIS+*(e*@V&aeI+YEOX&PbLfCHVZJ&TY*i9!S{mtGT2)!_W_#yKlea5 z;9;qp#2fo7r*d7|mSx}^-93Ecer4rt_rbnBUhb%0qoUfT%2XCh)X2L!cFC-cUXCBH zA4W-XFzJ6Ql?d7-@cvEN7?e(S-=vsOdtYe=hBcjv&%}gq(oz;#fM79@T`EO*?1EG=($a|Lwml4<5V=t%ZH-?j>;PlrQ}zT&T{^P<26HGbIsGw)x{5+ zlLB@ajnB?%BhH0}MHwj+JB#bne&2st%)xzLi^r4N6Qcx1&>8z6U>Ivi|GuK>n_7wK z^IPNWj<+nr&w;V|geTlIEDA_6)lOt`3viZrX0C?7hJ65Yu7*8jqT3lRk)=?4!fY2d zx}|9zn>_Ris=L=biH4{K5!IB5+vn2C=zprp{(IMyL&-MWJgT~yaAh4s)ic4&A9D8+ zR8PT6F^-fFqvY=NgJ$d%2VLD^kLm(A;Dg1p_n5f!4RfU<{6f5z=healX#g~T)`_ka zHV}O13SS zvo8`qIxaN9qLFX`m<2z3}@Ej=^?M+3XEn0$Vt7*v$AHOFjC%4$%>6}0T7=~39 zDJP#~N%Mvl{*x9Z{$FqLeM5Re;sJDo_$f^+z$PZ1+BNJ_>Ef{Py`Z>V7JD!${bNTo zF5dP{XAU%!2%AQ4Hy+Fep2lxAYy(%7D--?`A1I5iThEp5E`_T!q@tjT!c@?bdj6D7 z@R@bc8Lh_NI)QdEZgjI-ibR)aVmSFzDFwxI4zu=z)RQNPB*vkmBSnR<(WZ2?y`7cS zV8VFdbl9$@MOj_ov})KGyO8xiJY;oq#8T-b=Dpn#Rw{^I#!+QwGeK} zlsC7DOeM*6_Pr^N8XP@Rp4J@-JfHc;dyC|F0!fV8%PcSzny$-O$Z_3f%U~PUJJkm#zPFS1WC4lSNkB#GTP1Twu=Z>lt|8MIy&<2&Bj`BXK$$&=Y%9*38N#b8-3FiH$ zp0~lpzhTlnh9)2BSeTO*SiVV0V2u>&L=y)!oGpy=&FHx%EWHPpEz=c7QfcPYE5FCZ zrGnbIuV+f<<=D(vvp#v^p5N=gBc)YY*;e-sNKF~<^XJ^Gx8C@hdZLX6VF0+lib z^3Wp2XrYIfUFZ|JfKN{HQaKMwS%eGT(mXSlzV70)@doR0X@D8=utG40r{xAowsczDL?NOP_f^$! zw=?4lG}JCDMJG$gv4Bg%wCPR31=`^n&I{VqjZUqx=64TZd<-Qa1BwU)GN)Te{Y}8L zv<^3UJ)Jof92e_8OBxFSG$_cR2eI=Ur*JL%z=pu5tnkfe+2c$y?C97gePzdj^_ z(u+w4FD#zrBa2La;lVxj2JZ5C3f8rIO@=8jnri!-5G_O?VZG zy9CZhSw}&u(N_HjpbLI)-#F*^kM{T<&4D{79Omy2Sf z4kBmun|5>L$v>r%VvTMw(tYK4#Jn2D7LDW}QpT1q0xL>&)M{h`@BmN33BjpO&PA?% ze#j%$%sxMpdGQ`IakG^_RDu1cgz0-Cu+a1o^Vc>u^|v*OaJD%FX}x|cC`RM$P{pwA z=6!{C`6{>v`D}fCecH-4RIL<{9I*_LKszQp@nzo9Clph~H3!na6LaJ0aQLJ-j*$$> z<^$*uhQ^1s=f?akBR(;|WZ$h!RIM9pWEOI1z{NLf0?(RB?Q4J2T(F~Mp$4Bbr0c74lc;jMAZoOYJr7hUmhmT=o!T_Vy=3lcATUT?JN2Ly zob)2FVdZ&Q>zG!Zri1@_EfY)zd&_7@*lYZK$dY&U9O(E{s=3I@rbkHQMc*+eHdik1 z{`W^SYgMwWeEO)4zRaS!$6XaXM8n^N0rlHm+ib{(u0}-_Hwf3WUi`<$sFKdLiVUv4 zE7nd>J!08}S0+$mCc}zeKnUND`k`k}YFZd5DKF~yKARP=O2eC$hg6IBu%TN(k`zKm z)uKPUYhQM6-8WGDokYkYOa-CSv6Ve^6p;Ab=yZZAG3SGNbh z=1wTZS660x-5KFWg&6eD#%=gYefDVRqB$Nm|M^kv`{d?PF z0hJ~K0z#+)(t9TeQly36n^HpWH6dZH@B7VKGi&BQS&JVxC+D8M_p{OWy{CP%j;Ov4 z94NkD&m}C~74D4bTu==_@}ogyLP2RdBrVU4YyzvCt`IygQ&8S>LERg+KdHi8Vmr3) zexqxK_KK(3f#=U^^XKXNph}5LX4!GIB8}qTP4pCg!V7pMVIxePCroNhy&RiY1b~JSp_um>0PR|3|Ke`< zdB`9j;aH%syfVz==vZMJwhGZ70`8S}7<7qTD!G7Y)K`^?qP_lGW=Pw$ro@b^{db08 zezAn8A`G8ziZ6`_?YZ1Xk^uI!pt?y)s5=;`M&vWb6jil=a{`}8&|caZyLdP81kd-{z z!opE7@8~SVehJeDjVS%83f0^pveuXMATi}Hl`#RM_?F%;Y6@~}JlENM&m97da5X)t zS1vEGO$ zCmTBfssAn*ptD;YOot3Q$ct+*@__20u(CGh^kg}Q0gPdx8P}F{oYtfI zr_mvpt>U(!VkCiVA+WbULSDcZ3OCKhK_P!5vRoU`>@+U(LSecO`?~%@yQL)i?p)Ip zlxC6v5PGL zirFqK?_!VY8-FOo(trpHySfP%-I>}$9rSD6eiE!s{ZPdP#&^?2T7`1d?6Fzz-A@ia zJZd_NS2=|8sraq61~wXtvxt?@Smb2g-hy=&;vmp1g=^P(P*?ZJI;E|fca}$Xqql1; z9X8di?&^_OB7P7?hUqO6Tq_Uz!0AlpnYTVHHm*jUJ-^9v@PjL}pfb2%Qud_n8d7T6 zsh&K71om&%kVh>{uQjN3+r5`6j9Kc;-IoG%7Clz4>lMA1B{(Xrfw_}r+DNe88 zmR`?S$^L_j!<*E=c)$F3gz-}g-A<=k-r{=VN-oNZbTMjm(z~c3*s&J%7Ep)WY~Bnz z%A*;hR20Szy0GHxvR1F#M1Za&3fsj=@2~^C#DE*_PP%4Z>gSuxrXO>m$u*E z2g+Ad1oZQzM%C5T-KO#VuI!?LJsE&+V>afakya)sWF{G56Zl+; zi&{pzm1{KofM)s}#@RQtitZVcfMqF^UZ!*1N5@JnzEfN7w%TyBsz~gjI8(@{L%p;m zSCv`$>y z4YXB-tV|`e0-smA>q@^Yq8jVtwcoWUoX2KKoSH!=V)CDaW`x*$&6QNX?3sM`)5y<5 z@d7xkborhll2}%K>cgMwU%1?0@r`*VLJS5cs**vnc`e@U-$0(^fx!rebJtMh{Sg#A z;=ea#iU0Fvkv?$phr|4r84f*l7<>=>jF&WU1-%u)cyzXOZc>tzMEYGo_m;ac0L~{E z)7antc@wGFn;&z(iEr=fv5I#QQ^|z7Ve^{T)FBN-$S8^NX#IZWH71#U7YUR11|@-skn;WXo}$G!JRYw-->of7uyuR+DU$YC;Ehj*N9lCS zfuxPp`a?=W8lwsz6K#|dZLQniNs#KpGAnByZq{Q(vtHYP)mB31p_FFX4$JTQw#zIC z!9|v@%*gECi^H$=Pk3IK0GRIubcf5|%C4?o6+anSf9%jYf(ZN`R!pvE+)usgzN1fu zQfmE=e<0$<4Bix&REt^&tjrefHuc3W8w8TwBBd2gz^rsK856(+7F&_AiX4m2aJv63G+Jpw~eM*j1A{^EG`+Fx@da1Z_Tu4${tT< zWBK-{)+uIGywd^Wh2i$CE1QoYImyIy3e)GQVC=~_0^P9j&E$ALo#*N1!F7Xaex^64 zUMmytx@nKSIzgXD1nSehboQUGEi(n8jwxRCzS2`X zc3)HgZ$;65;!3q-d9|k)7?Iq3Rk|_=Vp0mK~>MnTd{m>F3xlxgqo+ zXyDmx_9qdYp*A5aA+OqZ6Owq+-&MOxyq+`YYH6XRXT=z+@-5u5xR|lE&|r6KB~PA) za`%;r8m(Gc4MU~)JUhF}quDA&ed^sR&vPQoDdyt!YK+${4Sq{$t{4Kw&|+6O(EC>} zV}~Y>7GT!fEGZGygq$rpJLf(_+kbr-37OJVG;*>OT0Bopt!B`uB`fZds#$KFw$)UZ z$J9q+RVnx!*1>%P;f`6a!m{HTmp%Hp1T-+8;(w*(Rf_5{$}*>IzX-zsuImpzEc*LJ ziK?qp7ep^%meQY`XJr$2vNxgKqQ$VY2?_)3vRuh9eRg3}xkZVn%~z5l)2lze&@5eT z6;C?5o1Bqts!88_+2ssEAz5!$i~|VMWeSZvKwN_Zw06>$EetdmWtYpgNDs$*Nxl|^{nQ}BG2onVjG+P$ce zAkTQzuW^}H(q=;+$_X5^djqT`S?}%$u6QW!fj}#d0NVd9!_QABI{`WWdl?413V~5bq&<2HUZ`!i*E zs%7r$)}Jt_9JF7DlAqXn21;ya3L@@(3YAM=(tdHDY63C{nzvTTGvH^`8@+1Grq0o9 zd7%B6e^y$r{`6h32N3(~VPU>0`QgFW^eNDgI~l5Kz|~zdkdx^DsF0lKyL@xw#)Q<7 zg#+fPM)e1HN^-qVl+HJ0O@ee-?`YS>hw4Idr5x$U&%Q0riLzVVOj^zaKwDiM7fn$j zbQI&+JgZpA?^xqi9Ha8ATP@l60hid94)B#GQS3ly@Q)ZKnS()#El8 zN(kl1JHUJQXVz_fxN-A}!x-7YUYKP0yI?oU++4}l7_Jm1OzMZl<8>Px>%EM;CPvv| z@!HOLX7KwORNo%9h`5FSdma#&hTU26(o|vV@a`%un3fMoxC>}*qUAha>((6R8al6h zVp$oiT%{t_#W9aYfujw=ig_uJi-em#qk$c{;STBVx#NBHof&aJ?N_- z4dqP54v+0OI{?7C%AoHLraKI;)FMkKCdi}eDuy}TvBm^K;qCd*t^ym(0?l-_%6UEIOcUOcxsGVRw~N+oGn0H>TwYs#1JFzC2UA2q`2 z=;V%y*Vh)j!(guFWIuGYs~-iAyJwyK`~V}4K;DQZatK1OKT0?Z`Y8&ZJC+2?!Q4YA@hsF0L8omH^s~mtnI)D?g6E?$Kd= zJdz8k4tmri@?zYfRi00Ol*EM)xd|w`$@lahN)*-@Q<(aoBTo~Rbu<3nK#J%w`$`)c z#vRu+xwn1&s&K#*#R#$8QEfJRpjp;-pQgz2eOtHI4>J=Sr;t<$7U5piFd1N7-h+*b zny$S6ut423vF#UXY*t=lYBDN28uNhhi{@LKFYv-P%a5OpZeh*XSvgkkOIT*e+&6%C zu{^r6i1~v53fnkyy-==@E$TAwXQ+?gOSQCP!FuTf9@~N!!7Ta^;U_X1a~^Jb8zO6& zm@NNr60Pm~>!C%Mi(m}WvataUtSh-J32WX zkk9@nsR%1QA}^fkGyXS<7_kNG#ptj~c5VK5)8)h{z4LO&Zqp4~d0$@5Mzb}e``8?P zoC&A}v%n5O)CdtxEr71Xr>$oZW)5z7O$5MLXCnlew!jJp8ukH>;+yJZL8WRFL z&)OV-DY+PGV$j*ixX5-e7QSc0DF2Y=teEZqAbs^M^+{rKaz@VYGl2}}9VRC09-Qv4 z2Bg-aPwf@`U36ilbJfl(PPq9eys8ra(Pdg@(~md&pPbO!KT?9XL*?q6!XnRLrL;c$gL ztf!}MP5%Kk{iAe1h{=VT)uJZ@Lfe=r69;{%AVhQIhv3)$?I&(^2yT&s2i?h|e0wqFqM=A3dkUh!n30|F_})Wem9ap_C7Mgi8vGc)Ll+g^x= znfg|wBjxW9EMSvE3=~76f85?L=ssA@ohwGV#K)^+zoE8Q)vZQYcDQQ8Z@f~*dDXkY zf4%OkSgo#&GvZ26$njj4ok9bE=#lkh;9d8S5Xv4cjH`ZJG|c`F9elWXmZ@s9A3242{C#P5Ht>wD6tJJLdV-TT}2&J!SUOd%W8 z?kdJed4vs${a8hkD*BWB$OJS90;qkt@h#3x7BUP3SoO;Wo<@eBpB-);zsBhJV6bAl zn9ax-a+P*gT0P``W%cxYgBG+Ca-VAOyc9-U=S)FdJ`xdHd z9@n>EnB32MRN#Ssuu!h!^XKyzV@1yI@xQfqB5Z$;LR+{9)D_J<)XH8|)L33YFwslMNrnCap=;)u-`0-}+?7W}I;_tbbo>%)vDAF4qBcLbUF4-E z$WfI)#hT5uN*noJ{N#78$W?Rlf>hJExQ?;|sx7vWkoY7ge?ZFVpEUPVNO>;$_G zD|NCjvye(!2_X%a?XCaN+m!UI4rIUI*9zas$yVE?x)`s0|CP$0Esjkpeb(LaA|12q z8)w#J54ez_?V;S2k&t#9i$*IGLsbcb57pcjrCRaxLZ-?A(;qw9P=6Flbca4Ngp$sT zD6%KKz-D0LGELrWvQa&KiTg2GVf3JHa$YQgR{@x{ODb^6?;mdcu!d4rZeG37cX>f| zZd=-&ub*BxUvAh;Ttxi5IfsUe*UL`?!)VfYV;Qagy)t;?=ctwoM9^GZgSYv2OsMe# zuLvS+RSHw>Vga9e`kHDv<5kW=CVN!p{^2zcNbk@==Ll3xoxy{yL z@AF=mY)8zs^$BkUGBJRR^&plW+MqILAsCtuZwX8Nzm$^_j8jPFr*FSo6LN;kqOt>8 z-0oRS-{ZIRnE$MB$lpjO?vmvREUqp20n|gfD=JFiv}r;4hVq`{l{w9~_CzAm<(r;9U)M3P7bDU8#R`?@LJn}0T_4JU;b)05)y28efI`oiE+f&v-~c| zHO`#7teSeAOR7I}`FR2ZsJ;bACxwZKebMN9DRDO{FBA~l5kS1F_LKP0{!&Lkx~|+q?R@Hq zggO3+euckmEYW5j&THd_6`3d~`3WySF7HFHE5gZ#0jJ(0x)U|)Cu>0tPW7>5hnt2# zZvj~jlCbr>89oO zoIWsdg^$X=1J+dyoMzDSwQIv;^4>arP7`YZc4}i`6~S1;n?EAzIVZwr)b}s$?COzZ zU<#(!K(M>2m$6Fax>G%f3Y3(R@&el<)}1#?H@0;aE@S;mko>0KGTme)`?}7K#&Q7+ z2#z$$P_D+Rahku>`aOtAY&!;%B$ccr%(i`r=_;bpE?jwkq4dO!6k=bO>-jc2V zKu^k6fB)rKwJ@r#iemlLr?+(SweF-yAsm5X)+bB|n0|%U__J@jUp0p8QmQUy`t$&; zto!Rt$L?RAC0Hu;ckzT2ja}_jzNF$ZpjLSwJXIEcEj zBim^S4bL?!QsoaKT-DnK)?ZM#qbG#4U_!q&)es2Rn{7r3m_KK!#eP`jJU2;`Pg^WD z1s!sJf1{pDWN^_;Mr&X~s_0URzHvTdMW(Ys*;Hh)b1JWpSFfq}ZRO=Lxg$7~k2)J% zPN4_e7iH-hec1O4O%-}!6H!K7eOn-5%0*D0iqYV=d$2SSLLaZIen}q&+(86k7>nad z4A&S#SfXfLyMKktjtx7-h*fj2KPq8*7DWg~f&NEjmdVS)aXpMDK7S^C&77ak-fs-} zjQ$$I%hw=17EYokU5HOi18?Y<`l~a}nOA2)8wZys>G4I59#iMBl^Tj zol<&(9(rf2pmf#L9DILF5qLw;HP`qZD$P0Vzx!~;d;c&MdwN3HD?BB_QL9c0f+9sT zrHfiv%fky(%kl39t-lr?kpGjs-mUFriKpcT^NJz1dy>FQ!$Oo!SZfK!1~d35!kt&> zv9V$_8!KzCxuRn~K*gYz0e?t$mN&yT&{a)E2#}z@d0h#tiaK{f>Mc`SqoSwgUfe(i zXp#;o;hY4i{uQ_P z*tiK(K<8(**;peALk52REbx4m4)tK?d$e|SGkc++K6je`%-UtkuWp6TR6x`4x-o#L zaKC^=lNI~-K+)Eda_sgz4SjH4`PER?@_jf+ZDe$fgGuhj3lJbUVb1K%YsW*cZ zrhV>qco84(>*1!x3ruT=^GhE$6VL1e8!iPX&<1hG_i|z^-I#+?gMaxj3{)3CAi70AdX#}Sd9!p-CbjR)J$dgb7ZiLWuWWXQd1bLiX>xEN< zC&r%t;X$y7*c?x}jlpWIZ@D{G;83dVZ87WVhp97)4rA-f|Tcch;m%qZ7+4ATD~T_Rk|{l|=D<<&w0&)sYTc>wBMUn67N z9X1fp9tm2vJ1H7tM(sipyxRRmI|Sf>swzh3eNITt342Wc$H8`WY9YC(L%=_Vns%*h zKX>TE+fZ#xdQg>d?Qv1NBwb z8aMT;>{;`Vgh{)hOZl=rB0IbSO+5W0334@<31E0g+g2h&Sox3}o5)e8!N!O)5@{pv z+_F&MHx$5$GDZPdgW~pCI<32xR{uxQ)N2vPT59qeicfMyYc5 z(SY%c3hrJLLEhNx5BZ|4`3#?4&)zEyms)FIcv>skC<>@*_H|mmGzopxj=X9cUHysN zgf1vMzJBpguj_Jl6KT|};J4>Jzu6dh3wTD~LUm;awB zM0_StJ!5AhyM^B4sdWh)39hH!iqB#VP*uM$;*hl264p}!e8zAv0l%^Jz7E->bYugw&$+COY?o^U&zrJS#dCN=q2%0JD-?GL@5Oa$BOFja-RSk-1^ z?WIPT&}*~W5+|Y8J4D6FiYBDn%CEM)?cmKlmC}D>wvAOaT7icN6nhJ6;K=_V;Y zW8C2X#4toMvhC#)e@cUYJ%#Z)cZ`o|QVv=RBI?(gqrj^zOue(Sa}Pw?9W`V>@*mOxl+!`mX*d)IA1*r`)gh@A*h=1A=;0g1?i? zX^fTm0sXpSf9Wj`|knF*u@cNC%se~pwWqFo+_{23BZzt4+*>Cw8R_~k`qD$Y#n z`Qza^ClU8WRVU6%C&f!odtk_nB3Op)SF6oupzGsXaKFZ7lNgm26y&tH+E-EO+U;#+ zbMIW1b(TBkY^t$UlKr4a#k+TFrjW;XH=1Q8)q94>$XBx|Fm>7pso6}WBQ}Ut;t-Xc z=>38Sdn#ZF%0pBNL={+#w8g9j5qe|qyuIl?F<#Q6ux)T#0qgrBEd4i||f^|Kbb=`{UpV!W@#3bYeO|3!!E-r{*AOtULVPxv0Vfwv-1#bK8>;I-w7d8(Y8k2pIjSLH`h2XjG$MI*zIvMn5clhI%-T}kX?ulUM`<0>`sb@8IOg=8x3<3(O+XQb#qIW8hI zKK{Zn(t%Y@APHEFIuVppUF|~Vd z2~04rMZ3QvG4m-3sM3u(Wu(AnRi!rX&h+xfF0-IXG}OOtkv1l-P)MVOE3)AVStz7y zongw)dgR8R9kcOTZg-T&qLFIl$n!71*pu+Bw|a@3_c5HB#k?9JM=AG zP;CRBWq5kQ$;zZE?J=T~0a`aE*N8@~-#_-hog#bA5#MNyX)7>4y)%3LU57*OS;AIx z^&9&~ve1Yw;e245#}7jbG_)F*JY)ec#&JC;wZw6y@)anV7Xwh5}At zdx_>0_;PaXDHm$5PfyW(MNY)B)FAiLG6y!mZB2~N_efmvU|G|y(90&X^u90pePTXm zp|twr$B(D$AZ;%sMfW8IguksOobS5c;3vlhU6_m+shBahYSl|+ZsK0C$K2WL`^XyN z=e|+CaQw2z*f?=Vgfh9uE%H(}9=EI=2#0Y;dG2>SG5Vmk{I~jX31KvDxI@BpakYNo z3?VVDu%DA8A7||GckQ{N>(0%jdLNLbN3eM*d#6;E3L?ZL1Frvz(P9|>v$T=9xlLYG zx+iWG<^lEj?>rieS_udR7@$y+n2HWUpFsAk5?;H zT-i%nRAqJKXp{vP`}jr_TuJ4j^T~pU-!fizU@ijw07t++Ke~`*B_Mg|7MdlIkV;vwu=)udqK8b3%k=I4NQGM|lQ^RTL)@vf z51tWMR_ffae*L;(0v9sTodchkvTjmcslJl$z8XBXb#boB71Bwq_JH-#k8*yYoHm`Hr#)0l(>@V#iwJ zr_ZJfyvdQ@@fA6!NTz=4rUNj2!n*+hy>-r{F?p2{WJ@_qDbtUEYeJqYloj*@vS8u1 z*EbgJOce#s&>stVfG&UsEY7fw(#{&Dgza02o8Jt0zd8W*fh1g6U@xog*(CaZn}B*< zVM{Bwdi-(CTme04o%xjmDas$)?gUgf?LIE+s_?t@@QQMBU_+!Ir+}#@APdsH$oio) zkVfDQr0cF67?=^$BaG707q;(SsPzF+t@Hu0V1l3>t$bhdaug|cmGY^Cb7UTw!;{}g5NZQk=ObvBhoh)2C>39J=*61)_sp=rXJ{eVa# z(1tvNU=>KwEN9dx5I_z)aoSX~6Ugly&zO>x8gFKN@6Jq{yev>xq9&kr39)y^=COsw zG}ot~)j(9XkdXkMPKIA-A(e0OvL2i7)#}z!OMay!`p&w}cbCjdLo_qHNa7a40xD}P zB&tO)ik?0Zm93!ZaCG3f5C-NR}H0x zg`E$Cjtq~xnHIxC7DxY(aXx?Y_QdU5D7(b7MbFdo_s>_4Tscwp-`TF6vX%ko`f1g8 zsWrD5A^0|A3k`%ox+@wgzyA5fUXO@PGB^9<#82D-|?(4fpkdk5iD)`D0a7b zksjlW9gL?(1Js$DPB`wii!}X8E*R!wyz0SJr8CQ6m}^x83TaztJyFRuu8lmHT)iD& zQ;QEeQ4TneC2)TvY$RDq*-@o{9rghaZq0UU|8oC%(|g+U@{}(jX|L0qk_9%(MNtPl zL$K!TkdyDWqk6!LB@>e6tl~JK5(+(09RLWs_aKguI-H0LLI6+XnzLKDB9{%-v+pZ! zUJn;Pljw|V)}YD*9~9|v6K)X6A;**I;-eS7yL(;kmTXU(@A2mJ_O|PVUEIbI7m@6I z8nZ!Z#`WbqwqDxHafd>ZZ+U+1%vu`4)v1BmZtA3?wJ&Ob+C0v!9DF@UE~&m477?Zi zuaQ@Qe!U*W+kr4>9dJS;>LUWEEw&u=Lu~!(mk)^sUHJzLp2G^Z zyB$MPM_G4%yc!*;l_3&IOYj?{_IWAp#fV+E9Ea5sEAo2rC z*H^s)F}tad6F~FVeZ}#Dj4r8Y{oWlOqfxn?l;JVG<-r5f_O2G(#`irwAfTY=Al|2= z(&_7@r+6>j3z+aRbkkd>UnMw-!X-cLjrqD&`A7GQEQ^XdY&Vnx<+F43UR{M^I990T zbH;{L-0F#$Y20BH6yp=OR(r^@w{|^Z;BJJf2HwY3bV|B~ZftOaShXK{=jM^hZ9!_u z+`&b=$OzL4ltcFGuP3v-m2k=2hde*vW%CH1r*&KmmB%lzL-TybP%zm|)-lc%J{fRI-YKXQ)R>@CS8EwKMr_=8LwoP>V8fPD@r1%W+ ze|uV;abnU3o}F6Qq*wFG6C>x5YOu>$HMe&c51&yPAx}Gw(aJm4j=#>je`Jk#hN&yp z2`VsqzIor^u8{#?$D70xW_DBk&pTU*SLx87kPYa~uMgkRxLgrzGA~urC}&v8f7+vE zG~05l$pfoKXf!j-G604St~&ZBUXf3|s_iUF{eC0NfD<37p_g}hqR`xtUo-X{hcd83 zUQ>-u<;piCXe7?Fv!ga9tHEdnT(IcEC4}JN3_w3B)(2LIVC?OaV)u&sogUSK)jb)s zv{m$ge%j&-9pwhZyGhPSencJZp>g}wZM5r5o!O{}V5#muoJ8LCdXF-D%`tr=riK73OnYF#DfJ zXb@ao4|N%tMNv^FFzAM| zjK5@Y>9)SC{z}>+E<4KY)FS!(xnk$~7L?oq|GJC$I%mLZbv1-^!VHmTrdGLU{z#S_JwbI=TD)-|LgYn_nC#rI{1=JsB+BF>8hw6r5sdsnqr~^D)hXBew*3(CcO3i*ToPk( z^9S0++#>8}j;Z(>G+NpE2psfk9p;Sz7~lq3TA(pAQ{-6xLeq`p&K3?S(Cbi2}5tiTi(tO!NtgHxu<%i$4mNH2bPafciySq)@-4e~A zV{Idw6a&5>ZDHS-vI{b+SJ>{|#8``dhK=tBS^S{3xCZW|OLPbCJPLTLnNhPB$-@1U z-S>Zy8Zy}qSS9iK6G^?(dr^hb+SCo}s+4|}fp-4`Gpga})ppbz5eogZ7zRthZK%dw zY2_mOdfJ?`N>x_nO2bR-;HPXpPZ<3AZaMlHner?}8F!uG_!`b~+OS7DeW2b8^0kn{sN7vzA}kWNA!*(p}n%3*)kV9@pOSm`hCPq+wVY< zhdXyyoXRg#d={LHSGmK~#1cPfUjkzgpuaM@;W!OOZ2&nbO@(_i+m)6l5~qu~n0oh@ z4_C)d<_%|NB6J6DkL6Ox{g#D}U%!8U-NKa<;|RM5sj4}wo+0C+yN8S9eF#g)_5$zy z-n%TGGf!4n#PnO>FXN4}R~l{)ECtb`?LIL5- z4q@&)P0$#!*N3L-YN}5_ZQhHatsoTYRw^J^7P4`J?O3X97kK+DQq1Rubh)epliGZ4 ze2AxH=r!wcMw82pd}$XF=tDx>z#1@(h^tXFV=#O5d6gpz|7hmQX~&sGUn-Nkr$hRm z7hh-Dh7lre2{OzXfj$RDgSm?1ivh_Cmib>&7*6YA%eQ!P7d|1PpIrwuzunDN$6dMN zKtLs8ljdc8C6%QP_()V@(%5hfwYJ{1DzM!CMGQ%raIU04OH~9TAan=H*)ocOyVe6v zLRKE3s4IDX@u-jD67!$Iw&3KEw>BXcj0n|oRm_LKh~p&~^lBXoAoTG#Bcsr4a|_jM zPg}&G;bs}OIkJDgVL00Dp)1Q7x$$dy!iLr4#rq#Sl&49X^<$`we}X7-xtRt2<$(&w zwOgf3f<A(60HmK8OyC#!;(KjX^LV?XH*Eg0JTxGVB{&Ba0qX zWE>0lib|w}LPOB?vMp_UFN6T0dt0ee8UNaX?p|odga8b#QeL(Jj}UMgmK%zK{S2Fj zpoxhqlE3hr`>PiPqCW(Lh}(5lpKJo2Relm#_mKhw#;m0mrB|2pxsXuvz;nkJEiSDA zRDG8nM(w-Uay~<-DXTb&?hMv-CX-dLXET0EQ>pxd!9S{HJ$jcUUo-SyK%b)PUuyXE z5o(Udn6t|YkeEM{;i6fQ-xaVAg3IU_xu-Y< z@u`oqbov94U?hc(KWll6wOq-*%=ehVw81TA=biGsYW%`e?L~Ts%i!^fqKtJkb5-T* zK$?2Li^vADl?u$D5ZXnZSYHV8{Gc~=bRYIJ;#IT){C3cOAtM#1vzyD+*8Ev`ewuJ!umaHzvKAJwoYC;LI8C9S9!mNt>T82nNrV0-D}`;^&P!g_}ZENlLBY6 zjaUdd-@&0TX4Sm6H8zmSRqawE)4}mk={b*+F5enC`TN)XA1+$T8g2Ch>Ls^yDXb}4 zg3{;8SqOI5*%m&{c!@n&3-4BATl;AzDm1(Cvl8|(_5-;s5wy>}%8@|4`dSzS^+Pul zP*2X)2f@Q_SVpD4^dzWQ{i$i%0M#bRswpVR-duyG?kzpo3NEuXc>Iy$bNgG-ojC!Z zH(O)uh&`tB2|BBwueH^RLS9isfqZBv&~S8uT`H(W>w<~+XNTIZq)um?^sgcLc4o{} zKAiw0`}Rz9P#Po1yutYm3E+~(t4m1S9vj4QRj;IEd*8_J3es4^$xi2nFQ|m1t4H{z zoJUmhuf0yW0(72FZt=j%tdnMo3sdE2-k?lA` zXYB{N9lvomq5y0>Ufmtuc=Lu8^OU3t^Vn0W>;y0SO4GN9{3WZV5TIt=adAzTG%==VLVWz6t%@y&ykTnc#l+^MK2h`^Sa4UD}s`>OB?*UU!NA@#{i zfN3Aa_vXB{=&$R`S;$$%#Z+XzJ7`m{?Wq{^f+sSn*ws4*0XfV2N0kAj%8ipXm9mHe zrha5|p_!vsk|ex#eRG(l6mrl!NiO&)klp9RLS9tBjlHhy3le?9vt$`MxT!> zTTdrJEErhzfyqcyQSX>Fwvr2^xNOURz6?;4y{gHuaL0R-r%n~&#hz36B+F_PSaVfU zJG6H>2_)&Sp9O!G zuNm0!W;*>W_SS6j)cCU~($dZ_&(M!sMke1fBj7$+q&o1{zjQDdf89F!Y3@FX`Tz5a zfn`0WO@Zh;9g%zKIhMR)8BePpF?XQlaV5w-CBre#o3vXqELmm-a11({{U>t@U;jQ& zl{2<@yRXsr=8SXy!bWxQfp65&S!!#c6)>E=k*dOegT>`r=vQljy5_4?JCL-y87ksP zndzT*HOR;!MuO+S$xDA*mPZj2sZ0}(?$3lYRdUTWv8WHL4hsKG$@{JLCt9{D?3RLi z%wW?s=X2G%Wv9UULU}q%UY{DToITB#5S2zW_f2*$)imb09kaFQ<6X*`OY~KE#2aLv zPEQzat#Yumw>5DNk{t2r3h>9QW_6=>DbD*uzae9bot_hU)+0|DCaBX(&tfEzyEPcE%P`w)l`N zL$dGtK1LGC8WCcMNM*^sQ-nxk-^RX;Wf&U!Fn+i1`ThR+{Wr`x&S9?mzOUEw`FuQ& zcxbPqygT<>g0^pgeP+3{!JA@@xU%yPBp9(JKmy(!p`;pfz>}AO2+8G@+XIxzJE>{C ztHOWhdZ!xO-F~X)KHZhGY6#I=-D5nrwvP%5DJ${oZ-~6Ycy;16L#%>@%W%j#qL;ep zg&rw}<+SMs5xN$HpAgww&?XFBPJ(Mj1n*OYY-e__8EEq^;BeNBxZJs6UyO=cM979( z$Z~7bT8TDn;3noQj(mb=zQJ}gY^JRDt`sv@e-^%>*1{dc8%VSE*;AZcmOCUq+b{Uy+;*O_S?pKYY@N^* z!GxD~mF#76w*|7$k$@h@_yy99+XB7Q<=C##r&EOvT@7E8Fmp#oSMIH3u{g)$YKHec zALiz}i5v7gyjI9zoLVFiPWB}ze}^A`bUX@{*V4{a89Mu6(MDU>1_Zi$oaxInd*TnT zBImA{)JBMShv#jMmlM_~7@sq^Uw2yQEpJOmNN|_w!34hRAIl4=xsHP5Cnt2dhhcroIn zn)URSn$K1r!#|aSlD0B|Ek;vl^O6->-YkJ%_Y!(ebHREtD|}r!fjTp#WTR#uA=!{1EjawxIPkRE%^2A zHIy3q{O0OYlbep8MnxYryh}H!jBR#kuM!ma%PZIpvhf8c{-gJf9A9QF`H*7lI1MZ+X|LzwK z$ih5@&Bej(WEnG?wwG~aM?k(Eg*pd>OsVQMPOJ+j`-#@TZOhcVf^_^SIbPV{VLdEv z!VE*Sya@(}L{p!92n&eAB}muD2F2(+$4eOU5$MrEr4o5szs*r_6>T&C2;UGOEl%|W zjefOM1UUx`SquJPJDjhFhwcZ3FnFRmmQZIxZp(~l&=48L&d8Lqb+GkO zBZdJ*lWY*F3fV~R%5aaldXfv-xjMwhCwxyF3*%9`DnkVwG>{d{LxnlT=)7?7h`kis zKv)3>{YZv}g!b2#=?d`@MC}OF{s4Peiwf0|)P7MyB;ZYncRY9zz1!(A=Kg`ad#nOP z0Q@N)6L`oAZ^#8Y8{uSr?8jMr#yS_$fl*SskZ1ePpz51k?9d2L^prbBi!gkRsyf*be9_Hy8dB40*I?U#)hta??@VMo!iRqhQZa! zTld&|*+e+w}K=M*0Pn$&b-oYDCaM8|gaim}>n z`ml2rUHd2I7MI__LO-OOj|F=IRDwLW`Bm|we|taE?tck`2}mxizWrkIW!%Z*&O@A5 zmy?@Axb5MYmf;_79n&Z<;(I{1ZTUSF5-tTelk!h$jbMqIf~S zL2Jmk7zqPqr;v9boc{~ zza2bquSK8<|^cE8~}sr$hHF21E$CYtuF3o<|@@RtiEs;cV&_n6c#_zeBWBTD>;^T>MI*6N7x^Cnn#>gJOFxA+dZstwUNUr%YwI@J{9h51$QF9dsPvq~#_1wA}EZ*mz z`r(Qz&E6;Hh&yfn;c3d*nW0oYcC14WB&pk#QGS(yeb?x686Ru0t%`EyzOAlf<%Jmv zJX$dg%F#)(D9_f31Baah`t{J8P@1P!|Ft5a=fR}T@Vy)!8`n0YQ4L7CUfJH{n4EDH94X56Y3O^@DS=PnioL3pLx5rhEDE`|0Li%tyi)e3$!t*pJ7&lG^x~=hd z5397@ru7BXJoTMm1K#Mb!LTj0&U>{QYp!s@U<4T#G31FPy3V0vWCc}Gipt%xPh@oh zxRhf6p_BeC2fv#jIrm{aQDub^u(Y-=G8EO!&bF{ZG4M~bBi@L!r|t%k;Xgn`K&Yy&oEev2=A6AnhQtH9MNA@J0eEn{u%B-;paPV{5sNJ+0QW-jO)i&08$O8ytTyO$-gO!4TF5J3`mK(QN1Aa^-ZSjHRI35HdwY@YzX5 zSW9b~cYk9m7&lARM=OYh4y=+cgWXBQyV#py2JRIzc+AGhwYwH#y(?ACbzo&uW~v_< ze_bK?l;!88`!`HnOw@J#d5P1<5B!{cUO9YtAkAU^;iriypbA1E9eu7r^JreJGaF{` zLOxD<XEBGn_3$#X>wXMpw0@{wj|D<$kZiF zc|Q~`U@?FHu`m17+@?mrkONTCtkP(-)H&-9KwhC4vO?j+IqYNRuUIzX=#~MMxW|#3|%1Sl)YyQV&tE^fw{2xJW2D4W|qyi zcDpKUsAJ;IQ}#T;at*QgqV5fv1L4@7>1{ib7xrHy=74ERs;^1ny< z;@jebeYi9?ZqlE|eu`1LIBuqUfw$>l^ux3_-zro+b|35T|4di)_1}guvpq1ODI9k( zta*bw0G}E;3#bVe1siJbl!{`{AXlNc(?)(PNfbI$*UPE+Bt|5yhLm;e4~xDo4Z% z@wHnOl^l7>5HDgxd<^UYVC&tZou_UTlL9}`ku3iDJ2W;i4TSH=Jmq=iYFx`5*Sq!< ztB?r|w8O2D>i{UM59D^U+8DGe11KlY)u%S9RM37Ue-I^q@*{*W<6E9~M*<=;i8xvD z{XMrA=UV7)D`mI<1|x2s?3WYr5a+8G=g>)t&LXq}n2TGhRyL%1a=>xZbHMW+=e(c7 z^>%g}CDj{DkM<4($s9p?eJxG_EiAQwPp3Aj%DN%YBja5Ep5}gUA=ODo{WW1PEf5TS zs_~*d=xH1q`>H5&l5W~XRGge3-TYb)ZH|Kf%RlHgReJi@l3E3mg$|)_H~Pe0bzSnC zBh##R?haSi+J2Z3t2++)T1s#7u7BkjZ{xL4M!C-b7bFBf*?(#@R!gUY+x~DidBtAE2k@%Ro zPk&48eMeY-G|LT7vnFl6-W$4!8L~4_(J@d8NX`xa3kg|z%f7zPj{d0LsuN3&sqQx` z=L9Nb9i=e#v#BQ6w6{j@MxKw!ND!^R4!RU;@XTIrkI$^LGdfkiCXdMu3sj*OfAMzDUOhv343EV+B zo-wa5h>lV8hcLYxQxh#Hx3)3@WHifOKl8R;S9jB~dtIRJ4Mzs=$?!?tb-lDa-0V)mu)b83D{qM1J{rDcM1Aq17Nk=rHh_-e?j8(OE zi)ntRx}q#(>vZ!T>RjpeS9(5Z2=UR+&**iUrNg||)>h?rzYhrMISM-1gX0F7$dQoH ziqhFP?j27Ge=k9iseX0&yp*zjW$FExZIN-azA`;b_-IacX46*rp;~z}muO1Tw0`;4 z^fXk@pg*gU=I$cz@Hh4R=*YtwSFkx2jqXoJSP>eo2e|Y= zJBnuean~Hi{u1hbW^LNgQhTe^e*+De-+)mjV?C9T_NR%P2Nx#KE`AB@D{ncNQso<8 z9ouXU$f^Q=tu2*m1HF7tY_%JfiIMpSftwC{kqcWM1`7N1zvssm+Lij1J#*Q?{LNhR$ zR0kHTCvP26J|ADH*@&ffd_?dlttm13WqgNER+ZysD($dt3;)g)w=J0ulL84IFiFkA zmH>(!YrP?IK=LYk%Ju|bo?s$s6ezRRCk_`>vt$6X(HaY37c&U20~J}y2qKmCKr5(4KGUGVW{8hssKYXO zk&SqL<=FS~xZT{N)8K$~9J~3u4-J_Y;<#ypzRh^(P{K9Uz6$b4V3OR z*E;3o%K!2%PR(cCiWWImk=Og>6iXMD#IL|#rYOiONGBKu@IB30QGY%*rNo8>sltO- zyb*p=tj>r-vA1{>W*=POp_bmjPF{XMB82t zB5&pk{i)tV+C7>h`hg6{=s}3#WD9kL2Bm!MTqr?#(RU{=5);oi^-j7T`j$shH8XM} zp23Z#9)t3s_Oojm;po8>!c1uyol%o!fFkV~UtY&h%=+g1cMW`>owwrAHkM`}A^cEi zs}#a^2sv6J|DKj^~b8e9ALNEfdJ@0FgPQweNIwE#X!ctDJAQx zDwd^+#>Fmo+tE9%?MEMTwkKh}X)7VBJCNC}z>;^1YKW3VB1h_A|=*H@B*z@+@oJ|HwDfoo9gRD ze@rtm`uX{#b#-;EO*i;LKe>BYrF;s|v2FT}L+2`Jqr*bt$Lhp~*|1NxSmTg1YqxWL z^)$0Ac1(LEehNm#`?b0Ziy}o2$95RQk4MKV$(wHi*ym@={;u2-6oQ^)FE*(7FMFR1 zqjU2#Xtr682>r4MP@fNpHUgPx9lC3O(w8bR zG;E-(2~(=qo>C$HHhyz*m|%u3#^nYjTZe8NR5t`?`riY66i)?IH515=tLKb4%E1rk zwF?jKv2^yCm4gTHXF4>YjCc#X| zq)d(34c1AnXa<0NOGc8}rk#ib0xWjYZ#?TQYuumvc6uUPyS0;#E}ycpK!>4Jbx2ZM zXST|1X?5Y3=G{}0^@9UsuFiA)p$gH6zz@R{=Z@!Nk>OMM@Ntj6iO}2j1}*#fyms~B zPLnmRInby_xEy-QUmKGlXUNk*k#Mhaa1RFhvV2#}+EVq<7gVdC5Jb4PebGXs$>(Tj zy*uC_gs@S`QL3-Y8ijjJnUqn zTAg|w&=Wi!12WBTP<3WKn_IEGofP)th^<*CCn{n;lX zh3W19q7M~_+Ay^MPMA_EM6V}qu29~6a3|Ly_f_;&kcj*#axH3_H_z^4rz_4sgLp^X zPZiHI_C7IM^b&PmPwT$mD6l)qw4R0gzI6W;LcW}ic7n2gTxR|C@b10OERd5-lOL|l zY`?2OLN~FQO~Y6ken)@w(Gvh(XrMK6Pt(Q{;m*lqgi^Wui`nSROPsX5bvIA{D=R7M zaaQqq9Q_bY@51r@`&$;jx`W+(tt#fO?fd2&Ud6IAgQ0S;#W3Q*LU60dP?$S_Vw;fd zIMmfr?cgL>Tx0(5z|p`DUGh&AnMzP0;iZnJIiBf)8p{8Fo}h#TQ)t09r9O5%5-ta7 zC_Kwr?w%Y%2={O#OO z!bh-Y2;2S&%9SOGTGMVLIcC!p?5V#;HsITOMU7M zrlP(U(=$>9NVwFQwCJVzgjO!g2Er?~)>uoNY&q9x ze<9?60)Pw&>2{T^R|$6@&M3 zf4Y4yF*5DU+2>vsB(Lb+1*MDP{eHc;kQmxP*RYF^D`u=yg0J%z`;Pc8#Lm?)7&-!~ zsTU_S_lNxfa#ZW3`E5_XmA|Z06BC7C5(O#CokznfrwQ`h?t>!j6)*|oxwa5Pz>&^* zLk=c|_7-CJ=-x-x2re>7OG;{K&z&b*N32tYEbKb2$3+&^RThI1- z=|PS(h9^G*9sGRNVKs=a{2LR;)&u6%lFfD{2(iCECP-q;Y3Z*$L=YR61dUBoo}9QO z$HZ&~;&D$qY8rl@oSv}1@cV&|Kw5QOUncr(FFWqdlC;-5OP2g>mj(5_=7`@wpYajr z?h^ojl8qq~Rp7mF{h23&pH#{ckRT9VF;#;AB0jxdW|$sxm3^!LYjPVWXn9Ocdw!`G zX=}`W8+q+!v!?^1!l2P}L&|MyXV|YlAloYL5VzLwnq@JR5?Bb}OMMm8)S`KleJ<}R zrsYuyv1M{T)Yn+mEZTA=FiWg?Zs+028Ly;{6HUD(X4E5Mu-qS&vOitM^~`sxDdC1+ z!QV||3@hr}CLY9PjH`U*^{RbNEgrVqOU+cx2u_Y7;VBT-p}(o>2-zEL2LWv$g|umG z64wz%qNMGoq2!*p*m|QaBwg!RgAX;cic{Xf{N2sT-g|v~<+1(>?#qgM_~S~jv8$t~ z5^RL>)OQICAE_<9we|ZOJ$!2a){%xboNTgft3)^mFFmYwH*T`veO9$q)?XI2N1nR? z_@Q~ySnI1IEkO4#>3Cv3*#b@r>_u&Qm0?;Dh+4g^4S0`dolMQr+8?7n1?|w;`hx&z z^DT{}pcqEZO)Yo18*VaA)*;(dZY5R(3#Hrt=HD>xxJ;P}BAgcxBNh`>1w>j5k5lC4^p7 z-f5?>0yl{Ehvl_?K5=h$ZdLgg+~wuORJLIZ@sRiy2>b-_}6y;NnR0DQvpI|2*rzlf>iWM>`Upam(3kV5rm5S3> zgAH^}=yn}zN!2*?hDBZ%KE~L+SrNK2ZNq*G?R4f?+6kRg< zoc1jytYwkjq^HX{yhePG{H$Da4NY2=VH!({O#)Qu!>krEUhOJ>_jNHDhQ4yBm$2;a zuc5xjUR?4>=fR84!@2c)B!+);1{X7#cfw6(1?{yp2kJkdK2pq&Oge6x{`VSOWL-bC zWwiND=B}Lpfb+fknrbEq$b44O0r)HGd*mp$CdNgEzkJu+apN+vKZ5Nlg-$u@8JH%m zr|P<+eo$VcxEhe8>O_L!YuaVo5!W_yuXD9CIJ;AATyAIZ;^AwN{BXe04%?c?;G78e zx;5a?@i-X2O6nqe_&Wtp?!qh7)7@uR&MBbf7k+oyaj$}P#s1f7Dl$_KULW&w@{iRf zjlWRQJF$^6ST|^wGuAreoxQB;u@NPdCl?=uy!$4XgF+IuL{{`^NNG7{ijJ`_;m4Oa(gvL$rMiS@(OGKPc z9Xb|^B~Z%YTWrR+#ypd)F#AVVAYmHh@Og0BoYvj?pk`~3e2E>W^D`TR`6+34cnF4K2JH+r2AR%US<1LF~J6x0{iyiPnBK7AR zkB@`1-d!n{a?~IE`5UggD=(RtxZSPWFh6Fd0Pda z1gP(w{THfcmiegBbilX;>eXDxa z3%K9S--e;l0GKq(AlutNUA!?&52QpxQM^6oK8JG69wfTkx5!u4X?s~7K3Y9*hG0PI^diQvhW!e84xD;|Vl%l$m z(D=~eN$AxuA#}#+iJ^@qL=`(;p5w{|TFbW`o0zvo*#DgIGmACV=4^ns!#1#mtqFXd zyC)a;J>~o;>3l8sOZ99m1*M5-KXseiq~W-S^rsedf2r?QZO9g>0C#-+D#+?mi3jaK zonCsm=lQJlg`=0TfnnSVNdk7Rig7=16K-uP-Vp&UTXTw8i~@ zoeo9A@9Ep(E=XDFZZ6okB8pBN(kk}&0C6a|bm8LQ?2UVxg*RzgVw}R>NXnwqOd3(^ zx|4D%kBlJWK#_2IvO_vn=Ek&H;@F)7-Ka4I#wS)~hJp$PqmQ(@v?7Ka3m(2ziZC@V zqkBgkr1xmfCjx+ZTZ`2B!jVaahXKi6m zhM3E1GlUfc=3A*B@e+eel4S<>>iH&^jhME$l(eL!wQ+xPi(J0rg#eYWmr0Zpmxw=3 z$B#p75h?l{o0KN8(!HNHtGS@dkTlJ6sU>!2k5}-`-7K@9hpNcfJu@7+>Q@CG)~>SG z@Z2e`85c_%7fP|I>8Gk1>xg;35G>+cW4?O)Q#8YJxi&abWkqG)HFYU;C83QxdC2j< zb=3^rT*{*7*QSJ%e{zW`{Mv5l@AH-a%LFkHn6cWK6N~gPn@l-35qDZj-=BVaa*-Hm zi3Z5n9N<*oUUB;qfPBD_%%DApr1+SBF@?mk3|;n#rFzUb!0YxVJ)@7houV@!HW_I) z)XDo7kV84^RNbt|UGLVc*06%5r6LEr7c{`?G^68z^2qsmWmWYi7Kwq@N+r*=Mmca_{^ePIlpQQOjf;Hk z){T6sq9YL>tjlSgDYEg9Z;`Ms9Ii9h_41fkCG2spq~m%A5Q&l&fQU|BYtIEM6pHE` z--(QgI=@_L+}>4%;}s9PWzr6(U(-gRGU^S?MbLzX3{q3Z0RXzKF%9nJ(2cW=*lcT1Q@8B@AmZO_S#aFSJNdV8?{Kct{* zT_Z>*L7i47y=Ir_RZ#`V{9p%}n=~iO#hCRe-1s^d{k-wKL7xnhW8$^He1(QNTWt;B zgx95oOYvj&as06ow;<=jm+$lz4qt-Y=GCUN=>bp`0+;v&DHmbkpwcCM_pW}1miS=w z>x{LbkFTZWWpq>4-T)|&5c0^rL2vX)ziQ+g&LiJQV7G~-T~kUn;ly$Ef^#QaXPi2_ zaB60PN%XJhBgZi%m4LXSYuZOSfhpInX|MN4B@OUxpM6yQ5epo3UQYTONYRfy8<%~Y z{pO_3wA?rb^m^EqR~(2RnYCPs?zuVJ$n;BV2tx5zvSCSlXo=Px2isVkMhF5{U7MvpJ?lBHF^Tg?zFJ-h&UTwz@pf z*os~cdyFy3lxueV3CJ|TJ^42WM7f0|nq<+zoJ=IeHXG9a!JCFCZceX$;yay60M<%Q zH)syslQxTU%MmUX+K(})yK$5zQv1jyEJ&w?9d#U^Dhc8^C-lM_ThpuYQ>?X{<(vH< z=Vm3at@Ue1p@s-Fqc-F;3_oUsxtH6fyGaUroOQrXx~;5?tx=QHuD(C*8gl-5FSj=7 z1{O2MkDi%utMGhGsj6fw^U&3Gpvn&G##hsTLI0ho z)L{JsKr3~7yaM0hC-uqnDe2GI2c_Df42RR@v*K8p_LM6fIZ<=d;1g52OI^~Zz)gH* zZ!MN{*)D_CXV`zisRK-8_LS>mXhs|M!NzjN!w-tGO&~D-FFzmmuG_|AB$S_)PpR$z zqXY*62IQV-X$mDMeS$x*Le%yDOS+rE8sMQ@3a32Z|CLB)XY(?9F)#xum+Gq;A98KR z>X-@K54Y&Q@InTD_lBY6N0dp$X@g``Y!HXUJ@FwZ?jfZ-;Ok_j`>5u9{uB9|%p{;n zpqG!oMJp$w8;0SiC{3jGW4+JS1lA|s<^XAMx_taeunH8ssB zZxjWDLEj+WP==X}_F{>XaHG{_6{;KTkA`YzZtW#9mM!fX&aKKz-wE7?E%k6u-F@N! z2Z30kH2fD!o||Qha=kMYJo*+d0VtWq9KuqLgJ$~`Fr`oC?=Jbug?*VWyTJ_Y`^Ye! zaa^@1Kihq^TtII$EX{O-gZGQuRbNO??AmiB_F0PwZ_4^OS`-xW1A~ppj5FeF3bN*J zPtZ@Tm6-~&Oc#xqFhC_dMhHqugaT+*UJ4uj11R~ivB2em0X&Pnoxs%NQsX;33!8ie zK8fX}nlG2O3W+<7gb0L39(nNE zKIFSQ$v=+TZP}8Xfrk`M&_&Su*K8`I`{+H4uqKkSy*3}1vJSUwO z!O6QxLzr^vLRwSW0fKoQ#{K*DNrMa=jxEz}lb?yTtoM|y90n+khSS=ZdXN5I)TW|H z(Z89|N6+G@y}S9{XHKUr0{lVSQz0rXPN*l;pxgwz?&F;(^Z{6$iTt+sP58-^S9Ckz zca4A)UiKZd7W4&A3ed4|FDo0JZ(c}|o14<}$_@pH6knZ@5Cmk*#-6!D0T)VDu%`Tz z?`SaC!+Q6I5*Yu)(Vbi$`LyNr)zo!wrvP>#Hgs)%W^YF*W}OVCB83c;Zh`K+L!LbC z23{jN2x)~Ve1px^M11^uw%Fg0%Pa{{zlQ_SzPPoHI_qLHba-5DFrHS~|HwOJnXIwb zX?Hm2YoMYop>#&uLLRExTScG?#u3OYbt3W9_W~(U@58x(Pd=o81vqUgRQSXG>K{UP zbK<Egs;KL|zUH zh6^*$waPk{K3zQN26G9Bj!>^>1_m&RNU!SeAWlTiW$ste0l44aasX6mw*p*VhlDEe zM99|K?$`2MXJO^_Dqx?yu4UEUUd#A5c)NjpZEeub2N8Q~0DM+Efxykm2sZA7I@wwN ztuX^YhCZaq9^2Ro?vjG|C{Ky}vNadxySmlR8Urj`e9uCB1drq&HO+L@HX#ohORVqcwI(e&}YFUvjz1zOA9?$-^4@Cu*SA>jv0WF_}VigOj*_RFxdc^YfPm zezZwqWS_*m7AtLIZd3DDFfcpOH~Rka?$YG=fd``Ye=TLD{cL!!li^&@w-Q(EgDZv0 zj=T)aoD15%QoCgkaWX8!_2(O3@{jD0Gq(xfiD~{e(FpA%-YudT+`T{s+kH^8x!rb7 zc1M=MDChgF3lfXTAYmM;Y1RZXweHjoM^uAI=!5JCKXm3`x0q4v9EYs?;qv%q$_m&_2&56Ic7FA z+}!`_W~(P|A>KQeFf4C3C$nKnm<=Ze#J)V7n|&m2*)`! zY3kF*{B+LEo6bIzz++iGy}eVZzfjAzfeI+)u<4H$G~wP!2&~ zepUHIE;GnZ(d}~-D%2R*zU0K5mC3yl+(`AeWAF#`(g%1q&3Bb9m(SNz8Dcb|az;kS zbY#n{Qf|FW?Z|2NK!s~mCe9vEPfA5H1aosoGX%l*qcgoBv{;Kx=afU{Niv`z*fsk{ zi*s2Sco*|EA&|Wo{5}WAsh8z#Kf?BVJkQ9ewFpVP`yBd|CDscij%XI`rleru-geI? zmuXEF=g(f7T@s%qAUSz9KH6ztTvgG?l(g^NGhQo5Qu&aZ%X@6`;q3SCwCl!2?DtQ_ zU$@PJ@1|WJ_A~}Bm{bYea3bPY+WPn>Ch~(Q*RNs$VujTzwsVi&+Uytjrl4o{i`t$> zw^5Gi&fkr!l{U`);V4{$6SJsdulc%mDFGgI zz=oV;`VocJ&A|Xw-&lw@@xR2c_O=G|UpB|?nCuM88Hw8>el?1O_AJedK1F%p?Ka!P zCZytp^WLKZnrW0?+S8{sG%yiHkY{ z2)6pFL5patEHB!9LK}Fkz&FLRbGaw!kk|F@ZNo#p+vw46wNH;LA42*&wHF6=lOcvn zn&#zBq!|J-V|u)1?=Ql-2!4Kyd4Mc}`Vi5(hS9Tp-();r*MMc1xT)K9Nh{|2c1aKq zH#bWt36chu2C-#dFc5Nr2*!OSQ)`?KrklFCb;3;$M1wwm5gZ)#GS9lM0PhS#9ro-F><~{j*$A*|x{5F%^)VHMJr)oS$!$=xCA%@$hgda?Ow! z%v{oTnzH~-Tl4Bi3cSxoR(5e~0S@gATx<1UQB4kD6tmC>`eNz3u+6 z9qjH8XeUy!RXkV_hlMF8eT{e+eM(motxMbwnB)Bt+O#jb;?^vZPE}#ZR~7A^KQr|s zKTSjmHXUMqr!Z(d?oknotT?N z8B7Ip(7YtIObR~6MANwRJN%U)UN~!Zm*?YaO5!l+v8+CnCjeZJ+D*asMF9j z7Mm7`@|(c-KV2{NF!@4(hk2^)FQ5bcPHb(?)_j#a0;D;XB-y(V6w^-LiBQzy;t!UD z#D$|7BNx}Ql&`^$v4R8|K<(ME#k&sX&Ys6$f?z4US-1~JbgV1z>(ga~F_BE0E| z%kkk~i#L}_s1oZ<*^tPI>e)Mb20muZLcT((}A-<&xm62|n(!?B;J6+3nZOLJQ2RsNW z=yZiOO6j^Ue9J=jBi9if?Zt2~z4{WqH@*uz|89_{8vj$KU%z`7a9BE$Ch{kit{fTa zR~}y<=(ek{s)9VdmBVF|<-qs?m|1@h&D;G?a*Fk4a}mecEjFIZ-u&W6KTKcYUsNX1 zu|nO_TBoVK%3j#tMyNPEGw!_8qHt|786PgGkL1PIJkx)8ppm$BuS=zxey2F#8Kz@G zlwx*xf1Pt#r8jqdmiAptxb7-sM}&l`Y>!evclOKVP@DxZ;03UhoX;%o?{eN)Z0yAR zU?r90#y5GlDu!j^@PTm=NazgBjNXJolx00v6>}9kq zS3yH)Zyy{dwZNXrRFP^ccRDd$E6+cqru(!$U_Qcsb93qB?;4_{$IjN?Cd4Zz!y{9tx#op?&*y zrm(k{t}&SS5-;4URQl=Dhl51@C-dJNR@qA;@(`8h_o-Fcx>|#miaK9DhBTSu1(aw) zkzy4q0^cJllYcGuEMT1GNQ8k^Mpx&))&1&l5}W*A_I-a>>*CM7E{Qb>phLDes=0d! zT=w;as&sPZ&9)+4JUj|4WP8_6#}UJ1Wku)nvOs6-%Q`1qZU5ftfnIg!xJ(FcOKfkq zRoQQGr})hofqv}wZ*JwVBh44TBaW9M?iw%b?J?xEc||(l9PGDHg5G#S*c(PBCjP|p zds_FV9iQ2CUV&{t9K`o9X7RLM1LmU?Q>*1||g_!0d3hoI?BXpm*cT zmx8P@)6Xj{?rR(QtFtPR(DZwsbNRZYx~dixsxz2iZl zkxtSrbLNkPDvE?Cv6_*gF|D)ks5hf9bb%T#4S`-2WhR~zym1D8DsOik7f5Ra$veTK zT>ee!ysZ_r6>j^|76OXEYIT4r+dDols`g9GIR5i!rTNRm2-E0qFNmSplZ+l}V>ddf zK0zvj)VxpX&(ioFP2?Mqd7uQLzVx-|z!wD1rRb%XV0c2Jyb$r5da`AI_xQ}R zgpr`w>_Q3fEAu-v8~VWRSFa@c+Q|pE5fkXRd#O@CE6RUB=n@h!p23qC&RPd5r2YCKtU@ARDB2 z2@(11XVW2NQ-5Y|&@sYA&FQmKu}7M$I57B3z3<7@N9HsC0?K`8DxjHLamt#a%^LI_ zzdJk@2aoBYgKjaE5zrNeeO}fi!Ywl$$NjesAt8k^hi>~|Mzv1b=*HKsE``-~&n0z@ z{BOChR)ghOC>pLFNlUhoKpnK+xUpLA*ApiP%gx+Y(S=g!}y!RVWU z8-$XOrd!Nmm!$B^ws{bm`vj0Ib2{VvrLg%C(K$6IRAvzW*ME3qbx~sdSR!Y|$nYS% zK{&CL1z8V6fpKbH#Fl@q{Ch!F1G&*q*$_1CTx&l+MO%3^n|@FbP4rRs3$VA1C;L-> z`#;jJjZtM zF5g#f#J@^)qz6|F=Hx*I)m|olldkj}FV}^`1*$G~IaWpdgnVI7;=;{z2X`jmoS29Msl9SL+v(}tKG-{FkAMCKaUxzb+UnJz+)=b(>8Pn<=&2l*@%zBF{lUYt<9g7p%kes$ zR%y{=z?@j>=R_RuET_8*O#L^%dyCc(zi%#PhTd=%fGKE#aQB)=?W^%kn0gHd#!yZA zN!t7IQ*YHTsw9XjTy4LCv|wBQX1#F@agOx{f_Q4GT9|CyY-j^sEDJ+b@cq2<@l2T6 zI6v-`Ly;3+wDJ`EWmr=A9V=o{1d8d8*+Z*#2iL#F{6#h?b^M#B2a<4&I1@0$fv#GhcjQvIp+nkmWp1b`CSmF= z9LXlP*dtg4yKX*~Yd-GpNy~{W-ESbPct$=0uTSjpc}^#M3aw(}s16&;++C4m$!DL~ z6tuk9hHq|`PfSP{92rRf=(W0%5?}KpZEw%FoNmTOZeLl)H)NtC_SHSDsy+mISQwHv zrgcf{A<+gv1Waz;0ymb^v{}#>>y2Yep+bn6^_(fC6nt|Gfw)zwo^mQc@_j-4l5OPHA zDi6Ou(obF*Un$%Dv#{p>r8Kr%=t+LB`~Kzw(LZtKFEZJFEVo@OjvACNLa z9c^bUZkt$(*sk>?rqz}DaL6l;-r<99aKm}_iT~7yWddFd^cUKs-n_EQj!Y}Fs7b<{Lb#6eljiuh zZAQH&(y||kRr7W*it)kaB6KqG(fW3o6C41?)G)EpBjByBV(vh!Llmck(gGllLY!hH zn|7kge00i+#<>;lc(8qzaWi~JHadP2AT1!iTcWY{P2r2S8lRezH?XJu2lfqy>05Pv zZQW3S*btG}E7s2Y8!`C^bNJ_n0s5vh0&>Z-|6F$Nd7wIAZS=3wVvAJdwTY!KNix!L z>nH(f@hm41js>N)!yib#llOO>+1G8{=*X$jWmBMogoy7MjUr!qao44!q`tMXINNzA z@CR*)o?$li9JMhuExYK|gw4llhpD)b%}GM34twdG{g0klL zQw{aTV!@|inOo|uW$q`f3ikWO(^9)Jo22alXZrsk0nohlx|RJt!`(mM#9ui0XucO> zwP?fXv$%y`$K;*6jlQNha8qV4#fro~>lw&~vTAC6h9UyxMhUwHDsUk9^_xAf+h}lV zL8z(to6|ma5f4z6f*?@xH*R1?zMqBjPKT!Br_AQ$2Gq{iB)1|2ygFk=0R(`iI63|O zYT{y9YA34FVtvEc$3?AcgJ0Hat}=NDLG7pLhBEOCT1S}M)6bb-lLdJ68FwJ4UErt> zI3{R_!n#W7FXsbof*|?`#-}#a=0Ol)QSfSAfDu~smdeepzqs{y)6%UzqX(9T4Fwjq zohzrGqzil2~bR4Yc_v43Vc@P5CPZQFF;MoLk^U=a=^ z|3w$X#tZ9<_Zv93fNGUgB>?9=x>X@U71QOrb~7CJlFI2X1k))@qM# zmU6DCn4Bt|&TWc{KrPE-6IxVy?E(wHJDbN0O(oXNZF^rBPOjLRwMQ&xI{qUBCYs`& zyiV|Ue>GlpTeK_yQq(79B08(JZ#uyBO!TctVZHZXSpncQIGp}ujLn`h7@4(LBg}1P zX~{4gas0qk(*4(@!*YY}$(@hK0wEk^Mp zeYmcJ!$2cfT}}*k>v4c(Bm~Sc+Yg5mLCr9^@KdLn=yoSH9$D-qZdBrP7dDWf+R~i* z?#)GeM=E%k1>n&S4rS#rXBBAR;Z>x9_T8U8eOG`qGZQWTu)4N(k%F+al%k`aGbql9 zmhSHEmF|=u$~b~JyDhZH-76w$0~UINETZ-CccCnZaQ2=RoAeVRz^6TsABaM~m*Ei< z5cyg)^Y@0g7yi2D%=lezkLk<6Y+YE;;J)zM%B&=IAkn=lzosT7lma~98Xnj@->+@> z*0k&tV|)Vl2?N{cnCd`swEl8u9?QyW40$*+Q)O`9^Gi8p{b#v1iEEPfd#e2BzegI> zLw*0FP05GWkAA_h+5Z%!LxF+$2LCOFfB^F5By_m7fyM8bB-|)F(;x@TGW@72G8P?~ zs`4JLa36D}vysg(0JY;#{TNGyFjM9%&hXl2E(76IDfaDqdrlA{u~S3|2GMwyJa5P9cy^8 z_{ST_89PJ}+?;Km);v3$fuS@=P=U>@RboXCd3<%*q2om4b0&-5Bth4

nU+BQRROHZw+8hP0>DN79L{@@&@9baK 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

o;P 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 z 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

    p=?mg?*sXA2}@_jADWl{2z>5 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 z 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

    cf3e3wXmAFLW9g_GvR+cO)rAgxYJr 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�Z};Rk$$Qyh22qHsvzbatY31Ol&7& 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

    ;Y5P`fjw-WCuL&9z~@{ey1FMad~5 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%0Ao4qq|%Gv=8=ZB91QqWIje>e9z4mtovpA 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

    {+D>%lu%tiGt{QK>@Vg>^NSNp*)1ecg8KYO6 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

    JCwdwxGD1{yW+sBM0DK&A$LQN2}C5;{I#CL1L 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 Date: Mon, 14 Sep 2020 20:47:45 -0700 Subject: [PATCH 62/67] Readme: add discord link --- README.md | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/README.md b/README.md index afeb578e..d8b6565b 100644 --- a/README.md +++ b/README.md @@ -4,6 +4,14 @@ VQE is **VQEngine**: A DX12 rewrite of [VQEngine-Vanilla](https://github.com/vilbeyli/VQEngine) for fast prototyping of rendering techniques and experimenting with cutting-edge technology. + +Join the [VQE Discord Channel](https://discord.gg/U7pd8TV)! + +[![Discord Banner 2](https://discordapp.com/api/guilds/720409073756930079/widget.png?style=banner2)]((https://discord.gg/U7pd8TV)) + + +# Screenshots + ![](Screenshots/HelloEnvMap.png)

    HDRI Environment Map Rendering From ab1f5eb5477876d76a2b56b98cc08ca9f6a70c4f Mon Sep 17 00:00:00 2001 From: Volkan Date: Mon, 14 Sep 2020 20:53:40 -0700 Subject: [PATCH 63/67] Fix discord banner link --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index d8b6565b..8b82186b 100644 --- a/README.md +++ b/README.md @@ -7,7 +7,7 @@ VQE is **VQEngine**: A DX12 rewrite of [VQEngine-Vanilla](https://github.com/vil Join the [VQE Discord Channel](https://discord.gg/U7pd8TV)! -[![Discord Banner 2](https://discordapp.com/api/guilds/720409073756930079/widget.png?style=banner2)]((https://discord.gg/U7pd8TV)) +[![Discord Banner 2](https://discordapp.com/api/guilds/720409073756930079/widget.png?style=banner2)](https://discord.gg/U7pd8TV) # Screenshots From c97628244485b641dbe99d8f204f4890eda7bb40 Mon Sep 17 00:00:00 2001 From: Volkan Date: Mon, 14 Sep 2020 21:42:38 -0700 Subject: [PATCH 64/67] Add PIX markers for RelWithDebInfo build --- CMakeLists.txt | 1 + Source/Renderer/Renderer_Resources.cpp | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 417366de..00ce9800 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -152,6 +152,7 @@ foreach( OUTPUTCONFIG ${CMAKE_CONFIGURATION_TYPES} ) set_target_properties(${PROJECT_NAME} PROPERTIES ${OUTPUTCONFIG}_OUTPUT_NAME "VQE-d") elseif (${OUTPUTCONFIG} MATCHES "RELWITHDEBINFO") set_target_properties(${PROJECT_NAME} PROPERTIES ${OUTPUTCONFIG}_OUTPUT_NAME "VQE-rwd") + add_compile_definitions(PROFILE_BUILD) endif() endforeach( OUTPUTCONFIG CMAKE_CONFIGURATION_TYPES ) diff --git a/Source/Renderer/Renderer_Resources.cpp b/Source/Renderer/Renderer_Resources.cpp index 5f60ca7a..228933b5 100644 --- a/Source/Renderer/Renderer_Resources.cpp +++ b/Source/Renderer/Renderer_Resources.cpp @@ -332,7 +332,7 @@ BufferID VQRenderer::CreateVertexBuffer(const FBufferDesc& desc) mVBVs[Id] = vbv; } else - Log::Error("Couldn't allocate vertex buffer"); + Log::Error("VQRenderer: Couldn't allocate vertex buffer"); return Id; } BufferID VQRenderer::CreateIndexBuffer(const FBufferDesc& desc) From 7553cb38da1e4e132fbfb2660700cd93e09829b7 Mon Sep 17 00:00:00 2001 From: Volkan Date: Mon, 14 Sep 2020 22:44:50 -0700 Subject: [PATCH 65/67] Display err msg when VB/IB heaps run out of memory before crashing --- Source/Application/AssetLoader.cpp | 47 ++++++++++++++++-------------- Source/Renderer/Buffer.cpp | 9 ++++-- 2 files changed, 32 insertions(+), 24 deletions(-) diff --git a/Source/Application/AssetLoader.cpp b/Source/Application/AssetLoader.cpp index 52a61a92..a26fce54 100644 --- a/Source/Application/AssetLoader.cpp +++ b/Source/Application/AssetLoader.cpp @@ -321,14 +321,15 @@ std::vector& AssetLoader::FMaterialTextureAssig // IMPORTERS //---------------------------------------------------------------------------------------------------------------- Model::Data ProcessAssimpNode( - aiNode* const pNode + const std::string& ModelName + , aiNode* const pNode , const aiScene* pAiScene , const std::string& modelDirectory , AssetLoader* pAssetLoader , Scene* pScene , VQRenderer* pRenderer - , AssetLoader::FMaterialTextureAssignments& MaterialTextureAssignments, - AssetLoader::LoadTaskID taskID + , AssetLoader::FMaterialTextureAssignments& MaterialTextureAssignments + , AssetLoader::LoadTaskID taskID ); ModelID AssetLoader::ImportModel(Scene* pScene, AssetLoader* pAssetLoader, VQRenderer* pRenderer, const std::string& objFilePath, std::string ModelName) @@ -366,7 +367,7 @@ ModelID AssetLoader::ImportModel(Scene* pScene, AssetLoader* pAssetLoader, VQRen // parse scene and initialize model data FMaterialTextureAssignments MaterialTextureAssignments(pAssetLoader->mWorkers_TextureLoad); - Model::Data data = ProcessAssimpNode(pAiScene->mRootNode, pAiScene, modelDirectory, pAssetLoader, pScene, pRenderer, MaterialTextureAssignments, taskID); + Model::Data data = ProcessAssimpNode(ModelName, pAiScene->mRootNode, pAiScene, modelDirectory, pAssetLoader, pScene, pRenderer, MaterialTextureAssignments, taskID); pRenderer->UploadVertexAndIndexBufferHeaps(); // load VB/IBs @@ -421,41 +422,41 @@ static std::vector GenerateTextureLoadParams( return TexLoadParams; } -static Mesh ProcessAssimpMesh(VQRenderer* pRenderer, aiMesh* mesh, const aiScene* scene) +static Mesh ProcessAssimpMesh(VQRenderer* pRenderer, aiMesh* pMesh, const aiScene* pScene) { std::vector Vertices; std::vector Indices; // Walk through each of the mesh's vertices - for (unsigned int i = 0; i < mesh->mNumVertices; i++) + for (unsigned int i = 0; i < pMesh->mNumVertices; i++) { FVertexWithNormalAndTangent Vert; // POSITIONS - Vert.position[0] = mesh->mVertices[i].x; - Vert.position[1] = mesh->mVertices[i].y; - Vert.position[2] = mesh->mVertices[i].z; + Vert.position[0] = pMesh->mVertices[i].x; + Vert.position[1] = pMesh->mVertices[i].y; + Vert.position[2] = pMesh->mVertices[i].z; // TEXTURE COORDINATES // a vertex can contain up to 8 different texture coordinates. We thus make the assumption that we won't // use models where a vertex can have multiple texture coordinates so we always take the first set (0). - Vert.uv[0] = mesh->mTextureCoords[0] ? mesh->mTextureCoords[0][i].x : 0; - Vert.uv[1] = mesh->mTextureCoords[0] ? mesh->mTextureCoords[0][i].y : 0; + Vert.uv[0] = pMesh->mTextureCoords[0] ? pMesh->mTextureCoords[0][i].x : 0; + Vert.uv[1] = pMesh->mTextureCoords[0] ? pMesh->mTextureCoords[0][i].y : 0; // NORMALS - if (mesh->mNormals) + if (pMesh->mNormals) { - Vert.normal[0] = mesh->mNormals[i].x; - Vert.normal[1] = mesh->mNormals[i].y; - Vert.normal[2] = mesh->mNormals[i].z; + Vert.normal[0] = pMesh->mNormals[i].x; + Vert.normal[1] = pMesh->mNormals[i].y; + Vert.normal[2] = pMesh->mNormals[i].z; } // TANGENT - if (mesh->mTangents) + if (pMesh->mTangents) { - Vert.tangent[0] = mesh->mTangents[i].x; - Vert.tangent[1] = mesh->mTangents[i].y; - Vert.tangent[2] = mesh->mTangents[i].z; + Vert.tangent[0] = pMesh->mTangents[i].x; + Vert.tangent[1] = pMesh->mTangents[i].y; + Vert.tangent[2] = pMesh->mTangents[i].z; } // BITANGENT ( NOT USED ) @@ -468,19 +469,21 @@ static Mesh ProcessAssimpMesh(VQRenderer* pRenderer, aiMesh* mesh, const aiScene } // now walk through each of the mesh's faces (a face is a mesh its triangle) and retrieve the corresponding vertex indices. - for (unsigned int i = 0; i < mesh->mNumFaces; i++) + for (unsigned int i = 0; i < pMesh->mNumFaces; i++) { - aiFace face = mesh->mFaces[i]; + aiFace face = pMesh->mFaces[i]; // retrieve all indices of the face and store them in the indices vector for (unsigned int j = 0; j < face.mNumIndices; j++) Indices.push_back(face.mIndices[j]); } // TODO: mesh name + return Mesh(pRenderer, Vertices, Indices, "TODO");; } static Model::Data ProcessAssimpNode( + const std::string& ModelName, aiNode* const pNode, const aiScene* pAiScene, const std::string& modelDirectory, @@ -609,7 +612,7 @@ static Model::Data ProcessAssimpNode( for (unsigned int i = 0; i < pNode->mNumChildren; i++) { // then do the same for each of its children - Model::Data childModelData = ProcessAssimpNode(pNode->mChildren[i], pAiScene, modelDirectory, pAssetLoader, pScene, pRenderer, MaterialTextureAssignments, taskID); + Model::Data childModelData = ProcessAssimpNode(ModelName, pNode->mChildren[i], pAiScene, modelDirectory, pAssetLoader, pScene, pRenderer, MaterialTextureAssignments, taskID); std::vector& ChildMeshes = childModelData.mOpaueMeshIDs; std::vector& ChildMeshesTransparent = childModelData.mTransparentMeshIDs; diff --git a/Source/Renderer/Buffer.cpp b/Source/Renderer/Buffer.cpp index 1b0f0f5d..8f966a3b 100644 --- a/Source/Renderer/Buffer.cpp +++ b/Source/Renderer/Buffer.cpp @@ -22,6 +22,7 @@ #include "Libs/D3DX12/d3dx12.h" #include +#include size_t StaticBufferHeap::MEMORY_ALIGNMENT = 256; @@ -153,10 +154,12 @@ bool StaticBufferHeap::AllocBuffer(uint32 numElements, uint32 strideInBytes, voi uint32 size = AlignOffset(numElements * strideInBytes, (uint32)StaticBufferHeap::MEMORY_ALIGNMENT); const bool bHeapOutOfMemory = ((mMemOffset + size) > mTotalMemSize); - assert( !bHeapOutOfMemory); // if this is hit, initialize heap with a larger size. + //assert( !bHeapOutOfMemory); // if this is hit, initialize heap with a larger size. if (bHeapOutOfMemory) { Log::Error("Static Heap out of memory."); + MessageBox(NULL, "Out of StaticBufferHeap memory", "Error", MB_ICONERROR | MB_OK); + PostMessage(NULL, WM_QUIT, NULL, NULL); return false; } @@ -245,7 +248,9 @@ bool DynamicBufferHeap::AllocConstantBuffer(uint32_t size, void** pData, D3D12_G uint32_t memOffset; if (m_mem.Alloc(size, &memOffset) == false) { - Log::Error("Ran out of mem for 'dynamic' buffers, please increase the allocated size\n"); + Log::Error("Ran out of mem for 'dynamic' buffers, increase the allocated size\n"); + MessageBox(NULL, "Out of DynamicBufferHeap memory", "Error", MB_ICONERROR | MB_OK); + PostMessage(NULL, WM_QUIT, NULL, NULL); return false; } From cd69206ebfa8fe48dbb5fee4d9f1b45ce208263d Mon Sep 17 00:00:00 2001 From: Volkan Date: Mon, 14 Sep 2020 22:49:07 -0700 Subject: [PATCH 66/67] Add ModelName to Mesh name construction --- Source/Application/AssetLoader.cpp | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/Source/Application/AssetLoader.cpp b/Source/Application/AssetLoader.cpp index a26fce54..4d88facb 100644 --- a/Source/Application/AssetLoader.cpp +++ b/Source/Application/AssetLoader.cpp @@ -422,7 +422,12 @@ static std::vector GenerateTextureLoadParams( return TexLoadParams; } -static Mesh ProcessAssimpMesh(VQRenderer* pRenderer, aiMesh* pMesh, const aiScene* pScene) +static Mesh ProcessAssimpMesh( + VQRenderer* pRenderer + , aiMesh* pMesh + , const aiScene* pScene + , const std::string& ModelName +) { std::vector Vertices; std::vector Indices; @@ -479,7 +484,7 @@ static Mesh ProcessAssimpMesh(VQRenderer* pRenderer, aiMesh* pMesh, const aiScen // TODO: mesh name - return Mesh(pRenderer, Vertices, Indices, "TODO");; + return Mesh(pRenderer, Vertices, Indices, ModelName);; } static Model::Data ProcessAssimpNode( @@ -599,7 +604,7 @@ static Model::Data ProcessAssimpNode( // AI_MATKEY_BLEND_FUNC // AI_MATKEY_BUMPSCALING - Mesh mesh = ProcessAssimpMesh(pRenderer, pAiMesh, pAiScene); + Mesh mesh = ProcessAssimpMesh(pRenderer, pAiMesh, pAiScene, ModelName); MeshID id = pScene->AddMesh(std::move(mesh)); modelData.mOpaueMeshIDs.push_back(id); From a220680d61256f47b698c60671b037f9490f2501 Mon Sep 17 00:00:00 2001 From: Volkan Date: Mon, 14 Sep 2020 22:52:40 -0700 Subject: [PATCH 67/67] Remove redundant code --- Source/Application/AssetLoader.cpp | 146 +++++++++++++---------------- 1 file changed, 65 insertions(+), 81 deletions(-) diff --git a/Source/Application/AssetLoader.cpp b/Source/Application/AssetLoader.cpp index 4d88facb..4ed45b6a 100644 --- a/Source/Application/AssetLoader.cpp +++ b/Source/Application/AssetLoader.cpp @@ -317,85 +317,6 @@ std::vector& AssetLoader::FMaterialTextureAssig } -//---------------------------------------------------------------------------------------------------------------- -// IMPORTERS -//---------------------------------------------------------------------------------------------------------------- -Model::Data ProcessAssimpNode( - const std::string& ModelName - , aiNode* const pNode - , const aiScene* pAiScene - , const std::string& modelDirectory - , AssetLoader* pAssetLoader - , Scene* pScene - , VQRenderer* pRenderer - , AssetLoader::FMaterialTextureAssignments& MaterialTextureAssignments - , AssetLoader::LoadTaskID taskID -); - -ModelID AssetLoader::ImportModel(Scene* pScene, AssetLoader* pAssetLoader, VQRenderer* pRenderer, const std::string& objFilePath, std::string ModelName) -{ - constexpr auto ASSIMP_LOAD_FLAGS - = aiProcess_Triangulate - | aiProcess_CalcTangentSpace - | aiProcess_MakeLeftHanded - | aiProcess_FlipUVs - | aiProcess_FlipWindingOrder - //| aiProcess_TransformUVCoords - //| aiProcess_FixInfacingNormals - | aiProcess_JoinIdenticalVertices - | aiProcess_GenSmoothNormals; - - - LoadTaskID taskID = GenerateLoadTaskID(); - //----------------------------------------------- - const std::string modelDirectory = DirectoryUtil::GetFolderPath(objFilePath); - - Log::Info("ImportModel: %s - %s", ModelName.c_str(), objFilePath.c_str()); - Timer t; - t.Start(); - - // Import Assimp Scene - Importer importer; - const aiScene* pAiScene = importer.ReadFile(objFilePath, ASSIMP_LOAD_FLAGS); - if (!pAiScene || pAiScene->mFlags & AI_SCENE_FLAGS_INCOMPLETE || !pAiScene->mRootNode) - { - Log::Error("Assimp error: %s", importer.GetErrorString()); - return INVALID_ID; - } - t.Tick(); float fTimeReadFile = t.DeltaTime(); - Log::Info(" [%.2fs] ReadFile=%s ", fTimeReadFile, objFilePath.c_str()); - - // parse scene and initialize model data - FMaterialTextureAssignments MaterialTextureAssignments(pAssetLoader->mWorkers_TextureLoad); - Model::Data data = ProcessAssimpNode(ModelName, pAiScene->mRootNode, pAiScene, modelDirectory, pAssetLoader, pScene, pRenderer, MaterialTextureAssignments, taskID); - - pRenderer->UploadVertexAndIndexBufferHeaps(); // load VB/IBs - - if(!MaterialTextureAssignments.mAssignments.empty()) - MaterialTextureAssignments.mTextureLoadResults = pAssetLoader->StartLoadingTextures(taskID); - - // cache the imported model in Scene - ModelID mID = pScene->CreateModel(); - Model& model = pScene->GetModel(mID); - model = Model(objFilePath, ModelName, std::move(data)); - - // SYNC POINT : wait for textures to load - { - MaterialTextureAssignments.WaitForTextureLoads(); - } - - // assign TextureIDs to the materials; - MaterialTextureAssignments.DoAssignments(pScene, pRenderer); - - t.Stop(); - Log::Info(" [%.2fs] Loaded Model '%s'.", fTimeReadFile + t.DeltaTime(), ModelName.c_str()); - return mID; -} - - - - - //---------------------------------------------------------------------------------------------------------------- // ASSIMP HELPER FUNCTIONS //---------------------------------------------------------------------------------------------------------------- @@ -482,8 +403,6 @@ static Mesh ProcessAssimpMesh( Indices.push_back(face.mIndices[j]); } - // TODO: mesh name - return Mesh(pRenderer, Vertices, Indices, ModelName);; } @@ -634,3 +553,68 @@ static Model::Data ProcessAssimpNode( return modelData; } + + +//---------------------------------------------------------------------------------------------------------------- +// IMPORT MODEL FUNCTION FOR WORKER THREADS +//---------------------------------------------------------------------------------------------------------------- +ModelID AssetLoader::ImportModel(Scene* pScene, AssetLoader* pAssetLoader, VQRenderer* pRenderer, const std::string& objFilePath, std::string ModelName) +{ + constexpr auto ASSIMP_LOAD_FLAGS + = aiProcess_Triangulate + | aiProcess_CalcTangentSpace + | aiProcess_MakeLeftHanded + | aiProcess_FlipUVs + | aiProcess_FlipWindingOrder + //| aiProcess_TransformUVCoords + //| aiProcess_FixInfacingNormals + | aiProcess_JoinIdenticalVertices + | aiProcess_GenSmoothNormals; + + + LoadTaskID taskID = GenerateLoadTaskID(); + //----------------------------------------------- + const std::string modelDirectory = DirectoryUtil::GetFolderPath(objFilePath); + + Log::Info("ImportModel: %s - %s", ModelName.c_str(), objFilePath.c_str()); + Timer t; + t.Start(); + + // Import Assimp Scene + Importer importer; + const aiScene* pAiScene = importer.ReadFile(objFilePath, ASSIMP_LOAD_FLAGS); + if (!pAiScene || pAiScene->mFlags & AI_SCENE_FLAGS_INCOMPLETE || !pAiScene->mRootNode) + { + Log::Error("Assimp error: %s", importer.GetErrorString()); + return INVALID_ID; + } + t.Tick(); float fTimeReadFile = t.DeltaTime(); + Log::Info(" [%.2fs] ReadFile=%s ", fTimeReadFile, objFilePath.c_str()); + + // parse scene and initialize model data + FMaterialTextureAssignments MaterialTextureAssignments(pAssetLoader->mWorkers_TextureLoad); + Model::Data data = ProcessAssimpNode(ModelName, pAiScene->mRootNode, pAiScene, modelDirectory, pAssetLoader, pScene, pRenderer, MaterialTextureAssignments, taskID); + + pRenderer->UploadVertexAndIndexBufferHeaps(); // load VB/IBs + + if (!MaterialTextureAssignments.mAssignments.empty()) + MaterialTextureAssignments.mTextureLoadResults = pAssetLoader->StartLoadingTextures(taskID); + + // cache the imported model in Scene + ModelID mID = pScene->CreateModel(); + Model& model = pScene->GetModel(mID); + model = Model(objFilePath, ModelName, std::move(data)); + + // SYNC POINT : wait for textures to load + { + MaterialTextureAssignments.WaitForTextureLoads(); + } + + // assign TextureIDs to the materials; + MaterialTextureAssignments.DoAssignments(pScene, pRenderer); + + t.Stop(); + Log::Info(" [%.2fs] Loaded Model '%s'.", fTimeReadFile + t.DeltaTime(), ModelName.c_str()); + return mID; +} +

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 z z!Lhe}h)M>}W?d26SJe+YHW=4m*f{GpTg#uFdm5!$vV5~bv5uR!&@$KL^A3Uo@i=Q2_I!)Asgdm&>}#Vh8f?yoc& z)D}4de{zgIDwyuFYSQ@r&Y!We$FoJMyCqKVB-VeIXY;A8_v?e$%0L_<5OjDnrCXho zBNKR|U|hfQ8nxJdzUg7aFQFj}buuMhDljo9!=)|#w#ctM2EDUyjw~zJb4^_J$7uv2oD2s}-t$w) zEq+m?<@+h>M`uIhELVhoarK1V16w*WJ&s@gUEJ}Ak8=}*hx!|@b)JQr5TWVDH%4Ub zsY+8xPpF+vA8(t@f>hdgBM({Ziqs=&y}h2;?|w4Z4n%PZ7UK1;k8nm9;ltXOH*VZ% z#Y^y3pUjc_h^m%MtA{d(T)zydgVaU1d3YD==4S^zf9COA%qk$XFL<@gK$CBe2lwd5#bG7!492m7Ut+rh7s@u8K z+$2fcUng5-xW_umj{zon)jZnJgQH;c#m`$!9pLi2D>+jYt?{eV2#ZKBsqs8jc*Nu% zOoy!zZZJrAh4=YC7NQ~Yp-ktOx#YvJzb3gvNd5mxgalUp$?tJ-jgQ^d{*nDJ8T${d z4_p#O!6$OwKLAqXI`srWQ>~QnVQ&C5|j$Gb<^QZ)8J=ABqreR9JKNjVc-oVhs=w|wmJGdvHm@nXLB~URJ#)QG&P2i?Ofh~4` z*(@`4%8{h>v)jsN(iv8@$6j2x#!!`=`6O z9zI`9-(s$K>=J%}jPL38qI%pAh~VYAm}KH8UaVo--G;?pMwd2$E=clU2!u@%*)R9E z6;-g&l|$t?zgDhx*7tDV+EaYKo_eykv6TGwv0lAy=RzMve8%O~KcBNxFKXhStH?|7 zBtVD(#o2!jP_$RT(p%KdI&yk0?jY1~TB3f-Kg!nzfXj^gR~Ey4I4Hu!ho4tF;a=uw zq^RXQknXpeOaJOMb8riRZJVq3-%;N`>ynsuS%H~vo3r?jY+hdfic1sP!;Gvt*I6vu z`o0@Max(L-r%&-V!{EO0w^dG}w#tIE<^~TiBYH9>^D^B9dczJm7V-G?Z-ROwnOn9% z8=L5B-VT+lv&WVA$qK(L#TaPqz+&=PkJfP zeMutV&T;xb3+^XXRaXzUw};@G4gZZ6xMb`Zgq?aiX$j85@Ui5o|Q<_@I1 z3IcX~+4%T`1B#5TzqQffF6H@}z}Op0}^?rSLa@BU8EnFJUYS;V!g3E59lrW}3U(g{lOli;bLuZ`}1KB>{&u?vO#vBjlKLM@k83E89YS zT#~2?7CvM#LlSt7^=T*-iJWfv@0HLPzKOa#_wL)Rmr`zutIKL>ny-SK86P6HsB$+I z>XNPKk4)4}bV$5c`Uzj#2*CU{3|SBAtYQXLPfQW5Xu{iG5O5{mXfZ;5!&rovw^MjRMI?ZX z7%Ua9lIU5kcmJb4omHoBT}|j2%Fc%xHq-FJz}$h23Br_cJWQBTi=hatCPr zU|Lx87vy@6nJL2O8jN9|2Yqpj=UDrE2--NuXF>RVVgX{+cNOriz*Et@vq7=M1u4EJ z%;tvv(dzIE==qB2hi$t=AD2Ec*aqs$M<@2I2IC6`KI%tP!;&(0OCC33jAfy_R1{Q5 zYvilE`jQ7;B7H!|Y3hD-s#aPtXojOf+c1}IBe@){E%44+=p4jxTr@{T&EDasrm+t3 zWm_#Sd6Yu}EmOv?y6&$Wo5LJ6lfbWI7|@~J)}J)TZxF?*teM3|XieCd`HymY(TvS6 z4ulxLr{*L`Ig_<6;0$(2S@{^@;h@TKpM&4p14oJt9CMn3t-fI69fo-2=8!34Af&#es`YYi-eiBGG%R6Cg<2hZMMSjB zuoqgk13GUUVyOv=_#l;&rs%hZY^zA|PQ>TIR^--Grj&8Y?DNYHO7?ykOhK<`b7^LR zLol$yla;FCtm+UL`cTi3HEBP07H|cMgUMD6D!efB_$txeye=*RPV zPl__zZy~8r(!h^%to%iheE(+OX>ODhP%gew+T~YdAI@gR?eJT51UA?eHimSddJXz2 zf)=S{OEbTm+o`(-&S{Si46?oJv&CK`!UtPnA7n=hp<1LiR7p{&9LHP-kSy}PTf^M+ zcZJ?tr#hB@tlA;Y4C9)9;9s-f)hAq;??RrppxXS&JAGDjZv|D`X)e-J(817^cY;W+ z!R+a*AW>kFn)S1&pX?qrzLl}%CJUX_tS|+mTp5{pTr!rs5fk1$xEKON$aUXEWqNg!|^pew0ySB}416Gq+;xx3>JTQc}XN9N+wdh;#5ZkAI1B3tF;k&QY?E18|+d4Vvive}vZ_%k1% zHD= z6*=!XH@PuNKx}N)6q$CYf=DP zy%{6W;n)~!MK1Tb{X&=wj1v?^gfb+kMpk{!R6t8@q5TDW8pbPDiFukFlD;7WdrbbN zUGYC@VP+W)lQC)QK3L_k$4vo3*6LmMMJrcaCFfZ7idFc_hVwb%l^>Q&7k4$K?%y-$ zdoZSqMT}4^8k3jyQaomeclq=7n!mQ+^jB+h+rYkuMA%7_+9no#;!vR1%d;&;okrbL z|4!k?^3UGYZXU5-T1Z~-g^P!MIqW&rWKLn+}lc;flp(3}fCR z&9LK3O>!E$%pjZasQ;e{51->t?C^iNxw$!aBKz?%dHj(KWUL<+n3B2?FtM~)A}#gq z8q3v7H4Ocly($f)_X~5gVA!TSD*<#F2~!ehwydBgZvqD8NWow}tSKB!O!-fN zr{E^x_W`69?VH1M7B`aI^qupY{!qoa=?}U(#Vmgcz!-E9+jFZ;AK{MHGraZwJ)C@w z8>B@S0PW~1pq4S@{k_<1h82#J4~Z`D{oQcgnL3s$kLDYxnR+CH04VT-sM462Kl*i{ z`MK9rUg1al-1Z^y^c(V;0~OI4C>>QBFMcg$_DlwC4ax{6xl-1sOmZL=IS~QobxM2< zf!H~?O%8>bYInZ(&(IH`BZ+s_rtSP_oOv^0Q+R(>o?`~G3u!-iNQk&7+o|f!Dkg^6 zv5woYjvvT)Wu~I9-|6V~KM8KqH08Pw@qM@Uim)ZOkq}k4E9ls3#^;y#Sn*ufQZup* zv1uek-(E2>P)QHc5*#p^jV@bs_XS?euKb;JU>#UNecqF@2X-wYJRs$XN<#0TYDvRo zAZqe$|D)Pjj{ljUNFvWMFV_##_uvcH_!GTpF`j5%XCARPjLmeO9Zn-BDyph}jhe+j zrVc;a#dPNl+iWz%JlEF#f~2~OXlfdBoL2x4-8X)UHhcMlCNGP;8A4di)-Et6h zo}XA#L9#M5XtMS@>Q)>Au7!l;>X;m;uNpLd5RMh)(a0)^%pQtU{V4yn+w`KbrKMZHxs0c> z2OXS4dkb-@y$rh44WJIVlDC@Z5Sxai`1r^?2Bgbm7f|Fhkmp!O*rptPc8Yw0=5O^!a((4^E4K=pk=tk_j&Yvo&MLE7@sH*<8(1<)OGGn(uc$ zZyK~3v0EQ}182^R3;4J@cR`}x-7Yv(8MV{5ob8GW7Py+$fjaONphjJ^t;O z1@?u!^??rN99Rc+GEg?k6s&_zSX$$d16Z#mrQi6v0h(nw!j&V1tNb*0IwZkSK6BMa zqol_7$qc8v0BDWnMh$YaEd)7Vzl|$4?nsWqx!fHg!{4#Q5Z&=XH;Dfi#p30ChS7)_ zne;iT($FH%!t$})FZ|5i+mhaaMj6|;W69uGOce867F3T`h z?p&+6HhXcVQz5I~7PWQ$K=Fd_-b?uN&sjOPdBnT-bW?M(&TO6(LDwjw!=pb6q0*hD zr|;zGxd|(H9Zn?GSqKPCWn6z`wHzHh>7A(E6kKbCkhVYbz;v4n#P<10$yi(4bzuh3 zKrD6A=M4JvNm`8gc-#?QQp$Rj^|_J5>k5{>3NHIH+xOUa&o0L{N9fN=pVbyyH)85) z6ZO!<6{I!jr-4S22YLE$J{2tm!&_$^a(=s+;4VUK?B_sT(MkM-Ql17yH# zN`8O{U#N$ZI|I0V#R1DR!cZFENUk+n9r$ai>I?%M;Hm@7W%JLYSKMxbj7k&2(>!?x z|0(U}rYW*TFC9fb4$3PtpZulb5tKuzw;-c4G?DyXze8L5Ut9>!2-Aecn$oF_oEWVX zkO6!dY_ENF3v?Z{SV|La%HXth<%)~ag;7NYJ(7|yG=O`wS|7{fz~>sVn=DjnNq!4s zM*nuruoX6TyJLv#ByRbvXEC(B@}}Cb>;tpiyIdk>Bd8fcoP8i+9&^w+x@p&^NrFiS#T5R%|~N5LIMbJ ziwOEfSws1h4ddo!I?xCSpHw1=m_2l8eIvD1Mt3<+<$z&A>w(?BrEq#Uc|2r%7quWm zEU=!DnuTnY7VQTsxoyarb*%NQ+NxN%RvCLF=&?Sy8bEt>emkQ*tNqIvlbhI9MiKVT zP4c;%wjF;wR(BpJj!3dC0o|@-vKg7rZAS#fj>_x!0S(4nLAzV0+@@d+VerJDh7)0|D28e+7{>7epr_*; zpHNoxzS}hbtz(Znj4P%Z2{z%hmK9{$_?+u>RH-udQ%_G&^@!JG?A%~k2sZf1+_3Ui z_fyL&^3%eJA_7#=ZC{$|m7<8B(@uqB^~IocYND8SG@}N_n7`Y>Op+oKeUvi%`b6dc=WC83g7!)(RMyDnPn};0Yi+A z<9zkFk8f7f>v3;YE-zT=o2{;>pJ`=%21>U)H1Uo9{;^IRXK38K@yj-b>`$c?8sxi6 z%5^NL0=sI^&LR+tEY8ofX4kp>;iQlp-UNlxJ_?c8@ zQWyxu*?w~%lY6D!r#iSRvS4+{a&?j}8AugEhn1|PbXzf62<~#KPJw@hH``LpYd5g! z6L3C0b*qH%64iR7=%F0K{b~K0e}w5M=%aFNqn_^glP?}lNrZ$Z`$LrBU<2OXabAv6 zZ2N-ba~8rep8SVfa~gCjAf7mfObF-NSn|0ID4r_2gUlKyr}x;w@RjK{%-7SZKSrG% zeThv@K(~Qu**AG;nI)Uo>D+?PCl`we4g0;sseiU5O`2lS74PCA(INL5$7w2XUuFT+ z@Hg_ay5~5gKQr;Af&NHTQ90FC_HhuHAN{7Ii58*mIBbB$9|km67#PP3?pHrn1e6qB zm=<+H149mS4?%bOIlCcs@5gfJ_bQEJNAklrWo8%8S$5y7elDj$I=j%6z8AlDz#s&3 zVZe!@)}$f%M)>M+^yp#=F|2fczvVkoDJA#nzDb+B3I~(e&wH01Iv$l0EYS^9kLTQu zWN@EOJRL3n@DtWyQ&3NKTs3Bm`enlELuW3_T~rIqS5P7}*F(E%L1YA+RJo_aIodE8 z=JIOd^_*z$WY|~+?xJ+lg^F9vI4=%wezoFG+yxc4MxWCBJowEDId9&f7?X(AB zUM)`ZAI3bs@Xl!NXP8&dlQuRF7m$H9RW;N-&xn|Ujf%SVo6T;r`}t6i3ZGU5sbt;AFM zb!VS^{?%WgwM1e_nh=`PwfFs5b1eI2h zE&(YCNhPO9r*sdb2gu0581UQY`+c6@bI$%}=Wrjm?)UY+UN7KWGa|y^qrYKonvTN~ zW2s7ss_=n%zlU2NKYtF-Ab9M}XIEh&XwA#R+xyqrb=((jqqDBT)1-S!OC^o@glhtk z#STx5RyH|)o$Bd6`V#2BL*&4~SZHZ%`x>uM!l$9LZ_mi>u)P;6{-!$~^CwNN++Z_x z(7{?}U!%K|tBU*A3NBz-d+vW=9E5*!r?#{J2?>T;xh50rl}pPU-)=6NLL2Glf+L@B zVfgG8oEj=9RNpG|OD=53m90*k|7!|`*{T0J2h)HV{a(6RQGGd894iO)-M`yifxHsW znAC(_pT3n$rA>WrvO$9bgQjFD+Jng71O3zZ{-nH7PXpy-aM&Z2R`54SZ?G`62Ezy`Zbxs}`o?UdSr_Uy~?Ff1ipkUcOhFO4?L z&}ds9lP{sDpHH)OClfpQ`J!M)6^6?2;*}XOo7kB z`)c=es}M}1XF)Fma`L6Mc`yc%$6|LOdE=4N*={f9x+m0i88B*ajm-MWV(tE&R&f>* z`a)e{lxm?2kpxBhe^zNA6O6Cu-l@Fklk2&jGF(w$($2@a4ev0DNv! zeLV+YE4+9A{U$7ocvP{LxWg(CkgRD1qeT@F#7y||3vhX(fnK7%*_Un-TyW}?0dzN- z=Rb;e+xz?SE_!=hMPrS_0?!sLok5C&x!#ZxI_)?TJXm<%T55}Jt!Q=wo4u#|QT=mJ z(&kX>ps)fQo_Ktu@h^7%F^?Bx&>GeOdu#4cE*2e>pnz#2Wo%35PN2VtV z25>Z*d~mC);cb56P-pm{XiHXfsrYf$qm}MIqrx#lzhuFUl~R2^Zk$ydy%8dkjE;E` zVQKVS8NwC7wQt=Vcmb|{ub4_N^j#Ti7GKlL_Erkx$qYPIj~~7=mcKSNRCkS!Yrkj5 zvx3X5L*iAnbQqTr|iZg$p@!k>U70;tQdu+B|Di zn~NLz!0`yO;5_kgo+SUgs@A~DY2S3PEO(2AnIZkSY&w5YQhq7)F}*++ThY2*Yc8F9 z2zj6Z?hA<;E4f=FP_=>*Ct>$zrYN9$g2?KLR);qBvg6) zQEj_Usj`K8Kgx-l5(D|&=`n6rA%nXzP93MlW4q_Of$+?uc%MktRctu%2eM5-c zA#QiAr8}lfS6wxxQn#ny6<_Ge(DK^#hqahs^GI(mm#)4@j?X)I3>0HbNdp)Y_-{^+ za~?aLXydJC^PYU{`fGg;31!5G?#`okFMafltL0r8-?{=p9wm1)bV%wrL!TxN=45qV zcaN?eMImSrW-Xt1BAksp%G3S4<9sh6#`i5wz76hM6F8PewcgsSG9G=`Eos9P41gSq z>TOcxyHrL>IQ1-S$@yVpXkzNpS8L#DRt11OpoEj_)md@h_$rxO@>^+2>4$WL7h1*w zAX~XF79;@KoT6>r{yS=&0a_{`oJR3O*PIU3rKwFcX&Jw`31}@+x^CHCkE#p-VO_EEOnnP30C2e^djm)C1tdADKdyB_5Y?9j}62j6ap6xe4gr{W1QetUHd3wF>_h*~Z;le9SZy z9O-f@1&`-=U?c3Nm6$xDM!i|e^V*n zPiuvkJAs%~4sVIZh!0(Drd#*uIQ-ydHhOZ~#Vbk}-`}gRQ^g9C>R@x~31DKb<3q&O z<;cIi`#Go-i3#H0Iz5VLd06|xzqaGZsNQ{ov!NVSns{@|30I&`ePs)#Xix8z>HFa9 zjz!X7Wx~)PDJzTpo4y+3(^@&P zbC#L=-C(XHwR3oZwA_b|gL3Eb-aQ|&n3hCc;`lE%C}EVhFJ6(3J44D4fQNng)K29wF{dqdcSzDuX3gdg?Q<^IM}bqI<$Uz7buuDv6j z1je)f*9JNJk0<>fQkpOVyV!>n&dphu>H^~24MqQxcV|B(MztQ(g&{ks?*v>M?bKuC zHz*?V=(4G+a{zX^B(_c<=^7uJFBf&Vb&KT!xFDCLgVXR|cDdTCtDOYt@u@OS^yitd z3$F%GG6Req@1{&3o6e`&qZ&f4#i+F=P8V$I9ljGSR`$DLP2778x`UBGH(S&`@nod- z^nRjhG*17L@^|~6g;_UD5MZA1Q5|^gGv7poTB_gQ;6;9)*xcZ=6QQ$XYFCFm$Apx8 z9K!T#ipeDcXVS-};=1N%OgG?eO@uiy(KEBNK@qf=h8sE@a7@$!U(2^1&HP#8MyKVr zr1Z~gKuQSW-hL@ZoQ&^tHqVrRWB$&zYFIPz$5E)F`Ot3Da6e@*v@Wd-prvgWyc`em zypvbHuQTQemb}}nNxeLdGRIub5A$30iM?LBc553FN_Cl;_w4z?WA~28qhw0&%mFc zvQ&y%XH1T*U!zTLC4Cq>$bu0L$H$yl2sL5GwU(iC?4e^Dl2j{$ zw>Dpa(CDqJIOt&MF#Zvz5s{hF8BXnY&@k&f^8B|Q^M|FPr6$zN zDnL?O8|kDoztMl^T!MjItq!MwQeV%nXsb}C9il6W8p0^${#!--BnuatwJ;`V^qRrG z3C1&q3r(JulPg=osc*jAsSp3E_R&HCbc$%!c&xuxj{rpv{e%aOd8q3gx^^1s5=61w z4{Cdf!K{?6A4?#$7%=_qyOeo0>j5;PL4;~WgTc&duiIPFM$}#Yo3F17ak%&w^(f8d z@c^E0MEEh&nfjz?W00dDV1L+Q-WF~}M;-6kzBVRKwzX-*Fj2x*nuAoy6C=O?;?*~_ z4NB}u*2fVpwFQUMYHnAQ)J6Qo(u94`J^2D6`5*p9{Wz{;*rKL*6%*eXE?_eAV%;X! z;<+#rW(VYnWm87woiAH$YZ&jGPZSqm#n9^Ir5-=x{@S2}lMlFT0WkDYawlAv=q1K- z5frycxXU0}9_eBmewt*v;&eKVx?v=_hLEs*=&U&kX$ax|{wJ)-_vM1j#Z zu%4XEwXxHkDfa_7<{^5j0B{v4eXNbd1QzYze>>mMcC0Ck&DID3?T|Un!ZCawzN@Dm zX=8$W^X_w2zvjzD(u_RBLAqn0aH?hK!FaH@TrHpVgUrtSQesS1_6HEg)tUE31DIHC z!NY86G8JeJ51@>8!h7%m6zdv`J0n*YCW)yySM| zFj&%dqqyRJOQgvuguZWZmtLzBh@Br%`&at4o65PsR2S_fDoSen>ZI7+BjF}40XlEL zi6y4Rx)v$vH%Zlu{)yG+mBkt@j7jLiPh{U_H*G;Uo@wZtEbAhRA@&V!BL>Eh&a zxaG_9f>?klW+;oiq}i^m)2W9rC<4 zDFNr1{Hf{UW>)&|iJ^kL*Hj*no>!SW zHr*p{T&I{D@H=)j^@Dr^u*0Lbbd3#Nw*pDb6%XRvzk39v7wLK&fn}}JJie^y^O+k*e|xV6 z_o*{q;XDHAJw{@bcGDYVO;Y`jpHbyhum?^S=5;pyQ;KuL_}Rf&ZgUu38fWtqumi_t z(dj^$54U>20>9-xJqXB>&;8yxn}@PXSucDQA(_F=!53l4pxY75PsIYpvYiJoWz^IQ zoPs~m4n1nI$Rh7>^Kh#_^5iP4GvybO7ByMs0ilqfi=MOU!T>Y<>B9&8XJ59dmh-rY zmuFJr4!A1+ejRV*o8Ot9Ku1J7^|UdrQaB`>=X2+{PX9E^Yd*e$2p4>Jc;htgTr)I! z_jPNiZ1ZZ-d70QRde^zxsXfm62C#P9?C)$GB!+H!(X0IQK;WI!gA1wp=TzI2dWXlJ z*uEJ)^hA1TZcRs;Eia#LZLw6D3g(R~r)#)hrjK>B1Ww~;U+aqNbj*8J9HLJJXaDGr zt<=C1D~{C>&YeT{bLhci+XK-V&e=sq)Bwi1Kn!RnT*V zearLlV7I_F(g)ocSM*=FWuI=xodesx?i7jRIIoo-@YXKBF!vHB#hs*SEiSZomRj&v z-|ud%>|3iyH3)pk$>{2m5Ck^c`Qlg5>LKqd`gXO7-uB}{@m4n9{EH2tajV#mOKkx! z+IH>-t;yX*-kJgOvUZzB75n!)(G`1T&ZI#CE#~2w^E#u-=mp0-BegiGzPhY7AAMrR z#zyl)JmgykNIaMNy>x1*^chs-w~d{QsA&nGD%P0Sae-=;-%qBFW61;YXt{ptKsnE8 zJrLbO?Hu#uxz^6RXKC5R1zGb~f}$22=4a+Q@@IOKA1EEa_Olb*_DdmlGHqQMmnZ$q z2+Z@B+PO2|9@toAxion6S7?k&AUM@&zemHiobz9s6DUB;>|G3!>wQR?AaUH>{Q6TE z&J*-UuecTQiHi%Bpc$EUth|y_**8sL#-7PHn8g8KIRLJ}WV=?35EzkLsYP#oT}^m2R?K;TrZ& zG)>mj6y{&$o5O&XLPGXG8B_L&ug*~G!vQKxIy;vR6QAkdF0oS+*AT|76)bS@TUuhoPljiB{F1$NyUy z=??$E2VlDm;aZ?=%4Pr2+*ffM)D&GFK#QOj`W$fqIT{Jh^-Dd#6hmS}RJuipBcx63+bycyaGrb~6Ff!@iBv4%1SIz%~{#Cq7}fT%z>BLc{) z4n5qry`0!nUj-LsvixwPn8uclx-ugR7U(9-d_0&N=7YPZxJX}P+;d}wRlr#zW=N~R zjf^L-S0OM>_xke7Tvq4L{p*xcj+lZlcfCi~kX54{%|R&Ufv6_F@=oL|mTKkYZ*iO; zU#rguM#a`(fo-Xt&KrqE6L1yCpG z1cZx;jpa-sgP-3vV3)Mwjs!5>yYEJe6-Yt8B~R^`DAghUV=ie~8IKNK%Fxt>2lJ`E zC(DrYJjNdAd?0c80q3x9jw(+2fDqJ02nBxVr2^FHJ5GukU0iDttz@P33ioHg(;CAu80u5He5wqpc>i&J z{t2JA3mq|6ijkR~_2g~#8r&nivCN978{XG^kZ^_H?y%>N(T~29Z=>Il%3~fG!@JSA z1%-I5xhS*2v!#e0nd{UUg$?CAbawdhRBC}Btq1a#>&D|})$CfMKndn@u|w6iUz9PK z0vNEXi(v^sF?rYzvL9^e#1eD*Wwu|Ji!|}VI_qKJ%0%HQyxR)6UkNhilY&vP3k!QA!XsXee;4Vqtdma~CT{TFHt|~5UI?nI(AcgZu zORjq}{z6^P(YOI`0^@osc^9&C)yOB8=e_aSxiFzQ@`D6sq_2!yLr`THPN{9hGjJSR zrch8cWnV4iE4;6^mcL&xyi_w>b{(TC?*t-Q#5gxcO>%F)TAGr~D9re#7ao!ST z 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

X=2 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