From f3486b1dd8eee1f0dd7f4410ac9d22f9a6c31ea7 Mon Sep 17 00:00:00 2001 From: Max Oberberger Date: Thu, 18 Jul 2024 09:00:50 +0200 Subject: [PATCH] Mesh Node Sample v1.0.0 --- .clang-format | 47 ++ .gitattributes | 15 + .gitignore | 4 + CMakeLists.txt | 33 + imported/CMakeLists.txt | 67 ++ imported/agilitysdk-version.patch | 52 ++ imported/binoutput.patch | 13 + imported/cameracomponent.patch | 13 + imported/dxil.patch | 37 + imported/patch-ffx.cmake | 52 ++ imported/update-agilitysdk.cmake | 126 ++++ license.txt | 19 + meshNodeSample/CMakeLists.txt | 101 +++ .../config/meshnodesampleconfig.json | 35 + meshNodeSample/fsr2rendermodule.cpp | 320 +++++++++ meshNodeSample/fsr2rendermodule.h | 125 ++++ meshNodeSample/main.cpp | 139 ++++ meshNodeSample/samplecameracomponent.cpp | 180 +++++ meshNodeSample/samplecameracomponent.h | 34 + meshNodeSample/shadercompiler.cpp | 165 +++++ meshNodeSample/shadercompiler.h | 45 ++ meshNodeSample/shaders/beemeshshader.hlsl | 215 ++++++ meshNodeSample/shaders/biomes.hlsl | 630 ++++++++++++++++++ .../shaders/butterflymeshshader.hlsl | 236 +++++++ meshNodeSample/shaders/common.hlsl | 355 ++++++++++ .../shaders/densegrassmeshshader.hlsl | 206 ++++++ meshNodeSample/shaders/flowermeshshader.hlsl | 397 +++++++++++ meshNodeSample/shaders/grasspixelshader.hlsl | 48 ++ meshNodeSample/shaders/heightmap.hlsl | 121 ++++ meshNodeSample/shaders/insectpixelshader.hlsl | 37 + .../shaders/mushroommeshshader.hlsl | 256 +++++++ meshNodeSample/shaders/rock.hlsl | 92 +++ meshNodeSample/shaders/shading.hlsl | 74 ++ meshNodeSample/shaders/shadingcommon.h | 44 ++ meshNodeSample/shaders/skybox.hlsl | 255 +++++++ .../shaders/sparsegrassmeshshader.hlsl | 145 ++++ meshNodeSample/shaders/splinerenderer.hlsl | 333 +++++++++ meshNodeSample/shaders/terrainrenderer.hlsl | 156 +++++ meshNodeSample/shaders/tree.hlsl | 300 +++++++++ meshNodeSample/shaders/utils.hlsl | 307 +++++++++ meshNodeSample/shaders/workgraphcommon.h | 53 ++ meshNodeSample/shaders/world.hlsl | 176 +++++ meshNodeSample/workgraphrendermodule.cpp | 538 +++++++++++++++ meshNodeSample/workgraphrendermodule.h | 104 +++ readme.md | 60 ++ screenshot.jpg | Bin 0 -> 946040 bytes 46 files changed, 6760 insertions(+) create mode 100644 .clang-format create mode 100644 .gitattributes create mode 100644 .gitignore create mode 100644 CMakeLists.txt create mode 100644 imported/CMakeLists.txt create mode 100644 imported/agilitysdk-version.patch create mode 100644 imported/binoutput.patch create mode 100644 imported/cameracomponent.patch create mode 100644 imported/dxil.patch create mode 100644 imported/patch-ffx.cmake create mode 100644 imported/update-agilitysdk.cmake create mode 100644 license.txt create mode 100644 meshNodeSample/CMakeLists.txt create mode 100644 meshNodeSample/config/meshnodesampleconfig.json create mode 100644 meshNodeSample/fsr2rendermodule.cpp create mode 100644 meshNodeSample/fsr2rendermodule.h create mode 100644 meshNodeSample/main.cpp create mode 100644 meshNodeSample/samplecameracomponent.cpp create mode 100644 meshNodeSample/samplecameracomponent.h create mode 100644 meshNodeSample/shadercompiler.cpp create mode 100644 meshNodeSample/shadercompiler.h create mode 100644 meshNodeSample/shaders/beemeshshader.hlsl create mode 100644 meshNodeSample/shaders/biomes.hlsl create mode 100644 meshNodeSample/shaders/butterflymeshshader.hlsl create mode 100644 meshNodeSample/shaders/common.hlsl create mode 100644 meshNodeSample/shaders/densegrassmeshshader.hlsl create mode 100644 meshNodeSample/shaders/flowermeshshader.hlsl create mode 100644 meshNodeSample/shaders/grasspixelshader.hlsl create mode 100644 meshNodeSample/shaders/heightmap.hlsl create mode 100644 meshNodeSample/shaders/insectpixelshader.hlsl create mode 100644 meshNodeSample/shaders/mushroommeshshader.hlsl create mode 100644 meshNodeSample/shaders/rock.hlsl create mode 100644 meshNodeSample/shaders/shading.hlsl create mode 100644 meshNodeSample/shaders/shadingcommon.h create mode 100644 meshNodeSample/shaders/skybox.hlsl create mode 100644 meshNodeSample/shaders/sparsegrassmeshshader.hlsl create mode 100644 meshNodeSample/shaders/splinerenderer.hlsl create mode 100644 meshNodeSample/shaders/terrainrenderer.hlsl create mode 100644 meshNodeSample/shaders/tree.hlsl create mode 100644 meshNodeSample/shaders/utils.hlsl create mode 100644 meshNodeSample/shaders/workgraphcommon.h create mode 100644 meshNodeSample/shaders/world.hlsl create mode 100644 meshNodeSample/workgraphrendermodule.cpp create mode 100644 meshNodeSample/workgraphrendermodule.h create mode 100644 readme.md create mode 100644 screenshot.jpg diff --git a/.clang-format b/.clang-format new file mode 100644 index 0000000..b70e42b --- /dev/null +++ b/.clang-format @@ -0,0 +1,47 @@ +BasedOnStyle: Google +IndentWidth: 4 +UseTab: Never +ColumnLimit: 160 +Language: Cpp +AccessModifierOffset: -4 +BreakBeforeBraces: Custom +BraceWrapping: + AfterCaseLabel: true + AfterClass: true + AfterControlStatement: true + AfterEnum: true + AfterFunction: true + AfterNamespace: true + AfterObjCDeclaration: true + AfterStruct: true + AfterUnion: true + AfterExternBlock: false + BeforeCatch: true + BeforeElse: true + IndentBraces: false + SplitEmptyFunction: true + SplitEmptyRecord: true + SplitEmptyNamespace: true +ConstructorInitializerAllOnOneLineOrOnePerLine : false +BreakConstructorInitializers: BeforeComma +DerivePointerAlignment: false +IndentCaseLabels: false +NamespaceIndentation: All +AlignConsecutiveAssignments: true +AlignConsecutiveDeclarations: true +AlignEscapedNewlines: Left +AlignTrailingComments: true +AlignOperands: true +AllowShortFunctionsOnASingleLine: false +AllowShortIfStatementsOnASingleLine: false +AllowShortLoopsOnASingleLine: false +AllowShortBlocksOnASingleLine: false +ReflowComments: false +SortIncludes: false +SortUsingDeclarations: false +BinPackArguments: false +BinPackParameters: false +ExperimentalAutoDetectBinPacking: false +AllowAllParametersOfDeclarationOnNextLine: true +AlignConsecutiveMacros: true +AlignAfterOpenBracket: true diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..57fba3b --- /dev/null +++ b/.gitattributes @@ -0,0 +1,15 @@ +# Set the default behavior, in case people don't have core.autocrlf set. +* text=auto + +# Declare files that will always have LF line endings on checkout. +*.c text eol=lf +*.cpp text eol=lf +*.h text eol=lf +*.hpp text eol=lf +*.idl text eol=lf +*.json text eol=lf +*.hlsl text eol=lf +*.patch text eol=lf + +# Denote all files that are truly binary and should not be modified. +*.png binary \ No newline at end of file diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..48b85f3 --- /dev/null +++ b/.gitignore @@ -0,0 +1,4 @@ +# CMake build folder +build +# Binary output folder +bin \ No newline at end of file diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..a8e1f4c --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,33 @@ +# This file is part of the AMD Work Graph Mesh Node Sample. +# +# Copyright (C) 2024 Advanced Micro Devices, Inc. +# +# 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 +# AUTHORS OR COPYRIGHT HOLDERS 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. + +cmake_minimum_required(VERSION 3.17) + +project("Work Graphs Mesh Node Sample" VERSION 0.1.0 LANGUAGES CXX) + +# Import FidelityFX & Cauldron +add_subdirectory(imported) + +# Add Work Graph Mesh Node Sample +add_subdirectory(meshNodeSample) + +set_property(DIRECTORY ${CMAKE_PROJECT_DIR} PROPERTY VS_STARTUP_PROJECT MeshNodeSample) diff --git a/imported/CMakeLists.txt b/imported/CMakeLists.txt new file mode 100644 index 0000000..f4aea3c --- /dev/null +++ b/imported/CMakeLists.txt @@ -0,0 +1,67 @@ +# This file is part of the AMD Work Graph Mesh Node Sample. +# +# Copyright (C) 2024 Advanced Micro Devices, Inc. +# +# 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 +# AUTHORS OR COPYRIGHT HOLDERS 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. + +include(FetchContent) + +FetchContent_Declare( + ffxsdk + GIT_REPOSITORY https://github.com/GPUOpen-LibrariesAndSDKs/FidelityFX-SDK + GIT_TAG 55ff22bb6981a9b9c087b9465101769fc0acd447 # fsr3-v3.0.4 +) + +FetchContent_GetProperties(ffxsdk) + +# manually import FidelityFX SDK +if (NOT ffxsdk_POPULATED) + message(STATUS "Downloading FidelityFX SDK") + FetchContent_Populate(ffxsdk) + message(STATUS "Downloaded FidelityFX SDK to ${ffxsdk_SOURCE_DIR}") + + # set root directory of FidelityFX SDK for patches + set(FFX_ROOT ${ffxsdk_SOURCE_DIR}) + # Apply patches to FidelityFX SDK + include(patch-ffx.cmake) + + # don't build any FFX samples + set(BUILD_TYPE FFX_NONE) + # build FFX SDK with Cauldron backend + set(FFX_API CAULDRON) + # enable FSR2 in FFX SDK. + set(FFX_FSR2 ON) + # FFX_FSR is required for FFX_FSR2, but also enables FFX sample, which also requires FFX_FSR1 + set(FFX_FSR ON) + set(FFX_FSR1 ON) + + # FFX uses CMAKE_HOME_DIRECTORY as root directory for all internal paths + # since FFX is not the top-level repository here, we need to change CMAKE_HOME_DIRECTORY such that all the paths still match up + set(CMAKE_HOME_DIRECTORY ${ffxsdk_SOURCE_DIR}) + add_subdirectory(${ffxsdk_SOURCE_DIR} ${ffxsdk_BINARY_DIR}) + + # Move FFX_FSR sample to folder in solution + set_target_properties(FFX_FSR PROPERTIES FOLDER "FFX Samples") +endif() + +# set root directory of FidelityFX SDK +set(FFX_ROOT ${ffxsdk_SOURCE_DIR} PARENT_SCOPE) + +# propagate configurations to top level; only DX12 is supported for this sample +set(CMAKE_CONFIGURATION_TYPES "DebugDX12;ReleaseDX12;RelWithDebInfoDX12" PARENT_SCOPE) \ No newline at end of file diff --git a/imported/agilitysdk-version.patch b/imported/agilitysdk-version.patch new file mode 100644 index 0000000..60919ee --- /dev/null +++ b/imported/agilitysdk-version.patch @@ -0,0 +1,52 @@ +diff --git a/framework/cauldron/framework/libs/agilitysdk/CAULDRONREADME.md b/framework/cauldron/framework/libs/agilitysdk/CAULDRONREADME.md +index e445450..470c187 100644 +--- a/framework/cauldron/framework/libs/agilitysdk/CAULDRONREADME.md ++++ b/framework/cauldron/framework/libs/agilitysdk/CAULDRONREADME.md +@@ -1,7 +1,7 @@ + # DX12 Agility SDK + + ## Current Version +-1.608.2 ++1.715.0-preview + + ## How to update + 1. Download the latest version (as a .nupkg) from https://devblogs.microsoft.com/directx/directx12agility/ +diff --git a/framework/cauldron/framework/src/render/dx12/device_dx12.cpp b/framework/cauldron/framework/src/render/dx12/device_dx12.cpp +index 6782b97..580ff02 100644 +--- a/framework/cauldron/framework/src/render/dx12/device_dx12.cpp ++++ b/framework/cauldron/framework/src/render/dx12/device_dx12.cpp +@@ -36,7 +36,7 @@ + using namespace Microsoft::WRL; + + // D3D12SDKVersion needs to line up with the version number on Microsoft's DirectX12 Agility SDK Download page +-extern "C" { __declspec(dllexport) extern const UINT D3D12SDKVersion = 608; } ++extern "C" { __declspec(dllexport) extern const UINT D3D12SDKVersion = 715; } + extern "C" { __declspec(dllexport) extern const char* D3D12SDKPath = u8".\\D3D12\\"; } + + namespace cauldron +diff --git a/sdk/tools/ffx_shader_compiler/libs/agilitysdk/FFX_SDK_README.md b/sdk/tools/ffx_shader_compiler/libs/agilitysdk/FFX_SDK_README.md +index d3ae9cd..db89102 100644 +--- a/sdk/tools/ffx_shader_compiler/libs/agilitysdk/FFX_SDK_README.md ++++ b/sdk/tools/ffx_shader_compiler/libs/agilitysdk/FFX_SDK_README.md +@@ -1,7 +1,7 @@ + # DX12 Agility SDK + + ## Current Version +-1.608.2 ++1.715.0-preview + + ## How to update + 1. Download the latest version (as a .nupkg) from https://devblogs.microsoft.com/directx/directx12agility/ +diff --git a/sdk/tools/ffx_shader_compiler/src/hlsl_compiler.cpp b/sdk/tools/ffx_shader_compiler/src/hlsl_compiler.cpp +index 5375d3d..39884e1 100644 +--- a/sdk/tools/ffx_shader_compiler/src/hlsl_compiler.cpp ++++ b/sdk/tools/ffx_shader_compiler/src/hlsl_compiler.cpp +@@ -24,7 +24,7 @@ + #include "utils.h" + + // D3D12SDKVersion needs to line up with the version number on Microsoft's DirectX12 Agility SDK Download page +-extern "C" { __declspec(dllexport) extern const UINT D3D12SDKVersion = 608; } ++extern "C" { __declspec(dllexport) extern const UINT D3D12SDKVersion = 715; } + extern "C" { __declspec(dllexport) extern const char* D3D12SDKPath = u8".\\D3D12\\"; } + + struct DxcCustomIncludeHandler : public IDxcIncludeHandler diff --git a/imported/binoutput.patch b/imported/binoutput.patch new file mode 100644 index 0000000..f9c0915 --- /dev/null +++ b/imported/binoutput.patch @@ -0,0 +1,13 @@ +diff --git a/common.cmake b/common.cmake +index 88aeb5d..4a2283b 100644 +--- a/common.cmake ++++ b/common.cmake +@@ -40,7 +40,7 @@ endif() + set(SAMPLE_ROOT ${CMAKE_HOME_DIRECTORY}/samples) + set(SDK_ROOT ${CMAKE_HOME_DIRECTORY}/sdk) + set(FRAMEWORK_ROOT ${CMAKE_HOME_DIRECTORY}/framework) +-set(BIN_OUTPUT ${CMAKE_HOME_DIRECTORY}/bin) ++set(BIN_OUTPUT ${CMAKE_SOURCE_DIR}/bin) + set(CAULDRON_ROOT ${FRAMEWORK_ROOT}/cauldron) + set(RENDERMODULE_ROOT ${FRAMEWORK_ROOT}/rendermodules) + set(FFX_API_CAULDRON_ROOT ${SAMPLE_ROOT}/ffx_cauldron) diff --git a/imported/cameracomponent.patch b/imported/cameracomponent.patch new file mode 100644 index 0000000..8b21864 --- /dev/null +++ b/imported/cameracomponent.patch @@ -0,0 +1,13 @@ +diff --git a/framework/cauldron/framework/inc/core/components/cameracomponent.h b/framework/cauldron/framework/inc/core/components/cameracomponent.h +index 114b5db..33a274d 100644 +--- a/framework/cauldron/framework/inc/core/components/cameracomponent.h ++++ b/framework/cauldron/framework/inc/core/components/cameracomponent.h +@@ -245,7 +245,7 @@ namespace cauldron + */ + static void SetJitterCallbackFunc(CameraJitterCallback callbackFunc) { s_pSetJitterCallback = callbackFunc; } + +- private: ++ protected: + CameraComponent() = delete; + + void ResetCamera(); diff --git a/imported/dxil.patch b/imported/dxil.patch new file mode 100644 index 0000000..f452d2f --- /dev/null +++ b/imported/dxil.patch @@ -0,0 +1,37 @@ +diff --git a/framework/cauldron/framework/libs/dxc/CMakeLists.txt b/framework/cauldron/framework/libs/dxc/CMakeLists.txt +index 6695b76..fad43bb 100644 +--- a/framework/cauldron/framework/libs/dxc/CMakeLists.txt ++++ b/framework/cauldron/framework/libs/dxc/CMakeLists.txt +@@ -2,8 +2,7 @@ add_library(dxc INTERFACE) + target_include_directories(dxc INTERFACE BEFORE "inc/") + + set(dxc_binaries +- ${CMAKE_CURRENT_SOURCE_DIR}/bin/x64/dxcompiler.dll +- ${CMAKE_CURRENT_SOURCE_DIR}/bin/x64/dxil.dll) ++ ${CMAKE_CURRENT_SOURCE_DIR}/bin/x64/dxcompiler.dll) + + copyTargetCommand("${dxc_binaries}" ${BIN_OUTPUT} copied_dxc_bin) + add_dependencies(dxc copied_dxc_bin) +\ No newline at end of file +diff --git a/framework/cauldron/framework/src/render/win/shaderbuilder_win.cpp b/framework/cauldron/framework/src/render/win/shaderbuilder_win.cpp +index 4847f86..47e2b50 100644 +--- a/framework/cauldron/framework/src/render/win/shaderbuilder_win.cpp ++++ b/framework/cauldron/framework/src/render/win/shaderbuilder_win.cpp +@@ -312,14 +312,10 @@ namespace cauldron + ComPtr pCompiledResult; + pCompiler->Compile(&shaderCodeBuffer, arguments.data(), static_cast(arguments.size()), &includeFileHandler, IID_PPV_ARGS(&pCompiledResult)); + +- // Handle any errors if they occurred +- ComPtr pErrors; // wide version currently doesn't appear to be supported +- pCompiledResult->GetOutput(DXC_OUT_ERRORS, IID_PPV_ARGS(&pErrors), nullptr); +- if (pErrors && pErrors->GetStringLength() > 0) ++ HRESULT compileStatus; ++ if (FAILED(pCompiledResult->GetStatus(&compileStatus)) || FAILED(compileStatus)) + { +- std::string errorString = pErrors->GetStringPointer(); +- std::wstring errorWString = StringToWString(errorString.c_str()); +- CauldronCritical(L"%ls : %ls", (shaderFile)? filePath.c_str() : L"ShaderCodeString", errorWString.c_str()); ++ CauldronCritical(L"%ls", (shaderFile)? filePath.c_str() : L"ShaderCodeString"); + return nullptr; + } + diff --git a/imported/patch-ffx.cmake b/imported/patch-ffx.cmake new file mode 100644 index 0000000..4eea100 --- /dev/null +++ b/imported/patch-ffx.cmake @@ -0,0 +1,52 @@ +# This file is part of the AMD Work Graph Mesh Node Sample. +# +# Copyright (C) 2024 Advanced Micro Devices, Inc. +# +# 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 +# AUTHORS OR COPYRIGHT HOLDERS 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. + +# This scripts applies small modifications to the FidelityFX & Cauldron SDK +# Patches: +# - Update Microsoft Agility SDK to 714 +# - patch camera component to allow for custom implementation + +# Update Agility SDK +include(update-agilitysdk.cmake) + +find_package(Git) + +message(STATUS "Patching cameracomponent.h") +# Patch camera component +execute_process(COMMAND "${GIT_EXECUTABLE}" apply "${CMAKE_CURRENT_SOURCE_DIR}/cameracomponent.patch" + WORKING_DIRECTORY "${FFX_ROOT}" + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) + +message(STATUS "Patching common.cmake") +# Patch bin output directory +execute_process(COMMAND "${GIT_EXECUTABLE}" apply "${CMAKE_CURRENT_SOURCE_DIR}/binoutput.patch" + WORKING_DIRECTORY "${FFX_ROOT}" + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) + +message(STATUS "Patching dxil.dll copy") +# Patch copying of dxil.dll to output directory +execute_process(COMMAND "${GIT_EXECUTABLE}" apply "${CMAKE_CURRENT_SOURCE_DIR}/dxil.patch" + WORKING_DIRECTORY "${FFX_ROOT}" + #ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) diff --git a/imported/update-agilitysdk.cmake b/imported/update-agilitysdk.cmake new file mode 100644 index 0000000..f18d0d5 --- /dev/null +++ b/imported/update-agilitysdk.cmake @@ -0,0 +1,126 @@ +# This file is part of the AMD Work Graph Mesh Node Sample. +# +# Copyright (C) 2024 Advanced Micro Devices, Inc. +# +# 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 +# AUTHORS OR COPYRIGHT HOLDERS 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. + +# This script will download the Microsoft Agility SDK & DirectX Shader compiler from the official NuGet package repository +# Update these URLs and perform a clean build if you wish to use a newer version of these packages. +set(AGILITY_SDK_URL "https://www.nuget.org/api/v2/package/Microsoft.Direct3D.D3D12/1.715.0-preview") +set(DXC_URL "https://www.nuget.org/api/v2/package/Microsoft.Direct3D.DXC/1.8.2404.55-mesh-nodes-preview") + +# Check if Agility SDK NuGet package was already downloaded +if (NOT EXISTS ${CMAKE_CURRENT_BINARY_DIR}/agilitySDK.zip) + message(STATUS "Downloading Agility SDK from ${AGILITY_SDK_URL}") + + file(DOWNLOAD ${AGILITY_SDK_URL} ${CMAKE_CURRENT_BINARY_DIR}/agilitySDK.zip STATUS DOWNLOAD_RESULT) + + list(GET DOWNLOAD_RESULT 0 DOWNLOAD_RESULT_CODE) + if(NOT DOWNLOAD_RESULT_CODE EQUAL 0) + message(FATAL_ERROR "Failed to download Agility SDK! Error: ${DOWNLOAD_RESULT}.") + endif() + + message(STATUS "Successfully downloaded Agility SDK") +else() + message(STATUS "Found local copy of ${AGILITY_SDK_URL} in ${CMAKE_CURRENT_BINARY_DIR}/agilitySDK.zip. Skipping download.") +endif() + +message(STATUS "Extracting Agility SDK") + +# extract agility SDK zip +file(ARCHIVE_EXTRACT + INPUT ${CMAKE_CURRENT_BINARY_DIR}/agilitySDK.zip + DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/agilitySDK) + +# validate agility SDK binaries +if(NOT EXISTS ${CMAKE_CURRENT_BINARY_DIR}/agilitySDK/build/native/bin/x64/D3D12Core.dll OR + NOT EXISTS ${CMAKE_CURRENT_BINARY_DIR}/agilitySDK/build/native/bin/x64/d3d12SDKLayers.dll) + message(FATAL_ERROR "Failed to extract Agility SDK!") +endif() + +message(STATUS "Successfully extracted Agility SDK") + +set(CAULDRON_AGILITY_SDK_PATH ${FFX_ROOT}/framework/cauldron/framework/libs/agilitysdk) + +# copy Agility SDK binaries +file(COPY_FILE ${CMAKE_CURRENT_BINARY_DIR}/agilitySDK/build/native/bin/x64/D3D12Core.dll ${CAULDRON_AGILITY_SDK_PATH}/bin/x64/D3D12Core.dll) +file(COPY_FILE ${CMAKE_CURRENT_BINARY_DIR}/agilitySDK/build/native/bin/x64/D3D12Core.pdb ${CAULDRON_AGILITY_SDK_PATH}/bin/x64/D3D12Core.pdb) +file(COPY_FILE ${CMAKE_CURRENT_BINARY_DIR}/agilitySDK/build/native/bin/x64/d3d12SDKLayers.dll ${CAULDRON_AGILITY_SDK_PATH}/bin/x64/d3d12SDKLayers.dll) +file(COPY_FILE ${CMAKE_CURRENT_BINARY_DIR}/agilitySDK/build/native/bin/x64/d3d12SDKLayers.pdb ${CAULDRON_AGILITY_SDK_PATH}/bin/x64/d3d12SDKLayers.pdb) +file(COPY_FILE ${CMAKE_CURRENT_BINARY_DIR}/agilitySDK/build/native/bin/x64/d3dconfig.exe ${CAULDRON_AGILITY_SDK_PATH}/bin/x64/d3dconfig.exe) +file(COPY_FILE ${CMAKE_CURRENT_BINARY_DIR}/agilitySDK/build/native/bin/x64/d3dconfig.pdb ${CAULDRON_AGILITY_SDK_PATH}/bin/x64/d3dconfig.pdb) + +# copy Agility SDK headers +file(COPY ${CMAKE_CURRENT_BINARY_DIR}/agilitySDK/build/native/include DESTINATION ${CAULDRON_AGILITY_SDK_PATH}) + +message(STATUS "Successfully copied Agility SDK to Cauldron source") + +# Check if DXC NuGet package was already downloaded +if (NOT EXISTS ${CMAKE_CURRENT_BINARY_DIR}/dxc.zip) + message(STATUS "Downloading DirectX Shader Compiler from ${DXC_URL}") + + file(DOWNLOAD ${DXC_URL} ${CMAKE_CURRENT_BINARY_DIR}/dxc.zip STATUS DOWNLOAD_RESULT) + + list(GET DOWNLOAD_RESULT 0 DOWNLOAD_RESULT_CODE) + if(NOT DOWNLOAD_RESULT_CODE EQUAL 0) + message(FATAL_ERROR "Failed to download DirectX Shader Compiler! Error: ${DOWNLOAD_RESULT}.") + endif() + + message(STATUS "Successfully downloaded DirectX Shader Compiler") +else() + message(STATUS "Found local copy of ${DXC_URL} in ${CMAKE_CURRENT_BINARY_DIR}/dxc.zip. Skipping download.") +endif() + +message(STATUS "Extracting DirectX Shader Compiler") + +# extract dxc zip +file(ARCHIVE_EXTRACT + INPUT ${CMAKE_CURRENT_BINARY_DIR}/dxc.zip + DESTINATION ${CMAKE_CURRENT_BINARY_DIR}/dxc) + +# validate DXC binaries +if(NOT EXISTS ${CMAKE_CURRENT_BINARY_DIR}/dxc/build/native/bin/x64/dxcompiler.dll) + message(FATAL_ERROR "Failed to extract DirectX Shader Compiler!") +endif() + +message(STATUS "Successfully extracted DirectX Shader Compiler") + +set(CAULDRON_DXC_PATH ${FFX_ROOT}/framework/cauldron/framework/libs/dxc) + +# copy dxc binaries +file(COPY_FILE ${CMAKE_CURRENT_BINARY_DIR}/dxc/build/native/bin/x64/dxcompiler.dll ${CAULDRON_DXC_PATH}/bin/x64/dxcompiler.dll) +file(COPY_FILE ${CMAKE_CURRENT_BINARY_DIR}/dxc/build/native/bin/x64/dxc.exe ${CAULDRON_DXC_PATH}/bin/x64/dxc.exe) +file(COPY_FILE ${CMAKE_CURRENT_BINARY_DIR}/dxc/build/native/lib/x64/dxcompiler.lib ${CAULDRON_DXC_PATH}/lib/x64/dxcompiler.lib) + +# copy dxc headers +file(COPY_FILE ${CMAKE_CURRENT_BINARY_DIR}/dxc/build/native/include/d3d12shader.h ${CAULDRON_DXC_PATH}/inc/d3d12shader.h) +file(COPY_FILE ${CMAKE_CURRENT_BINARY_DIR}/dxc/build/native/include/dxcapi.h ${CAULDRON_DXC_PATH}/inc/dxcapi.h) +file(COPY_FILE ${CMAKE_CURRENT_BINARY_DIR}/dxc/build/native/include/dxcerrors.h ${CAULDRON_DXC_PATH}/inc/dxcerrors.h) +file(COPY_FILE ${CMAKE_CURRENT_BINARY_DIR}/dxc/build/native/include/dxcisense.h ${CAULDRON_DXC_PATH}/inc/dxcisense.h) + +message(STATUS "Successfully copied DirectX Shader Compiler to Cauldron source") + +message(STATUS "Patching Agility SDK version") + +# find git and apply a patch to FFX +find_package(Git) +execute_process(COMMAND "${GIT_EXECUTABLE}" apply "${CMAKE_CURRENT_SOURCE_DIR}/agilitysdk-version.patch" + WORKING_DIRECTORY "${FFX_ROOT}" + ERROR_QUIET + OUTPUT_STRIP_TRAILING_WHITESPACE) \ No newline at end of file diff --git a/license.txt b/license.txt new file mode 100644 index 0000000..6c7cab2 --- /dev/null +++ b/license.txt @@ -0,0 +1,19 @@ +Copyright (c) 2024 Advanced Micro Devices, Inc. All rights reserved. + +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 +AUTHORS OR COPYRIGHT HOLDERS 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. \ No newline at end of file diff --git a/meshNodeSample/CMakeLists.txt b/meshNodeSample/CMakeLists.txt new file mode 100644 index 0000000..2433f29 --- /dev/null +++ b/meshNodeSample/CMakeLists.txt @@ -0,0 +1,101 @@ +# This file is part of the AMD Work Graph Mesh Node Sample. +# +# Copyright (C) 2024 Advanced Micro Devices, Inc. +# +# 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 +# AUTHORS OR COPYRIGHT HOLDERS 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. + +# Declare project +project(MeshNodeSample) + +# --------------------------------------------- +# Import FFX config +# --------------------------------------------- +# FidelityFX uses CMAKE_HOME_DIRECTORY as base for all paths +set(CMAKE_HOME_DIRECTORY ${FFX_ROOT}) +include(${FFX_ROOT}/common.cmake) +include(${FFX_ROOT}/sample.cmake) + +# Set compile definitions from Cauldron/FidelityFX +set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS + $<$:_DX12 _WIN> + $<$:_DX12 _WIN _RELEASE> + $<$:_DX12 _WIN _RELEASE> + FFX_API_CAULDRON + NOMINMAX +) + +# Output exe to bin directory +set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${BIN_OUTPUT}) +foreach( OUTPUTCONFIG ${CMAKE_CONFIGURATION_TYPES} ) + string( TOUPPER ${OUTPUTCONFIG} OUTPUTCONFIG ) + set( CMAKE_RUNTIME_OUTPUT_DIRECTORY_${OUTPUTCONFIG} ${BIN_OUTPUT} ) +endforeach( OUTPUTCONFIG CMAKE_CONFIGURATION_TYPES ) + +# --------------------------------------------- +# Sample render module +# --------------------------------------------- + +file(GLOB meshnodesample_src + ${CMAKE_CURRENT_SOURCE_DIR}/*.h + ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp) +file(GLOB meshnodesample_shaders + ${CMAKE_CURRENT_SOURCE_DIR}/shaders/*.h + ${CMAKE_CURRENT_SOURCE_DIR}/shaders/*.hlsl) +set_source_files_properties(${meshnodesample_shaders} PROPERTIES VS_TOOL_OVERRIDE "Text") +copyCommand("${meshnodesample_shaders}" ${SHADER_OUTPUT}) + +# Add config file +set(config_file ${CMAKE_CURRENT_SOURCE_DIR}/config/meshnodesampleconfig.json) +copyCommand("${config_file}" ${CONFIG_OUTPUT}) + +# Add the sample to the solution +add_executable(${PROJECT_NAME} WIN32 ${default_icon_src} ${config_file} ${meshnodesample_src} ${meshnodesample_shaders} ${ffx_remap}) + +# Setup the correct exe based on backend name +set(EXE_OUT_NAME ${PROJECT_NAME}_) + +# Link everything (including the compiler for now) +target_link_libraries(${PROJECT_NAME} LINK_PUBLIC Framework RenderModules d3dcompiler ffx_fsr2_x64) +set_target_properties(${PROJECT_NAME} PROPERTIES + OUTPUT_NAME_DEBUGDX12 "${EXE_OUT_NAME}DX12D" + OUTPUT_NAME_DEBUGVK "${EXE_OUT_NAME}VKD" + OUTPUT_NAME_RELEASEDX12 "${EXE_OUT_NAME}DX12" + OUTPUT_NAME_RELEASEVK "${EXE_OUT_NAME}VK" + VS_DEBUGGER_WORKING_DIRECTORY "${BIN_OUTPUT}") + +# Add manifest info +addManifest(${PROJECT_NAME}) + +# Add dependency information +add_dependencies(${PROJECT_NAME} Framework) +add_dependencies(${PROJECT_NAME} RenderModules) +add_dependencies(${PROJECT_NAME} ffx_fsr2_x64) + +# Link the correct backend in + +target_link_libraries(${PROJECT_NAME} LINK_PUBLIC ffx_backend_cauldron_x64) +add_dependencies(${PROJECT_NAME} ffx_backend_cauldron_x64) +target_include_directories(${PROJECT_NAME} PUBLIC ${FFX_API_CAULDRON_ROOT} ${CMAKE_SOURCE_DIR}) + +# And solution layout definitions +source_group("" FILES ${ffx_remap}) +source_group("Icon" FILES ${default_icon_src}) +source_group("Config" FILES ${config_file}) +source_group("Sample" FILES ${meshnodesample_src}) +source_group("Sample\\Shaders" FILES ${meshnodesample_shaders}) diff --git a/meshNodeSample/config/meshnodesampleconfig.json b/meshNodeSample/config/meshnodesampleconfig.json new file mode 100644 index 0000000..4b5144b --- /dev/null +++ b/meshNodeSample/config/meshnodesampleconfig.json @@ -0,0 +1,35 @@ +{ + "Mesh Node Sample": { + "RenderResources": { + "GBufferColorTarget": { + "Format": "RGB10A2_UNORM", + "RenderResolution": true + }, + "GBufferNormalTarget": { + "Format": "RGBA16_FLOAT", + "RenderResolution": true + }, + "GBufferMotionVectorTarget": { + "Format": "RG16_FLOAT", + "RenderResolution": true + }, + "GBufferDepthTarget": "DepthTarget" + }, + + "RenderModules": [ + "WorkGraphRenderModule", + "FSR2RenderModule", + "ToneMappingRenderModule" + ], + + "Allocations": { + "GPUResourceViewCount": 200000, + "CPUResourceViewCount": 200000 + }, + + "InvertedDepth": false, + "Content": { + "SceneExposure": 0.5 + } + } +} diff --git a/meshNodeSample/fsr2rendermodule.cpp b/meshNodeSample/fsr2rendermodule.cpp new file mode 100644 index 0000000..1d28fcb --- /dev/null +++ b/meshNodeSample/fsr2rendermodule.cpp @@ -0,0 +1,320 @@ +// This file is part of the AMD Work Graph Mesh Node Sample. +// +// Copyright (c) 2024 Advanced Micro Devices, Inc. All rights reserved. +// +// 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 +// AUTHORS OR COPYRIGHT HOLDERS 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. + +#include "fsr2rendermodule.h" + +#include + +#include + +#include "core/scene.h" +#include "render/dynamicresourcepool.h" +#include "render/profiler.h" +#include "render/rasterview.h" +#include "render/uploadheap.h" +#include "validation_remap.h" + +using namespace cauldron; + +void FSR2RenderModule::Init(const json& initData) +{ + // Fetch needed resources + m_pColorTarget = GetFramework()->GetColorTargetForCallback(GetName()); + m_pDepthTarget = GetFramework()->GetRenderTexture(L"GBufferDepthTarget"); + m_pMotionVectors = GetFramework()->GetRenderTexture(L"GBufferMotionVectorTarget"); + + CauldronAssert(ASSERT_CRITICAL, m_pColorTarget && m_pDepthTarget && m_pMotionVectors, L"Could not get one of the needed resources for FSR2 Rendermodule."); + + // Set our render resolution function as that to use during resize to get render width/height from display + // width/height + m_pUpdateFunc = [this](uint32_t displayWidth, uint32_t displayHeight) { return this->UpdateResolution(displayWidth, displayHeight); }; + + // UI + InitUI(); + + ////////////////////////////////////////////////////////////////////////// + // Finish up init + + // Start disabled as this will be enabled externally + SetModuleEnabled(false); + + // That's all we need for now + SetModuleReady(true); +} + +FSR2RenderModule::~FSR2RenderModule() +{ + // Protection + if (ModuleEnabled()) + EnableModule(false); // Destroy FSR context +} + +void FSR2RenderModule::EnableModule(bool enabled) +{ + // If disabling the render module, we need to disable the upscaler with the framework + if (enabled) + { + // Setup everything needed when activating FSR + // Will also enable upscaling + UpdatePreset(nullptr); + + // Toggle this now so we avoid the context changes in OnResize + SetModuleEnabled(enabled); + + // Setup Cauldron FidelityFX interface. + const size_t scratchBufferSize = ffxGetScratchMemorySize(FFX_FSR2_CONTEXT_COUNT); + void* scratchBuffer = calloc(scratchBufferSize, 1); + FfxErrorCode errorCode = + ffxGetInterface(&m_InitializationParameters.backendInterface, GetDevice(), scratchBuffer, scratchBufferSize, FFX_FSR2_CONTEXT_COUNT); + CauldronAssert(ASSERT_CRITICAL, errorCode == FFX_OK, L"Could not initialize the FidelityFX SDK backend"); + + // Create the FSR2 context + UpdateFSR2Context(true); + + // Set the jitter callback to use + CameraJitterCallback jitterCallback = [this](Vec2& values) { + // Increment jitter index for frame + ++m_JitterIndex; + + // Update FSR2 jitter for built in TAA + const ResolutionInfo& resInfo = GetFramework()->GetResolutionInfo(); + const int32_t jitterPhaseCount = ffxFsr2GetJitterPhaseCount(resInfo.RenderWidth, resInfo.DisplayWidth); + ffxFsr2GetJitterOffset(&m_JitterX, &m_JitterY, m_JitterIndex, jitterPhaseCount); + + values = Vec2(2.f * m_JitterX / resInfo.RenderWidth, 2.f * m_JitterY / resInfo.RenderHeight); + }; + CameraComponent::SetJitterCallbackFunc(jitterCallback); + + // ... and register UI elements for active upscaler + GetUIManager()->RegisterUIElements(m_UISection); + } + else + { + // Toggle this now so we avoid the context changes in OnResize + SetModuleEnabled(enabled); + + GetFramework()->EnableUpscaling(false); + + // Destroy the FSR2 context + UpdateFSR2Context(false); + + // Destroy the FidelityFX interface memory + free(m_InitializationParameters.backendInterface.scratchBuffer); + + // Deregister UI elements for inactive upscaler + GetUIManager()->UnRegisterUIElements(m_UISection); + } +} + +void FSR2RenderModule::InitUI() +{ + // Build UI options, but don't register them yet. Registration/Deregistration will be controlled by enabling/disabling the render module + m_UISection.SectionName = "Upscaling"; // We will piggy-back on existing upscaling section" + m_UISection.SectionType = UISectionType::Sample; + + // Setup scale preset options + const char* preset[] = {"Quality (1.5x)", "Balanced (1.7x)", "Performance (2x)", "Ultra Performance (3x)", "Custom"}; + std::vector presetComboOptions; + presetComboOptions.assign(preset, preset + _countof(preset)); + std::function presetCallback = [this](void* pParams) { this->UpdatePreset(static_cast(pParams)); }; + m_UISection.AddCombo("Scale Preset", reinterpret_cast(&m_ScalePreset), &presetComboOptions, presetCallback); + + // Setup scale factor (disabled for all but custom) + std::function ratioCallback = [this](void* pParams) { this->UpdateUpscaleRatio(static_cast(pParams)); }; + m_UISection.AddFloatSlider("Custom Scale", &m_UpscaleRatio, 1.f, 3.f, ratioCallback, &m_UpscaleRatioEnabled); + + // Sharpening + m_UISection.AddCheckBox("RCAS Sharpening", &m_RCASSharpen); + m_UISection.AddFloatSlider("Sharpness", &m_Sharpness, 0.f, 1.f, nullptr, &m_RCASSharpen); +} + +void FSR2RenderModule::UpdatePreset(const int32_t* pOldPreset) +{ + switch (m_ScalePreset) + { + case FSR2ScalePreset::Quality: + m_UpscaleRatio = 1.5f; + break; + case FSR2ScalePreset::Balanced: + m_UpscaleRatio = 1.7f; + break; + case FSR2ScalePreset::Performance: + m_UpscaleRatio = 2.0f; + break; + case FSR2ScalePreset::UltraPerformance: + m_UpscaleRatio = 3.0f; + break; + case FSR2ScalePreset::Custom: + default: + // Leave the upscale ratio at whatever it was + break; + } + + // Update whether we can update the custom scale slider + m_UpscaleRatioEnabled = (m_ScalePreset == FSR2ScalePreset::Custom); + + // Update resolution since rendering ratios have changed + GetFramework()->EnableUpscaling(true, m_pUpdateFunc); +} + +void FSR2RenderModule::UpdateUpscaleRatio(const float* pOldRatio) +{ + // Disable/Enable FSR2 since resolution ratios have changed + GetFramework()->EnableUpscaling(true, m_pUpdateFunc); +} + +void FSR2RenderModule::FfxMsgCallback(FfxMsgType type, const wchar_t* message) +{ + if (type == FFX_MESSAGE_TYPE_ERROR) + { + CauldronWarning(L"FSR2_API_DEBUG_ERROR: %ls", message); + } + else if (type == FFX_MESSAGE_TYPE_WARNING) + { + CauldronWarning(L"FSR2_API_DEBUG_WARNING: %ls", message); + } +} + +void FSR2RenderModule::UpdateFSR2Context(bool enabled) +{ + if (enabled) + { + const ResolutionInfo& resInfo = GetFramework()->GetResolutionInfo(); + m_InitializationParameters.maxRenderSize.width = resInfo.RenderWidth; + m_InitializationParameters.maxRenderSize.height = resInfo.RenderHeight; + m_InitializationParameters.displaySize.width = resInfo.DisplayWidth; + m_InitializationParameters.displaySize.height = resInfo.DisplayHeight; + + // Enable auto-exposure by default + m_InitializationParameters.flags = FFX_FSR2_ENABLE_AUTO_EXPOSURE; + + // Note, inverted depth and display mode are currently handled statically for the run of the sample. + // If they become changeable at runtime, we'll need to modify how this information is queried + static bool s_InvertedDepth = GetConfig()->InvertedDepth; + + // Setup inverted depth flag according to sample usage + if (s_InvertedDepth) + m_InitializationParameters.flags |= FFX_FSR2_ENABLE_DEPTH_INVERTED | FFX_FSR2_ENABLE_DEPTH_INFINITE; + + // Input data is HDR + m_InitializationParameters.flags |= FFX_FSR2_ENABLE_HIGH_DYNAMIC_RANGE; + + // Motion vectors include frame-to-frame jitter + m_InitializationParameters.flags |= FFX_FSR2_ENABLE_MOTION_VECTORS_JITTER_CANCELLATION; + +// Do eror checking in debug +#if defined(_DEBUG) + m_InitializationParameters.flags |= FFX_FSR2_ENABLE_DEBUG_CHECKING; + m_InitializationParameters.fpMessage = &FSR2RenderModule::FfxMsgCallback; +#endif // #if defined(_DEBUG) + + // Create the FSR2 context + FfxErrorCode errorCode = ffxFsr2ContextCreate(&m_FSR2Context, &m_InitializationParameters); + CauldronAssert(ASSERT_CRITICAL, errorCode == FFX_OK, L"Couldn't create the FidelityFX SDK FSR2 context."); + } + + else + { + // Destroy the FSR2 context + ffxFsr2ContextDestroy(&m_FSR2Context); + } +} + +ResolutionInfo FSR2RenderModule::UpdateResolution(uint32_t displayWidth, uint32_t displayHeight) +{ + return { + static_cast((float)displayWidth / m_UpscaleRatio), static_cast((float)displayHeight / m_UpscaleRatio), displayWidth, displayHeight}; +} + +void FSR2RenderModule::OnResize(const ResolutionInfo& resInfo) +{ + if (!ModuleEnabled()) + return; + + // Need to recreate the FSR2 context on resource resize + UpdateFSR2Context(false); // Destroy + UpdateFSR2Context(true); // Re-create + + // Rest jitter index + m_JitterIndex = 0; +} + +void FSR2RenderModule::Execute(double deltaTime, CommandList* pCmdList) +{ + GPUScopedProfileCapture sampleMarker(pCmdList, L"FFX FSR2"); + const ResolutionInfo& resInfo = GetFramework()->GetResolutionInfo(); + CameraComponent* pCamera = GetScene()->GetCurrentCamera(); + + // All cauldron resources come into a render module in a generic read state (ResourceState::NonPixelShaderResource | + // ResourceState::PixelShaderResource) + FfxFsr2DispatchDescription dispatchParameters = {}; + dispatchParameters.commandList = ffxGetCommandList(pCmdList); + dispatchParameters.color = ffxGetResource(m_pColorTarget->GetResource(), L"FSR2_Input_OutputColor", FFX_RESOURCE_STATE_PIXEL_COMPUTE_READ); + dispatchParameters.depth = ffxGetResource(m_pDepthTarget->GetResource(), L"FSR2_InputDepth", FFX_RESOURCE_STATE_PIXEL_COMPUTE_READ); + dispatchParameters.motionVectors = ffxGetResource(m_pMotionVectors->GetResource(), L"FSR2_InputMotionVectors", FFX_RESOURCE_STATE_PIXEL_COMPUTE_READ); + dispatchParameters.exposure = ffxGetResource(nullptr, L"FSR2_InputExposure", FFX_RESOURCE_STATE_PIXEL_COMPUTE_READ); + dispatchParameters.output = dispatchParameters.color; + + dispatchParameters.reactive = ffxGetResource(nullptr, L"FSR2_EmptyInputReactiveMap", FFX_RESOURCE_STATE_PIXEL_COMPUTE_READ); + dispatchParameters.transparencyAndComposition = ffxGetResource(nullptr, L"FSR2_EmptyTransparencyAndCompositionMap", FFX_RESOURCE_STATE_PIXEL_COMPUTE_READ); + + // Jitter is calculated earlier in the frame using a callback from the camera update + dispatchParameters.jitterOffset.x = m_JitterX; + dispatchParameters.jitterOffset.y = -m_JitterY; + dispatchParameters.motionVectorScale.x = resInfo.fRenderWidth() / 2.f; + dispatchParameters.motionVectorScale.y = -resInfo.fRenderHeight() / 2.f; + dispatchParameters.reset = false; + dispatchParameters.enableSharpening = m_RCASSharpen; + dispatchParameters.sharpness = m_Sharpness; + + // Cauldron keeps time in seconds, but FSR expects miliseconds + dispatchParameters.frameTimeDelta = static_cast(deltaTime * 1000.f); + + dispatchParameters.preExposure = GetScene()->GetSceneExposure(); + dispatchParameters.renderSize.width = resInfo.RenderWidth; + dispatchParameters.renderSize.height = resInfo.RenderHeight; + + // Note, inverted depth and display mode are currently handled statically for the run of the sample. + // If they become changeable at runtime, we'll need to modify how this information is queried + static bool s_InvertedDepth = GetConfig()->InvertedDepth; + + // Setup camera params as required + dispatchParameters.cameraFovAngleVertical = pCamera->GetFovY(); + if (s_InvertedDepth) + { + dispatchParameters.cameraFar = pCamera->GetNearPlane(); + dispatchParameters.cameraNear = FLT_MAX; + } + else + { + dispatchParameters.cameraFar = pCamera->GetFarPlane(); + dispatchParameters.cameraNear = pCamera->GetNearPlane(); + } + + FfxErrorCode errorCode = ffxFsr2ContextDispatch(&m_FSR2Context, &dispatchParameters); + FFX_ASSERT(errorCode == FFX_OK); + + // FidelityFX contexts modify the set resource view heaps, so set the cauldron one back + SetAllResourceViewHeaps(pCmdList); + + // We are now done with upscaling + GetFramework()->SetUpscalingState(UpscalerState::PostUpscale); +} diff --git a/meshNodeSample/fsr2rendermodule.h b/meshNodeSample/fsr2rendermodule.h new file mode 100644 index 0000000..585f992 --- /dev/null +++ b/meshNodeSample/fsr2rendermodule.h @@ -0,0 +1,125 @@ +// This file is part of the AMD Work Graph Mesh Node Sample. +// +// Copyright (c) 2024 Advanced Micro Devices, Inc. All rights reserved. +// +// 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 +// AUTHORS OR COPYRIGHT HOLDERS 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. + +#pragma once + +#include "render/rendermodule.h" +#include "core/framework.h" +#include "core/uimanager.h" + +#include + +#include + +namespace cauldron +{ + class Texture; +} // namespace cauldron + +/** + * FSR2RenderModule takes care of: + * - creating UI section that enable users to select upscaling options + * - creating GPU resources + * - clearing and/or generating the reactivity masks + * - dispatch workloads for upscaling using FSR 2 + */ +class FSR2RenderModule : public cauldron::RenderModule +{ +public: + /** + * @brief Constructor with default behavior. + */ + FSR2RenderModule() + : RenderModule(L"FSR2RenderModule") + { + } + + /** + * @brief Tear down the FSR 2 API Context and release resources. + */ + virtual ~FSR2RenderModule(); + + /** + * @brief Initialize FSR 2 API Context, create resources, and setup UI section for FSR 2. + */ + void Init(const json& initData); + + /** + * @brief If render module is enabled, initialize the FSR 2 API Context. If disabled, destroy the FSR 2 API Context. + */ + void EnableModule(bool enabled) override; + + /** + * @brief Setup parameters that the FSR 2 API needs this frame and then call the FFX Dispatch. + */ + void Execute(double deltaTime, cauldron::CommandList* pCmdList) override; + + /** + * @brief Recreate the FSR 2 API Context to resize internal resources. Called by the framework when the resolution changes. + */ + void OnResize(const cauldron::ResolutionInfo& resInfo) override; + +private: + // Enum representing the FSR 2 quality modes. + enum class FSR2ScalePreset + { + Quality = 0, // 1.5f + Balanced, // 1.7f + Performance, // 2.f + UltraPerformance, // 3.f + Custom // 1.f - 3.f range + }; + + static void FfxMsgCallback(FfxMsgType type, const wchar_t* message); + + void InitUI(); + void UpdatePreset(const int32_t* pOldPreset); + void UpdateUpscaleRatio(const float* pOldRatio); + + cauldron::ResolutionInfo UpdateResolution(uint32_t displayWidth, uint32_t displayHeight); + void UpdateFSR2Context(bool enabled); + + FSR2ScalePreset m_ScalePreset = FSR2ScalePreset::Custom; + float m_UpscaleRatio = 1.f; + float m_Sharpness = 0.8f; + uint32_t m_JitterIndex = 0; + float m_JitterX = 0.f; + float m_JitterY = 0.f; + + bool m_UpscaleRatioEnabled = false; + bool m_RCASSharpen = true; + + // FidelityFX Super Resolution 2 information + FfxFsr2ContextDescription m_InitializationParameters = {}; + FfxFsr2Context m_FSR2Context; + + // For UI params + cauldron::UISection m_UISection; + + // FidelityFX Super Resolution 2 resources + const cauldron::Texture* m_pColorTarget = nullptr; + const cauldron::Texture* m_pDepthTarget = nullptr; + const cauldron::Texture* m_pMotionVectors = nullptr; + + // For resolution updates + std::function m_pUpdateFunc = nullptr; + +}; diff --git a/meshNodeSample/main.cpp b/meshNodeSample/main.cpp new file mode 100644 index 0000000..4746a8d --- /dev/null +++ b/meshNodeSample/main.cpp @@ -0,0 +1,139 @@ +// This file is part of the AMD Work Graph Mesh Node Sample. +// +// Copyright (c) 2024 Advanced Micro Devices, Inc. All rights reserved. +// +// 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 +// AUTHORS OR COPYRIGHT HOLDERS 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. + +// Framework and Windows implementation +#include "core/framework.h" +#include "core/win/framework_win.h" + +// Config file parsing +#include "misc/fileio.h" + +// Custom camera component +#include "samplecameracomponent.h" + +// Content manager to fix texture load bug +#include "core/contentmanager.h" + +// Render Module Registry +#include "rendermoduleregistry.h" +// Render Modules +#include "fsr2rendermodule.h" +#include "workgraphrendermodule.h" + +// D3D12 header to enable experimental shader models +#include "d3d12.h" + +using namespace cauldron; + +class MeshNodeSample final : public Framework +{ +public: + MeshNodeSample(const FrameworkInitParams* pInitParams) + : Framework(pInitParams) + { + } + + ~MeshNodeSample() = default; + + // Overrides + void ParseSampleConfig() override + { + const auto configFileName = L"configs/meshnodesampleconfig.json"; + + json sampleConfig; + CauldronAssert(ASSERT_CRITICAL, ParseJsonFile(configFileName, sampleConfig), L"Could not parse JSON file %ls", configFileName); + + // Get the sample configuration + json configData = sampleConfig["Mesh Node Sample"]; + + // Let the framework parse all the "known" options for us + ParseConfigData(configData); + } + + void RegisterSampleModules() override + { + // Init all pre-registered render modules + rendermodule::RegisterAvailableRenderModules(); + + // Register sample render module + RenderModuleFactory::RegisterModule("WorkGraphRenderModule"); + // Register FSR 2 render module + RenderModuleFactory::RegisterModule("FSR2RenderModule"); + } + + int32_t PreRun() override + { + const auto status = Framework::PreRun(); + + // Init custom camera entity & component + Task createCameraTask(InitCameraEntity, nullptr); + GetTaskManager()->AddTask(createCameraTask); + + // Cauldron is missing its media folder, thus these textures are not available. + // Due to a bug, Cauldron will not shutdown if these textures are not loaded, + // thus we decrement the pending texture loads manually with three nullptr textures + Texture* texturePtr = nullptr; + GetContentManager()->StartManagingContent(L"SpecularIBL", texturePtr); + GetContentManager()->StartManagingContent(L"DiffuseIBL", texturePtr); + GetContentManager()->StartManagingContent(L"BrdfLut", texturePtr); + + return status; + } + + int32_t DoSampleInit() override + { + // Enable FSR 2 upscaling and AA + GetFramework()->GetRenderModule("FSR2RenderModule")->EnableModule(true); + + return 0; + } + + void DoSampleShutdown() override + { + // Shutdown (disable) FSR 2 render module + GetFramework()->GetRenderModule("FSR2RenderModule")->EnableModule(false); + } +}; + +static FrameworkInitParamsInternal s_WindowsParams; + +////////////////////////////////////////////////////////////////////////// +// WinMain +int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int nCmdShow) +{ + // Enable experimental D3D12 features for mesh nodes + std::array meshNodesExperimentalFeatures = {D3D12ExperimentalShaderModels, D3D12StateObjectsExperiment}; + CauldronThrowOnFail( + D3D12EnableExperimentalFeatures(static_cast(meshNodesExperimentalFeatures.size()), meshNodesExperimentalFeatures.data(), nullptr, nullptr)); + + // Create the sample and kick it off to the framework to run + FrameworkInitParams initParams = {}; + initParams.Name = L"Mesh Node Sample"; + initParams.CmdLine = lpCmdLine; + initParams.AdditionalParams = &s_WindowsParams; + + // Setup the windows info + s_WindowsParams.InstanceHandle = hInstance; + s_WindowsParams.CmdShow = nCmdShow; + + MeshNodeSample frameworkInstance(&initParams); + return RunFramework(&frameworkInstance); +} diff --git a/meshNodeSample/samplecameracomponent.cpp b/meshNodeSample/samplecameracomponent.cpp new file mode 100644 index 0000000..429ecc2 --- /dev/null +++ b/meshNodeSample/samplecameracomponent.cpp @@ -0,0 +1,180 @@ +// This file is part of the AMD Work Graph Mesh Node Sample. +// +// Copyright (c) 2024 Advanced Micro Devices, Inc. All rights reserved. +// +// 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 +// AUTHORS OR COPYRIGHT HOLDERS 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. + +#include "samplecameracomponent.h" + +#include "core/contentmanager.h" +#include "core/framework.h" +#include "core/inputmanager.h" +#include "core/scene.h" + +MeshNodeSampleCameraComponent::MeshNodeSampleCameraComponent(cauldron::Entity* pOwner, cauldron::ComponentData* pData, cauldron::CameraComponentMgr* pManager) + : CameraComponent(pOwner, pData, pManager) +{ + m_Speed = 50.f; + m_ArcBallMode = false; +} + +void MeshNodeSampleCameraComponent::Update(double deltaTime) +{ + using namespace cauldron; + + // Always update temporal information + m_PrevViewMatrix = m_ViewMatrix; + m_PrevViewProjectionMatrix = m_ViewProjectionMatrix; + m_PrevProjJittered = m_ProjJittered; + + // If this camera is the currently active camera for the scene, check for input + if (GetScene()->GetCurrentCamera() == this) + { + const InputState& inputState = GetInputManager()->GetInputState(); + + // Read in inputs + + // Scale speed with mouse wheel rotation + if (inputState.GetMouseAxisDelta(Mouse_Wheel)) + { + m_Speed = m_Speed * ((inputState.GetMouseAxisDelta(Mouse_Wheel) > 0) ? 1.5f : (1.f / 1.5f)); + // clamp speed + m_Speed = std::max(m_Speed, 1.f); + m_Speed = std::min(m_Speed, 200.f); + } + + // Use right game pad stick to pitch and yaw the camera + bool hasRotation = false; + if (inputState.GetGamePadAxisState(Pad_RightThumbX) || inputState.GetGamePadAxisState(Pad_RightThumbY)) + { + // All rotations (per frame) are of 0.005 radians + m_Yaw -= inputState.GetGamePadAxisState(Pad_RightThumbX) / 200.f; + m_Pitch += inputState.GetGamePadAxisState(Pad_RightThumbY) / 200.f; + hasRotation = true; + } + + // Left click + mouse move == free cam look & WASDEQ movement (+ mouse wheel in/out) + else if (inputState.GetMouseButtonState(Mouse_LButton)) + { + // All rotations (per frame) are of 0.002 radians + m_Yaw -= inputState.GetMouseAxisDelta(Mouse_XAxis) / 500.f; + m_Pitch += inputState.GetMouseAxisDelta(Mouse_YAxis) / 500.f; + hasRotation = true; + } + + // If hitting the 'r' key or back button on game pad, reset camera to original transform + if (inputState.GetKeyState(Key_R) || inputState.GetGamePadButtonState(Pad_Back)) + { + ResetCamera(); + UpdateMatrices(); + return; + } + + Vec4 eyePos = Vec4(m_InvViewMatrix.getTranslation(), 0.f); + Vec4 polarVector = PolarToVector(m_Yaw, m_Pitch); + + // WASDQE == camera translation + float x(0.f), y(0.f), z(0.f); + x -= (inputState.GetKeyState(Key_A)) ? 1.f : 0.f; + x += (inputState.GetKeyState(Key_D)) ? 1.f : 0.f; + y -= (inputState.GetKeyState(Key_Q)) ? 1.f : 0.f; + y += (inputState.GetKeyState(Key_E)) ? 1.f : 0.f; + z -= (inputState.GetKeyState(Key_W)) ? 1.f : 0.f; + z += (inputState.GetKeyState(Key_S)) ? 1.f : 0.f; + + // Controller input can also translate + x += inputState.GetGamePadAxisState(Pad_LeftThumbX); + z -= inputState.GetGamePadAxisState(Pad_LeftThumbY); + y -= inputState.GetGamePadAxisState(Pad_LTrigger); + y += inputState.GetGamePadAxisState(Pad_RTrigger); + Vec4 movement = Vec4(x, y, z, 0.f); + + Mat4& transform = m_pOwner->GetTransform(); + + // Update from inputs + if (hasRotation || dot(movement.getXYZ(), movement.getXYZ())) + { + // Setup new eye position + eyePos = + m_InvViewMatrix.getCol3() + (m_InvViewMatrix * movement * m_Speed * static_cast(deltaTime)); // InvViewMatrix is the owner's transform + } + + // Limit maximum camera height + eyePos[1] = std::min(eyePos[1], 400.f); + + // Update camera jitter if we need it + if (CameraComponent::s_pSetJitterCallback) + { + s_pSetJitterCallback(m_jitterValues); + m_Dirty = true; + } + else + { + // Reset jitter if disabled + if (m_jitterValues.getX() != 0.f || m_jitterValues.getY() != 0.f) + { + m_jitterValues = Vec2(0.f, 0.f); + m_Dirty = true; + } + } + + LookAt(eyePos, eyePos - 10 * polarVector); + UpdateMatrices(); + } +} + +void InitCameraEntity(void*) +{ + using namespace cauldron; + + ContentBlock* pContentBlock = new ContentBlock(); + + // Memory backing camera creation + EntityDataBlock* pCameraDataBlock = new EntityDataBlock(); + pContentBlock->EntityDataBlocks.push_back(pCameraDataBlock); + pCameraDataBlock->pEntity = new Entity(L"MeshNodeDemoCamera"); + CauldronAssert(ASSERT_CRITICAL, pCameraDataBlock->pEntity, L"Could not allocate default perspective camera entity"); + + // Use the same matrix setup as Cauldron 1.4 (note that Cauldron kept view-matrix native transforms, and our + // entity needs the inverse of that) + Mat4 transform = LookAtMatrix(Vec4(120.65f, 24.44f, -15.74f, 0.f), // eye position + Vec4(120.45f, 24.44f, -14.74f, 0.f), // look-at position + Vec4(0.f, 1.f, 0.f, 0.f)); // up + transform = InverseMatrix(transform); + pCameraDataBlock->pEntity->SetTransform(transform); + + // Setup default camera parameters + CameraComponentData defaultPerspCameraCompData; + defaultPerspCameraCompData.Name = L"MeshNodeDemoCamera"; + defaultPerspCameraCompData.Perspective.AspectRatio = GetFramework()->GetAspectRatio(); + defaultPerspCameraCompData.Perspective.Yfov = CAULDRON_PI2 / defaultPerspCameraCompData.Perspective.AspectRatio; + defaultPerspCameraCompData.Znear = 0.5f; + defaultPerspCameraCompData.Zfar = 2000.f; + + CameraComponentData* pCameraComponentData = new CameraComponentData(defaultPerspCameraCompData); + pCameraDataBlock->ComponentsData.push_back(pCameraComponentData); + MeshNodeSampleCameraComponent* pCameraComponent = + new MeshNodeSampleCameraComponent(pCameraDataBlock->pEntity, pCameraComponentData, CameraComponentMgr::Get()); + pCameraDataBlock->pEntity->AddComponent(pCameraComponent); + + pCameraDataBlock->Components.push_back(pCameraComponent); + + pContentBlock->ActiveCamera = pCameraDataBlock->pEntity; + + GetContentManager()->StartManagingContent(L"MeshNodeDemoCameraEntities", pContentBlock, false); +} diff --git a/meshNodeSample/samplecameracomponent.h b/meshNodeSample/samplecameracomponent.h new file mode 100644 index 0000000..8ab90db --- /dev/null +++ b/meshNodeSample/samplecameracomponent.h @@ -0,0 +1,34 @@ +// This file is part of the AMD Work Graph Mesh Node Sample. +// +// Copyright (c) 2024 Advanced Micro Devices, Inc. All rights reserved. +// +// 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 +// AUTHORS OR COPYRIGHT HOLDERS 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. + +#pragma once + +#include "core/components/cameracomponent.h" + +class MeshNodeSampleCameraComponent : public cauldron::CameraComponent +{ +public: + MeshNodeSampleCameraComponent(cauldron::Entity* pOwner, cauldron::ComponentData* pData, cauldron::CameraComponentMgr* pManager); + + void Update(double deltaTime) override; +}; + +void InitCameraEntity(void*); \ No newline at end of file diff --git a/meshNodeSample/shadercompiler.cpp b/meshNodeSample/shadercompiler.cpp new file mode 100644 index 0000000..08e369b --- /dev/null +++ b/meshNodeSample/shadercompiler.cpp @@ -0,0 +1,165 @@ +// This file is part of the AMD Work Graph Mesh Node Sample. +// +// Copyright (c) 2024 Advanced Micro Devices, Inc. All rights reserved. +// +// 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 +// AUTHORS OR COPYRIGHT HOLDERS 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. + +#include "shadercompiler.h" + +#include "misc/assert.h" + +#define _SILENCE_EXPERIMENTAL_FILESYSTEM_DEPRECATION_WARNING // To avoid receiving deprecation error since we are using \ + // C++11 only +#include +using namespace std::experimental; + +template +inline void SafeRelease(Interface*& pInterfaceToRelease) +{ + if (pInterfaceToRelease != nullptr) + { + pInterfaceToRelease->Release(); + + pInterfaceToRelease = nullptr; + } +} + +ShaderCompiler::ShaderCompiler() +{ + HMODULE dxilModule = LoadLibraryW(L"dxil.dll"); + HMODULE dxcompilerModule = LoadLibraryW(L"dxcompiler.dll"); + + cauldron::CauldronAssert(cauldron::ASSERT_CRITICAL, dxcompilerModule, L"Failed to load dxcompiler.dll"); + + DxcCreateInstanceProc pfnDxcCreateInstance = DxcCreateInstanceProc(GetProcAddress(dxcompilerModule, "DxcCreateInstance")); + + cauldron::CauldronAssert(cauldron::ASSERT_CRITICAL, pfnDxcCreateInstance, L"Failed to load DxcCreateInstance from dxcompiler.dll"); + + if (FAILED(pfnDxcCreateInstance(CLSID_DxcUtils, IID_PPV_ARGS(&m_pUtils)))) + { + cauldron::CauldronCritical(L"Failed to create DXC utils"); + } + + if (FAILED(pfnDxcCreateInstance(CLSID_DxcCompiler, IID_PPV_ARGS(&m_pCompiler)))) + { + // delete utils if compiler creation fails + SafeRelease(m_pUtils); + + cauldron::CauldronCritical(L"Failed to create DXC compiler"); + } + + if (FAILED(m_pUtils->CreateDefaultIncludeHandler(&m_pIncludeHandler))) + { + // delete utils & compiler if include handler creation fails + SafeRelease(m_pCompiler); + SafeRelease(m_pUtils); + + cauldron::CauldronCritical(L"Failed to create DXC compiler"); + } +} + +ShaderCompiler::~ShaderCompiler() +{ + SafeRelease(m_pIncludeHandler); + SafeRelease(m_pCompiler); + SafeRelease(m_pUtils); +} + +IDxcBlob* ShaderCompiler::CompileShader(const wchar_t* shaderFilePath, const wchar_t* target, const wchar_t* entryPoint) +{ + IDxcBlobEncoding* source = nullptr; + + const auto shaderSourceFilePath = std::wstring(L"Shaders\\") + shaderFilePath; + + if (FAILED(m_pUtils->LoadFile(shaderSourceFilePath.c_str(), nullptr, &source)) || (source == nullptr)) + { + cauldron::CauldronCritical(L"Failed to load %s", shaderFilePath); + } + + const auto shadersFolderPath = filesystem::current_path() / L"shaders"; + const auto shaderIncludeArgument = std::wstring(L"-I") + shadersFolderPath.wstring(); + + std::vector arguments = { + L"-enable-16bit-types", + // use HLSL 2021 + L"-HV", + L"2021", + // column major matrices + DXC_ARG_PACK_MATRIX_COLUMN_MAJOR, + // include path for "shaders" folder + shaderIncludeArgument.c_str(), + }; + + IDxcOperationResult* result = nullptr; + const auto hr = m_pCompiler->Compile( + source, shaderFilePath, entryPoint, target, arguments.data(), static_cast(arguments.size()), nullptr, 0, m_pIncludeHandler, &result); + + // release source blob + SafeRelease(source); + + if (FAILED(hr)) + { + SafeRelease(result); + + cauldron::CauldronCritical(L"Failed to compile shader %s", shaderFilePath); + } + + HRESULT compileStatus; + if (FAILED(result->GetStatus(&compileStatus))) + { + SafeRelease(result); + + cauldron::CauldronCritical(L"Failed to get compilation status for shader %s", shaderFilePath); + } + + std::wstring errorString = L""; + + // try get error string from DXC result + { + IDxcBlobEncoding* errorStringBlob = nullptr; + if (SUCCEEDED(result->GetErrorBuffer(&errorStringBlob)) && (errorStringBlob != nullptr)) + { + IDxcBlobWide* errorStringBlob16 = nullptr; + m_pUtils->GetBlobAsUtf16(errorStringBlob, &errorStringBlob16); + + errorString = std::wstring(errorStringBlob16->GetStringPointer(), errorStringBlob16->GetStringLength()); + + SafeRelease(errorStringBlob16); + } + SafeRelease(errorStringBlob); + } + + if (FAILED(compileStatus)) + { + SafeRelease(result); + + cauldron::CauldronCritical(L"Failed to compile shader %s\n%s", shaderFilePath, errorString.c_str()); + } + + IDxcBlob* outputBlob = nullptr; + if (FAILED(result->GetResult(&outputBlob))) + { + SafeRelease(result); + + cauldron::CauldronCritical(L"Failed to get binary shader blob for shader %s", shaderFilePath); + } + + SafeRelease(result); + + return outputBlob; +} \ No newline at end of file diff --git a/meshNodeSample/shadercompiler.h b/meshNodeSample/shadercompiler.h new file mode 100644 index 0000000..11dd403 --- /dev/null +++ b/meshNodeSample/shadercompiler.h @@ -0,0 +1,45 @@ +// This file is part of the AMD Work Graph Mesh Node Sample. +// +// Copyright (c) 2024 Advanced Micro Devices, Inc. All rights reserved. +// +// 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 +// AUTHORS OR COPYRIGHT HOLDERS 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. + +#pragma once + +// windows headers +#define WIN32_LEAN_AND_MEAN +#include +// for BSTR typedef +#include + +// DXC header +#include + +class ShaderCompiler +{ +public: + ShaderCompiler(); + ~ShaderCompiler(); + + IDxcBlob* CompileShader(const wchar_t* shaderFilePath, const wchar_t* target, const wchar_t* entryPoint); + +private: + IDxcUtils* m_pUtils = nullptr; + IDxcCompiler* m_pCompiler = nullptr; + IDxcIncludeHandler* m_pIncludeHandler = nullptr; +}; \ No newline at end of file diff --git a/meshNodeSample/shaders/beemeshshader.hlsl b/meshNodeSample/shaders/beemeshshader.hlsl new file mode 100644 index 0000000..c729d55 --- /dev/null +++ b/meshNodeSample/shaders/beemeshshader.hlsl @@ -0,0 +1,215 @@ +// This file is part of the AMD Work Graph Mesh Node Sample. +// +// Copyright (c) 2024 Advanced Micro Devices, Inc. All rights reserved. +// +// 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 +// AUTHORS OR COPYRIGHT HOLDERS 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. + +#include "common.hlsl" + +// Static "vertex buffer" for bees +static const int numBeeVertices = 11; +static const float3 beePositions[numBeeVertices] = { + float3(0.84, 0.0, -0.0), + float3(-1.0, 0.0, -0.0), + float3(-0.083, 0.722, -0.682), + float3(-0.083, 0.722, 0.682), + float3(1.063, 0.361, -0.275), + float3(1.063, 0.361, 0.275), + float3(0.353, 0.6, 0.0), + float3(-0.283, 1.283, 1.415), + float3(0.753, 1.228, 1.865), + float3(-0.283, 1.283, -1.415), + float3(0.753, 1.228, -1.865), +}; +// Static vertex color attributes +static const float3 beeColors[numBeeVertices] = { + float3(0.72, 0.56, 0.032), + float3(0, 0, 0), + float3(0.72, 0.56, 0.032), + float3(0.72, 0.56, 0.032), + float3(0, 0, 0), + float3(0, 0, 0), + + float3(0.85, 0.85, 0.85), + float3(0.85, 0.85, 0.85), + float3(0.85, 0.85, 0.85), + float3(0.85, 0.85, 0.85), + float3(0.85, 0.85, 0.85), +}; + +// Static "index buffer" for bees +static const int numBeeTriangles = 10; +static const uint3 beeTriangles[numBeeTriangles] = { + uint3(1, 3, 2), + uint3(4, 5, 0), + uint3(9, 6, 10), + uint3(2, 5, 4), + uint3(7, 6, 8), + uint3(5, 3, 0), + uint3(3, 1, 0), + uint3(4, 0, 2), + uint3(2, 0, 1), + uint3(3, 5, 2), +}; + +float3 GetInsectPosition(float time) +{ + return 1.2 * float3(PerlinNoise2D(float2(time * 0.001, 0)), + PerlinNoise2D(float2(time * 0.001, 5)), + PerlinNoise2D(float2(time * 0.001, 9))); +} + +static const int beeGroupSize = 128; + +// customizable bee limit +static const int maxNumBees = min(32, min(256 / numBeeVertices, 192 / numBeeTriangles)); +static const int numOutputVertices = maxNumBees * numBeeVertices; +static const int numOutputTriangles = maxNumBees * numBeeTriangles; + +static const int numOutputVertexIterations = (numOutputVertices + (beeGroupSize - 1)) / beeGroupSize; +static const int numOutputTriangleIterations = (numOutputTriangles + (beeGroupSize - 1)) / beeGroupSize; + +[Shader("node")] +[NodeLaunch("mesh")] +[NodeId("DrawBees", 0)] +[NodeMaxDispatchGrid(maxInsectsPerRecord, 1, 1)] +// This limit was set through instrumentation and is not required on AMD GPUs. +// If you wish to change any of the procedural generation parameters, +// and you are running on a non-AMD GPU, you may need to adjust this limit. +// You can learn more at: +// https://gpuopen.com/learn/work_graphs_mesh_nodes/work_graphs_mesh_nodes-tips_tricks_best_practices +[NodeMaxInputRecordsPerGraphEntryRecord(20, true)] +[NumThreads(beeGroupSize, 1, 1)] +[OutputTopology("triangle")] +void BeeMeshShader( + uint gtid : SV_GroupThreadID, + uint gid : SV_GroupID, + DispatchNodeInputRecord inputRecord, + out indices uint3 tris[numOutputTriangles], + out vertices InsectVertex verts[numOutputVertices]) +{ + const int numBees = maxNumBees; + const int vertexCount = numBees * numBeeVertices; + const int triangleCount = numBees * numBeeTriangles; + + SetMeshOutputCounts(vertexCount, triangleCount); + + const float3 patchCenter = inputRecord.Get().position[gid]; + const int seed = CombineSeed(asuint(patchCenter.x), asuint(patchCenter.z)); + + [[unroll]] + for (int i = 0; i < numOutputTriangleIterations; ++i) + { + const int triId = gtid + beeGroupSize * i; + + if (triId < triangleCount) { + const int insectId = triId / numBeeTriangles; + const int insectTriangleId = triId % numBeeTriangles; + + tris[triId] = beeTriangles[insectTriangleId] + insectId * numBeeVertices; + } + } + + [[unroll]] + for (int i = 0; i < numOutputVertexIterations; ++i) + { + const int vertId = gtid + beeGroupSize * i; + + if (vertId < vertexCount) { + const int insectId = vertId / numBeeVertices; + const int insectVertexId = vertId % numBeeVertices; + + // start time before night start + const float nightStart = nightStartTime - Random(seed, 7843); + // end time after night end + const float nightEnd = nightEndTime + Random(seed, 732); + + // scale insects to 0 at night + const float nightScale = max(smoothstep(nightStart - 1, nightStart, GetTimeOfDay()), + 1 - smoothstep(nightEnd, nightEnd + 1, GetTimeOfDay())); + // slowly scale insects to 0 in the distance + // for simplicity, we omit this scaling from the motion vector, as it only affects very distant insects + const float distanceScale = + smoothstep(beeFadeStartDistance, beeMaxDistance, distance(patchCenter, GetCameraPosition())); + + const float scale = (.01 + 0.03 * Random(seed, insectId, 8)) * (1 - nightScale) * (1 - distanceScale); + + // radius scale for positioning insects + static const float R = 0.2; + const float angle = 2 * PI * Random(seed, insectId, 8); + const float radius = sqrt(R * Random(seed, insectId, 98)); + + // compute random position offset for insect + // insects will rotate around this position + const float3 insectBasePosition = + float3(radius * cos(angle), 0.75 + 0.5 * Random(seed, insectId, 988), radius * sin(angle)); + + const float timeOffset = 1e6 * Random(seed, insectId, 55); + const float time = GetTime() + timeOffset; + const float timePrev = GetPreviousTime() + timeOffset; + + // compute local insect position offsets + const float3 insectPositionOffset = GetInsectPosition(time); + const float3 insectPositionOffsetDelta = GetInsectPosition(time - 10); + const float3 prevInsectPositionOffset = GetInsectPosition(timePrev); + const float3 prevInsectPositionOffsetDelta = GetInsectPosition(timePrev - 10); + + const float3 insectPosition = insectBasePosition + insectPositionOffset; + const float3 prevInsectPosition = insectBasePosition + prevInsectPositionOffset; + + // compute forward vectors for rotating insects to face movement direction + const float2 forward = normalize(insectPositionOffset.xz - insectPositionOffsetDelta.xz); + const float2 prevForward = normalize(prevInsectPositionOffset.xz - prevInsectPositionOffsetDelta.xz); + + float3 vertexPosition = beePositions[insectVertexId] * scale; + float3 prevVertexPosition = vertexPosition; + + // rotate wing vertices around insect center + if (insectVertexId > 6) { + // compute wing animation angle + static const float wingDownAngle = -0.15; + static const float wingAmplitude = 0.4; + const float phase = wingDownAngle + wingAmplitude * cos(2 * PI * frac(time * 0.005)); + const float phasePrev = wingDownAngle + wingAmplitude * cos(2 * PI * frac(timePrev * 0.005)); + + // insect center for rotating wings + static const float3 rotatePoint = beePositions[6] * scale; + + float wingAngle = sign(vertexPosition.z) * phase; + float prevWingAngle = sign(vertexPosition.z) * phasePrev; + vertexPosition.yz = RotateAroundPoint2d(vertexPosition.yz, wingAngle, rotatePoint.yz); + prevVertexPosition.yz = RotateAroundPoint2d(prevVertexPosition.yz, prevWingAngle, rotatePoint.yz); + } + // rotate insect towards movement direction + vertexPosition.xz = float2(vertexPosition.x * forward.x - vertexPosition.z * forward.y, + vertexPosition.x * forward.y + vertexPosition.z * forward.x); + prevVertexPosition.xz = float2(prevVertexPosition.x * prevForward.x - prevVertexPosition.z * prevForward.y, + prevVertexPosition.x * prevForward.y + prevVertexPosition.z * prevForward.x); + + InsectVertex vertex; + vertex.objectSpacePosition = insectPosition + vertexPosition; + vertex.color = beeColors[insectVertexId]; + + ComputeClipSpacePositionAndMotion(vertex, + patchCenter + vertex.objectSpacePosition, + patchCenter + prevInsectPosition + prevVertexPosition); + + verts[vertId] = vertex; + } + } +} \ No newline at end of file diff --git a/meshNodeSample/shaders/biomes.hlsl b/meshNodeSample/shaders/biomes.hlsl new file mode 100644 index 0000000..94f0216 --- /dev/null +++ b/meshNodeSample/shaders/biomes.hlsl @@ -0,0 +1,630 @@ +// This file is part of the AMD Work Graph Mesh Node Sample. +// +// Copyright (c) 2024 Advanced Micro Devices, Inc. All rights reserved. +// +// 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 +// AUTHORS OR COPYRIGHT HOLDERS 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. + +#include "common.hlsl" + +// Groupshared counters for group output records +groupshared uint denseGrassPatchCount; +groupshared uint sparseGrassPatchCount; +groupshared uint mushroomPatchCount; +groupshared uint butterflyPatchCount; +groupshared uint flowerPatchCount; +groupshared uint beePatchCount; + +// Groupshared terrain gradient estimate +groupshared int terrainGradient; + +[Shader("node")] +[NodeId("Tile", 0)] +[NodeLaunch("broadcasting")] +[NodeDispatchGrid(1, 1, 1)] +// each thread corresponds to one detailed tile +[NumThreads(detailedTilesPerTile, detailedTilesPerTile, 1)] +void MountainTile( + DispatchNodeInputRecord inputRecord, + + int2 groupThreadId : SV_GroupThreadID, + + [MaxRecords(detailedTilesPerTile * detailedTilesPerTile)] + [NodeId("GenerateRock")] + NodeOutput rockOutput, + + [MaxRecords(detailedTilesPerTile * detailedTilesPerTile)] + [NodeId("GenerateTree", 1)] + NodeOutput treeOutput) +{ + // clear groupshared counters + terrainGradient = 0; + + GroupMemoryBarrierWithGroupSync(); + + const int linearGroupThreadId = groupThreadId.x + groupThreadId.y * 8; + + const TileRecord input = inputRecord.Get(); + const int2 tileGridPosition = input.position; + const float2 tileWorldPosition = tileGridPosition * tileSize; + const float3 tileCenterWorldPosition = GetTerrainPosition(tileWorldPosition + tileSize * 0.5); + + const int2 threadGridPosition = tileGridPosition * detailedTilesPerTile + groupThreadId; + const float2 threadWorldPosition = threadGridPosition * detailedTileSize; + const float3 threadCenterWorldPosition = GetTerrainPosition(threadWorldPosition + detailedTileSize * 0.5); + + // Gradient estimation + if (any(groupThreadId == 0) || any(groupThreadId == (detailedTilesPerTile - 1))) + { + const float3 towardsCenter = tileCenterWorldPosition - threadCenterWorldPosition; + + InterlockedAdd(terrainGradient, int(towardsCenter.y * 10.f)); + } + + GroupMemoryBarrierWithGroupSync(); + + // Tree cluster output + { + const uint seed = CombineSeed(asuint(tileGridPosition.x), asuint(tileGridPosition.y)); + + const bool hasTreeCluster = (terrainGradient < 0) && (Random(seed, 97834) > 0.55); + const uint treeCount = hasTreeCluster * round(lerp(5, 10, Random(seed, 5614))); + + const bool hasThreadTreeOutput = linearGroupThreadId < treeCount; + + ThreadNodeOutputRecords treeOutputRecord = + treeOutput.GetThreadNodeOutputRecords(hasThreadTreeOutput); + + if (hasThreadTreeOutput) { + const float angle = linearGroupThreadId * (1.5f + Random(seed, 8437)); + const float radius = linearGroupThreadId * (1.f + Random(seed, 4742)); + const float2 offset = float2(sin(angle), cos(angle)) * radius; + + treeOutputRecord.Get().position = tileCenterWorldPosition.xz + offset; + } + + treeOutputRecord.OutputComplete(); + } + + // Rock output + { + const uint seed = CombineSeed(asuint(threadGridPosition.x), asuint(threadGridPosition.y)); + + const float3 biomeWeight = GetBiomeWeights(threadWorldPosition); + const float3 terrainNormal = GetTerrainNormal(threadWorldPosition); + + const bool hasRockOutput = + (abs(terrainGradient) < 500) && (Random(seed, 7982) > 0.75) && (terrainNormal.y > 0.65); + + ThreadNodeOutputRecords rockOutputRecord = + rockOutput.GetThreadNodeOutputRecords(hasRockOutput); + + if (hasRockOutput) { + rockOutputRecord.Get().position = threadCenterWorldPosition.xz; + } + + rockOutputRecord.OutputComplete(); + } +} + +bool HasTree(in int2 detailedTileGridPosition, out int outTreeType, out float2 outTreePosition) +{ + outTreeType = -1; + // Set position to +inf + outTreePosition = 1.f / 0.f; + + const float2 detailedTileWorldPosition = detailedTileGridPosition * detailedTileSize; + + const uint seed = CombineSeed(asuint(detailedTileGridPosition.x), asuint(detailedTileGridPosition.y)); + + const float3 biomeWeight = GetBiomeWeights(detailedTileWorldPosition); + + // check if woodlands is the dominant biome + if ((biomeWeight.y < biomeWeight.x) || (biomeWeight.y < biomeWeight.z)) { + return false; + } + + const float3 terrainNormal = GetTerrainNormal(detailedTileWorldPosition); + + const float2 randomOffset = float2(Random(seed, 82347), Random(seed, 9780)); + + outTreeType = ((biomeWeight.x > 0.4) || (terrainNormal.y < 0.85)) ? 1 : 0; + outTreePosition = detailedTileWorldPosition + randomOffset * detailedTileSize; + + return (Random(seed, 7982) > 0.1) && // Randomly limit tree occurance + (Random(seed, 28937) < biomeWeight.y) && // Only place trees in woodland biome + (terrainNormal.y > 0.65); // Don't place trees on very steep slopes +} + +[Shader("node")] +[NodeId("Tile", 1)] +[NodeLaunch("broadcasting")] +[NodeDispatchGrid(1, 1, 1)] +// each thread corresponds to one detailed tile +[NumThreads(detailedTilesPerTile, detailedTilesPerTile, 1)] +void WoodlandTile( + DispatchNodeInputRecord inputRecord, + + int2 groupThreadId : SV_GroupThreadID, + + [MaxRecords(detailedTilesPerTile * detailedTilesPerTile)] + [NodeId("DetailedTile")] + NodeOutput detailedTileOutput, + + [MaxRecords(detailedTilesPerTile * detailedTilesPerTile)] + [NodeId("GenerateTree")] + [NodeArraySize(2)] + NodeOutputArray treeOutput, + + [MaxRecords(1)] + [NodeId("DrawMushroomPatch")] + NodeOutput mushroomOutput, + + [MaxRecords(1)] + [NodeId("DrawSparseGrassPatch")] + NodeOutput sparseGrassOutput) +{ + // clear groupshared counters + sparseGrassPatchCount = 0; + mushroomPatchCount = 0; + butterflyPatchCount = 0; + + GroupMemoryBarrierWithGroupSync(); + + const TileRecord input = inputRecord.Get(); + const int2 tileGridPosition = input.position; + const float2 tileWorldPosition = tileGridPosition * tileSize; + + const int2 threadGridPosition = tileGridPosition * detailedTilesPerTile + groupThreadId; + const float2 threadWorldPosition = threadGridPosition * detailedTileSize; + const float3 threadCenterWorldPosition = GetTerrainPosition(threadWorldPosition + detailedTileSize * 0.5); + const float3 threadCenterCurvedWorldPosition = GetCurvedWorldSpacePosition(threadCenterWorldPosition); + const float centerDistanceToCamera = distance(GetCameraPosition(), threadCenterWorldPosition); + + const AxisAlignedBoundingBox threadBoundingBox = + GetGridBoundingBox(threadGridPosition, detailedTileSize, -100, 300); + const bool isThreadVisible = threadBoundingBox.IsVisible(ComputeClipPlanes()); + + const uint seed = CombineSeed(asuint(threadGridPosition.x), asuint(threadGridPosition.y)); + + // sparse grass + { + + bool hasOutput = true; + + // --- frustum cull --- + float radius = sqrt(grassPatchesPerDetailedTile * grassPatchesPerDetailedTile) * grassSpacing; + if (!IsSphereVisible(threadCenterCurvedWorldPosition, radius, ComputeClipPlanes())) { + hasOutput = false; + } + + // --- distance cull --- + if (((centerDistanceToCamera + radius) < denseGrassMaxDistance) || + ((centerDistanceToCamera + radius) > sparseGrassMaxDistance)) + { + hasOutput = false; + } + + int outputIndex = 0; + + if (hasOutput) { + InterlockedAdd(sparseGrassPatchCount, 1, outputIndex); + } + + GroupMemoryBarrierWithGroupSync(); + + GroupNodeOutputRecords sparseGrassRecord = + sparseGrassOutput.GetGroupNodeOutputRecords(sparseGrassPatchCount > 0); + + if (all(groupThreadId == 0) && sparseGrassPatchCount > 0) { + sparseGrassRecord.Get().dispatchGrid = uint3(sparseGrassPatchCount, sparseGrassThreadGroupsPerRecord, 1); + } + + if (hasOutput) { + // XZ-position + sparseGrassRecord.Get().position[outputIndex] = threadGridPosition; + } + + sparseGrassRecord.OutputComplete(); + } + + // tree output + { + int treeType; + float2 treePosition; + const bool hasTreeOutput = HasTree(threadGridPosition, treeType, treePosition); + + ThreadNodeOutputRecords treeOutputRecord = + treeOutput[treeType].GetThreadNodeOutputRecords(hasTreeOutput); + + if (hasTreeOutput) { + treeOutputRecord.Get().position = treePosition; + } + + treeOutputRecord.OutputComplete(); + + // Place mushrooms under each tree + const bool hasMushroomOutput = + hasTreeOutput && (centerDistanceToCamera < (mushroomMaxDistance * 1.5 + (detailedTileSize * 2))); + // Select random number of mushrooms to generate + const int mushroomOutputCount = + hasMushroomOutput * round(lerp(1, maxMushroomsPerDetailedTile, Random(seed, 67823))); + + // Synchronize mushroom output counts across thread group + int mushroomOutputIndex = 0; + if (mushroomOutputCount > 0) { + InterlockedAdd(mushroomPatchCount, mushroomOutputCount, mushroomOutputIndex); + } + + GroupMemoryBarrierWithGroupSync(); + + GroupNodeOutputRecords mushroomRecord = + mushroomOutput.GetGroupNodeOutputRecords(mushroomPatchCount > 0); + + if (all(groupThreadId == 0) && mushroomPatchCount > 0) { + mushroomRecord.Get().dispatchGrid = uint3(mushroomPatchCount, 1, 1); + } + + for (int mushroomIndex = 0; mushroomIndex < mushroomOutputCount; ++mushroomIndex) { + const float mushroomAngleRange = PI / 2; + const float mushroomOffsetAngle = + (-mushroomAngleRange / 2.f) + + (mushroomIndex * (mushroomAngleRange / mushroomOutputCount)) + + (Random(seed, mushroomIndex, 23456) - 1.f) * (mushroomAngleRange / mushroomOutputCount); + const float mushroomOffsetRadius = 0.75f + Random(seed, mushroomIndex, 89237) * 0.5f; + const float2 mushroomOffset = + float2(cos(mushroomOffsetAngle), sin(mushroomOffsetAngle)) * mushroomOffsetRadius; + + mushroomRecord.Get().position[mushroomOutputIndex + mushroomIndex] = + GetTerrainPosition(treePosition + mushroomOffset); + } + + mushroomRecord.OutputComplete(); + } + + // detailed tile output + { + const bool hasDetailedTileOutput = + isThreadVisible && (centerDistanceToCamera < (denseGrassMaxDistance + (detailedTileSize * 2))); + + ThreadNodeOutputRecords detailedTileOutputRecord = + detailedTileOutput.GetThreadNodeOutputRecords(hasDetailedTileOutput); + + if (hasDetailedTileOutput) { + detailedTileOutputRecord.Get().position = tileGridPosition * detailedTilesPerTile + groupThreadId; + } + + detailedTileOutputRecord.OutputComplete(); + } +} + +[Shader("node")] +[NodeId("Tile", 2)] +[NodeLaunch("broadcasting")] +[NodeDispatchGrid(1, 1, 1)] +// each thread corresponds to one detailed tile +[NumThreads(detailedTilesPerTile, detailedTilesPerTile, 1)] +void GrasslandTile( + DispatchNodeInputRecord inputRecord, + + int2 groupThreadId : SV_GroupThreadID, + + [MaxRecords(detailedTilesPerTile * detailedTilesPerTile)] + [NodeId("DetailedTile")] + NodeOutput detailedTileOutput, + + [MaxRecords(1)] + [NodeId("DrawButterflies")] + NodeOutput butterflyOutput, + + [MaxRecords(1)] + [NodeArraySize(2)] + [NodeId("DrawFlowerPatch")] + NodeOutputArray flowerOutput, + + [MaxRecords(1)] + [NodeId("DrawBees")] + NodeOutput beeOutput, + + [MaxRecords(1)] + [NodeId("DrawSparseGrassPatch")] + NodeOutput sparseGrassOutput) +{ + // clear groupshared counters + sparseGrassPatchCount = 0; + butterflyPatchCount = 0; + flowerPatchCount = 0; + beePatchCount = 0; + + GroupMemoryBarrierWithGroupSync(); + + const TileRecord input = inputRecord.Get(); + const int2 tileGridPosition = input.position; + const float2 tileWorldPosition = tileGridPosition * tileSize; + const float3 tileCenterWorldPosition = GetTerrainPosition(tileWorldPosition + tileSize * 0.5); + + const int2 threadGridPosition = tileGridPosition * detailedTilesPerTile + groupThreadId; + const float2 threadWorldPosition = threadGridPosition * detailedTileSize; + const float3 threadCenterWorldPosition = GetTerrainPosition(threadWorldPosition + detailedTileSize * 0.5); + const float3 threadCenterCurvedWorldPosition = GetCurvedWorldSpacePosition(threadCenterWorldPosition); + const float centerDistanceToCamera = distance(GetCameraPosition(), threadCenterWorldPosition); + + const AxisAlignedBoundingBox threadBoundingBox = + GetGridBoundingBox(threadGridPosition, detailedTileSize, -100, 300); + const bool isThreadVisible = threadBoundingBox.IsVisible(ComputeClipPlanes()); + + const uint seed = CombineSeed(asuint(threadGridPosition.x), asuint(threadGridPosition.y)); + const bool isNight = (GetTimeOfDay() > nightStartTime) || (GetTimeOfDay() < nightEndTime); + + // sparse grass + { + bool hasOutput = true; + + // --- frustum cull --- + float radius = sqrt(grassPatchesPerDetailedTile * grassPatchesPerDetailedTile) * grassSpacing; + if (!IsSphereVisible(threadCenterCurvedWorldPosition, radius, ComputeClipPlanes())) { + hasOutput = false; + } + + // --- distance cull --- + if (((centerDistanceToCamera + radius) < denseGrassMaxDistance) || + ((centerDistanceToCamera + radius) > sparseGrassMaxDistance)) + { + hasOutput = false; + } + + int outputIndex = 0; + + if (hasOutput) { + InterlockedAdd(sparseGrassPatchCount, 1, outputIndex); + } + + GroupMemoryBarrierWithGroupSync(); + + GroupNodeOutputRecords sparseGrassRecord = + sparseGrassOutput.GetGroupNodeOutputRecords(sparseGrassPatchCount > 0); + + if (all(groupThreadId == 0) && sparseGrassPatchCount > 0) { + sparseGrassRecord.Get().dispatchGrid = uint3(sparseGrassPatchCount, sparseGrassThreadGroupsPerRecord, 1); + } + + if (hasOutput) { + // XZ-position + sparseGrassRecord.Get().position[outputIndex] = threadGridPosition; + } + + sparseGrassRecord.OutputComplete(); + } + + // butterfly output + { + // 2% chance of spawning butterflies + const float butterflyProbability = 0.02f; + const bool hasButterflyOutput = + !isNight && // no butterflies at night + (centerDistanceToCamera < butterflyMaxDistance) && // cull butterflies in distance + (Random(seed, 1998) < butterflyProbability); + + int butterflyOutputIndex = 0; + + if (hasButterflyOutput) { + InterlockedAdd(butterflyPatchCount, 1, butterflyOutputIndex); + } + + GroupMemoryBarrierWithGroupSync(); + + GroupNodeOutputRecords butterflyOutputRecord = + butterflyOutput.GetGroupNodeOutputRecords(butterflyPatchCount > 0); + + if (all(groupThreadId == 0) && butterflyPatchCount > 0) { + butterflyOutputRecord.Get().dispatchGrid = uint3(butterflyPatchCount, 1, 1); + } + + if (hasButterflyOutput) { + // XZ-position + butterflyOutputRecord.Get().position[butterflyOutputIndex] = threadCenterWorldPosition; + } + + butterflyOutputRecord.OutputComplete(); + } + + // flower output + { + const float3 biomeWeight = GetBiomeWeights(threadWorldPosition); + + // cull flowers for visibility and max distance + const float flowerCullDistance = flowerMaxDistance - (Random(seed, 8437) * flowerMaxDistance * 0.2); + const bool hasFlowerOutput = isThreadVisible && (centerDistanceToCamera < flowerCullDistance); + // select random number of flowers to generate. number also depends on meadow biome weight + const int flowerOutputCount = + hasFlowerOutput * round(lerp(0, maxFlowersPerDetailedTile, Random(seed, 2134) * biomeWeight.z)); + // 30% chance of spawning bees over a flower + const float beeProbability = 0.3f; + // one of the generated flowers can also spawn a bee patch + const bool hasBeeOutput = (flowerOutputCount > 0) && // patch has at least one flower + !isNight && // no bees at night + (centerDistanceToCamera < beeMaxDistance) && // cull bees in distance + (Random(seed, 2378) < beeProbability); // limit bee occurrance + + // output indices into shared records + int flowerOutputIndex = 0; + int beeOutputIndex = 0; + + // increment shared flower/bee counters + if (flowerOutputCount > 0) { + InterlockedAdd(flowerPatchCount, flowerOutputCount, flowerOutputIndex); + } + if (hasBeeOutput) { + InterlockedAdd(beePatchCount, 1, beeOutputIndex); + } + + GroupMemoryBarrierWithGroupSync(); + + const uint flowerType = (distance(GetCameraPosition(), tileCenterWorldPosition) > flowerSparseStartDistance); + + GroupNodeOutputRecords flowerOutputRecord = + flowerOutput[flowerType].GetGroupNodeOutputRecords(flowerPatchCount > 0); + GroupNodeOutputRecords beeOutputRecord = + beeOutput.GetGroupNodeOutputRecords(beePatchCount > 0); + + if (all(groupThreadId == 0) && flowerPatchCount > 0) { + if (flowerType == 1) { + flowerOutputRecord.Get().dispatchGrid = uint3( + (flowerPatchCount + flowersInSparseFlowerThreadGroup - 1) / flowersInSparseFlowerThreadGroup, 1, 1); + } else { + flowerOutputRecord.Get().dispatchGrid = uint3(flowerPatchCount, 1, 1); + } + flowerOutputRecord.Get().flowerPatchCount = flowerPatchCount; + } + if (all(groupThreadId == 0) && beePatchCount > 0) { + beeOutputRecord.Get().dispatchGrid = uint3(beePatchCount, 1, 1); + } + + for (int flowerId = 0; flowerId < flowerOutputCount; ++flowerId) { + const float2 offset = + float2(Random(asuint(threadWorldPosition.x), asuint(threadWorldPosition.y), flowerId, 4387), + Random(asuint(threadWorldPosition.x), asuint(threadWorldPosition.y), flowerId, 8327)) * + detailedTileSize; + + flowerOutputRecord.Get().position[flowerOutputIndex + flowerId] = threadWorldPosition + offset; + } + + if (hasBeeOutput) { + beeOutputRecord.Get().position[beeOutputIndex] = + GetTerrainPosition(flowerOutputRecord.Get().position[flowerOutputIndex]); + } + + flowerOutputRecord.OutputComplete(); + beeOutputRecord.OutputComplete(); + } + + // detailed tile output + { + const bool hasDetailedTileOutput = + isThreadVisible && (centerDistanceToCamera < (denseGrassMaxDistance + (detailedTileSize * 2))); + + ThreadNodeOutputRecords detailedTileOutputRecord = + detailedTileOutput.GetThreadNodeOutputRecords(hasDetailedTileOutput); + + if (hasDetailedTileOutput) { + detailedTileOutputRecord.Get().position = tileGridPosition * detailedTilesPerTile + groupThreadId; + } + + detailedTileOutputRecord.OutputComplete(); + } +} + +[Shader("node")] +[NodeLaunch("broadcasting")] +[NodeDispatchGrid(1, 1, 1)] +// each thread corresponds to one grass patch tile +[NumThreads(grassPatchesPerDetailedTile, grassPatchesPerDetailedTile, 1)] +void DetailedTile( + DispatchNodeInputRecord inputRecord, + + int2 groupThreadId : SV_GroupThreadID, + + // Node outputs: + [MaxRecords(1)] + [NodeId("DrawDenseGrassPatch")] + NodeOutput grassOutput) +{ + // clear groupshared counters + denseGrassPatchCount = 0; + + GroupMemoryBarrierWithGroupSync(); + + const TileRecord input = inputRecord.Get(); + + const int2 tileGridPosition = input.position; + const float2 tileWorldPosition = tileGridPosition * detailedTileSize; + + const int2 threadGridPosition = tileGridPosition * grassPatchesPerDetailedTile + groupThreadId; + const float2 threadWorldPosition = (threadGridPosition + GetGrassOffset(threadGridPosition)) * grassSpacing; + + // get terrain height and normal & biome weights + const float3 patchPosition = GetTerrainPosition(threadWorldPosition.x, threadWorldPosition.y); + const float3 patchNormal = GetTerrainNormal(threadWorldPosition.x, threadWorldPosition.y); + const float3 biomeWeights = GetBiomeWeights(threadWorldPosition); + + bool hasOutput = true; + + // don't spawn grass on extremly steep slopes + if (patchNormal.y < 0.55) { + hasOutput = false; + } + + // cull against view frustum + const float radius = 4 * grassSpacing; + if (!IsSphereVisible(patchPosition, radius, ComputeClipPlanes())) { + hasOutput = false; + } + + const float distanceToCamera = distance(GetCameraPosition(), patchPosition.xyz); + + // cull against distance to camera + if (distanceToCamera > denseGrassMaxDistance) { + hasOutput = false; + } + + // cull at biome transitions to mountain biome + if (Random(asuint(patchPosition.x), asuint(patchPosition.z), 2378) < biomeWeights.x * 2) { + hasOutput = false; + } + + const float minGrassHeight = 0.2; + const float maxGrassHeight = minGrassHeight + .35; + const float grassHeight = minGrassHeight + (maxGrassHeight - minGrassHeight) * Random(threadGridPosition.x, threadGridPosition.y, 34567); + + // Each dense grass mesh shader can only render 16 grass blades. + // If grass patch has more than 16 blades, we require two thread groups to draw this patch + const bool hasSplitOutput = + lerp(32.f, 2., pow(saturate(distanceToCamera / (denseGrassMaxDistance * 1.05)), 0.75)) > 16.f; + + // Output dense grass + { + // sync total dense grass count + uint grassOutputIndex = 0; + + if (hasOutput) { + InterlockedAdd(denseGrassPatchCount, hasSplitOutput? 2 : 1, grassOutputIndex); + } + + GroupMemoryBarrierWithGroupSync(); + + GroupNodeOutputRecords denseGrassRecord = + grassOutput.GetGroupNodeOutputRecords(denseGrassPatchCount > 0); + + if (all(groupThreadId == 0) && denseGrassPatchCount > 0) { + denseGrassRecord.Get().dispatchGrid = uint3(denseGrassPatchCount, 1, 1); + } + + if (hasOutput) { + denseGrassRecord.Get().position[grassOutputIndex] = patchPosition; + denseGrassRecord.Get().height[grassOutputIndex] = grassHeight; + denseGrassRecord.Get().bladeOffset[grassOutputIndex] = 0; + + if (hasSplitOutput) { + denseGrassRecord.Get().position[grassOutputIndex + 1] = patchPosition; + denseGrassRecord.Get().height[grassOutputIndex + 1] = grassHeight; + denseGrassRecord.Get().bladeOffset[grassOutputIndex + 1] = 1; + } + } + + denseGrassRecord.OutputComplete(); + } +} \ No newline at end of file diff --git a/meshNodeSample/shaders/butterflymeshshader.hlsl b/meshNodeSample/shaders/butterflymeshshader.hlsl new file mode 100644 index 0000000..1c10fdb --- /dev/null +++ b/meshNodeSample/shaders/butterflymeshshader.hlsl @@ -0,0 +1,236 @@ +// This file is part of the AMD Work Graph Mesh Node Sample. +// +// Copyright (c) 2024 Advanced Micro Devices, Inc. All rights reserved. +// +// 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 +// AUTHORS OR COPYRIGHT HOLDERS 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. + +#include "common.hlsl" + +// Static "vertex buffer" for butterflies +static const int numButterflyVertices = 16; +static const float3 butterflyPositions[numButterflyVertices] = { + float3(-0.548, 0.0, -0.0), + float3(-0.41, 0.0, 0.226), + float3(-0.41, -0.0, -0.226), + float3(-0.948, 0.239, 0.528), + float3(-1.048, 0.238, 0.468), + float3(-0.948, 0.239, -0.528), + float3(-1.048, 0.238, -0.468), + float3(0.747, 0.0, 0.125), + float3(0.747, -0.0, -0.125), + float3(-0.194, 0.139, -0.0), + float3(0.384, -0.046, -0.0), + float3(-0.297, 0.092, -0.0), + float3(-0.651, 0.324, 2.446), + float3(1.621, -0.0, 0.785), + float3(-0.651, 0.324, -2.446), + float3(1.621, -0.0, -0.785), +}; +// Static vertex color attributes +static const float3 butterflyColors[numButterflyVertices] = { + float3(0., 0., 0.), + float3(0., 0., 0.), + float3(0., 0., 0.), + float3(0., 0., 0.), + float3(0., 0., 0.), + float3(0., 0., 0.), + float3(0., 0., 0.), + float3(0., 0., 0.), + float3(0., 0., 0.), + float3(0., 0., 0.), + float3(0., 0., 0.), + float3(0., 0., 0.), + float3(0.2, 0.2, .7), + float3(0.2, 0.2, .7), + float3(0.2, 0.2, .7), + float3(0.2, 0.2, .7) +}; + +// Static "index buffer" for butterflies +static const int numButterflyTriangles = 14; +static const uint3 butterflyTriangles[numButterflyTriangles] = { + uint3(1, 10, 0), + uint3(3, 4, 0), + uint3(5, 0, 6), + uint3(10, 2, 0), + uint3(7, 1, 9), + uint3(1, 0, 9), + uint3(2, 9, 0), + uint3(2, 8, 9), + uint3(7, 9, 8), + uint3(7, 10, 1), + uint3(7, 8, 10), + uint3(2, 10, 8), + uint3(12, 13, 11), + uint3(11, 14, 15), +}; + +float3 GetInsectPosition(float time) +{ + return 4 * float3(PerlinNoise2D(float2(time * 0.001, 0)), + PerlinNoise2D(float2(time * 0.001, 5)), + PerlinNoise2D(float2(time * 0.001, 9))); +} + +static const int butterflyGroupSize = 128; + +// customizable butterfly limit +static const int maxNumButterflies = min(32, min(256 / numButterflyVertices, 192 / numButterflyTriangles)); +static const int numOutputVertices = maxNumButterflies * numButterflyVertices; +static const int numOutputTriangles = maxNumButterflies * numButterflyTriangles; + +static const int numOutputVertexIterations = (numOutputVertices + (butterflyGroupSize - 1)) / butterflyGroupSize; +static const int numOutputTriangleIterations = (numOutputTriangles + (butterflyGroupSize - 1)) / butterflyGroupSize; + +[Shader("node")] +[NodeLaunch("mesh")] +[NodeId("DrawButterflies", 0)] +[NodeMaxDispatchGrid(maxInsectsPerRecord, 1, 1)] +// This limit was set through instrumentation and is not required on AMD GPUs. +// If you wish to change any of the procedural generation parameters, +// and you are running on a non-AMD GPU, you may need to adjust this limit. +// You can learn more at: +// https://gpuopen.com/learn/work_graphs_mesh_nodes/work_graphs_mesh_nodes-tips_tricks_best_practices +[NodeMaxInputRecordsPerGraphEntryRecord(10, true)] +[NumThreads(butterflyGroupSize, 1, 1)] +[OutputTopology("triangle")] +void ButterflyMeshShader( + uint gtid : SV_GroupThreadID, + uint gid : SV_GroupID, + DispatchNodeInputRecord inputRecord, + out indices uint3 tris[numOutputTriangles], + out vertices InsectVertex verts[numOutputVertices]) +{ + const int numButterflies = maxNumButterflies; + const int vertexCount = numButterflies * numButterflyVertices; + const int triangleCount = numButterflies * numButterflyTriangles; + + SetMeshOutputCounts(vertexCount, triangleCount); + + const float3 patchCenter = inputRecord.Get().position[gid]; + const int seed = CombineSeed(asuint(patchCenter.x), asuint(patchCenter.z)); + + [[unroll]] + for (int i = 0; i < numOutputTriangleIterations; ++i) + { + const int triId = gtid + butterflyGroupSize * i; + + if (triId < triangleCount) { + const int insectId = triId / numButterflyTriangles; + const int insectTriangleId = triId % numButterflyTriangles; + + tris[triId] = butterflyTriangles[insectTriangleId] + insectId * numButterflyVertices; + } + } + + [[unroll]] + for (int i = 0; i < numOutputVertexIterations; ++i) + { + const int vertId = gtid + butterflyGroupSize * i; + + if (vertId < vertexCount) { + const int insectId = vertId / numButterflyVertices; + const int insectVertexId = vertId % numButterflyVertices; + + // start time before night start + const float nightStart = nightStartTime - Random(seed, 4561); + // end time after night end + const float nightEnd = nightEndTime + Random(seed, 6456); + + // scale insects to 0 at night + const float nightScale = max(smoothstep(nightStart - 1, nightStart, GetTimeOfDay()), + 1 - smoothstep(nightEnd, nightEnd + 1, GetTimeOfDay())); + // slowly scale insects to 0 in the distance + // for simplicity, we omit this scaling from the motion vector, as it only affects very distant insects + const float distanceScale = smoothstep( + butterflyFadeStartDistance, butterflyMaxDistance, distance(patchCenter, GetCameraPosition())); + + const float scale = (.01 + 0.03 * Random(seed, insectId, 8)) * (1 - nightScale) * (1 - distanceScale); + + // radius scale for positioning insects + static const float R = 2; + const float angle = 2 * PI * Random(seed, insectId, 8); + const float radius = sqrt(R * Random(seed, insectId, 98)); + + // compute random position offset for insect + // insects will rotate around this position + const float3 insectBasePosition = + float3(radius * cos(angle), 0.75 + 0.5 * Random(seed, insectId, 988), radius * sin(angle)); + + const float timeOffset = 1e6 * Random(seed, insectId, 55); + const float time = GetTime() + timeOffset; + const float timePrev = GetPreviousTime() + timeOffset; + + // compute local insect position offsets + const float3 insectPositionOffset = GetInsectPosition(time * .25); + const float3 insectPositionOffsetDelta = GetInsectPosition((time - 10) * .25); + const float3 prevInsectPositionOffset = GetInsectPosition(timePrev * .25); + const float3 prevInsectPositionOffsetDelta = GetInsectPosition((timePrev - 10) * .25); + + const float3 insectPosition = insectBasePosition + insectPositionOffset; + const float3 prevInsectPosition = insectBasePosition + prevInsectPositionOffset; + + // compute forward vectors for rotating insects to face movement direction + const float2 forward = -normalize(insectPositionOffset.xz - insectPositionOffsetDelta.xz); + const float2 prevForward = -normalize(prevInsectPositionOffset.xz - prevInsectPositionOffsetDelta.xz); + + float3 vertexPosition = butterflyPositions[insectVertexId] * scale; + float3 prevVertexPosition = vertexPosition; + + // rotate wing vertices around insect center + if (insectVertexId >= 12) { + // compute wing animation angle + static const float wingDownAngle = -0.15; + static const float wingAmplitude = 0.6; + const float phase = wingDownAngle + wingAmplitude * cos(2 * PI * frac(time * 0.005)); + const float phasePrev = wingDownAngle + wingAmplitude * cos(2 * PI * frac(timePrev * 0.005)); + + // insect center for rotating wings + static const float3 rotatePoint = float3(0.353, 0.6, 0.0) * scale; + + float wingAngle = sign(vertexPosition.z) * phase; + float prevWingAngle = sign(vertexPosition.z) * phasePrev; + vertexPosition.yz = RotateAroundPoint2d(vertexPosition.yz, wingAngle, rotatePoint.yz); + prevVertexPosition.yz = RotateAroundPoint2d(prevVertexPosition.yz, prevWingAngle, rotatePoint.yz); + } + // rotate insect towards movement direction + vertexPosition.xz = float2(vertexPosition.x * forward.x - vertexPosition.z * forward.y, + vertexPosition.x * forward.y + vertexPosition.z * forward.x); + prevVertexPosition.xz = float2(prevVertexPosition.x * prevForward.x - prevVertexPosition.z * prevForward.y, + prevVertexPosition.x * prevForward.y + prevVertexPosition.z * prevForward.x); + + InsectVertex vertex; + vertex.objectSpacePosition = insectPosition + vertexPosition; + + if (insectVertexId >= 12) { + // compute random wing color + vertex.color = 0.95 * normalize(float3(Random(insectId, seed, 'r'), // + Random(insectId, seed, 'g'), // + Random(insectId, seed, 'b'))); + } else { + vertex.color = butterflyColors[insectVertexId]; + } + + ComputeClipSpacePositionAndMotion(vertex, + patchCenter + vertex.objectSpacePosition, + patchCenter + prevInsectPosition + prevVertexPosition); + + verts[vertId] = vertex; + } + } +} \ No newline at end of file diff --git a/meshNodeSample/shaders/common.hlsl b/meshNodeSample/shaders/common.hlsl new file mode 100644 index 0000000..52946db --- /dev/null +++ b/meshNodeSample/shaders/common.hlsl @@ -0,0 +1,355 @@ +// This file is part of the AMD Work Graph Mesh Node Sample. +// +// Copyright (c) 2024 Advanced Micro Devices, Inc. All rights reserved. +// +// 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 +// AUTHORS OR COPYRIGHT HOLDERS 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. + +#pragma once + +#include "workgraphcommon.h" +#include "utils.hlsl" +#include "heightmap.hlsl" + +// ================== +// Constants + +// World grid definitions +// DO NOT CHANGE THESE! +static const uint grassPatchesPerDetailedTile = 16; +static const uint detailedTilesPerTile = 8; +static const uint tilesPerChunk = 8; + +// World grid sizes are defined by grass blade spacing +static const float grassSpacing = 0.25; +static const float detailedTileSize = grassPatchesPerDetailedTile * grassSpacing; +static const float tileSize = detailedTilesPerTile * detailedTileSize; +static const float chunkSize = tilesPerChunk * tileSize; + +// Distance limits for procedural generation +static const float worldGridMaxDistance = 2000.f; + +static const float denseGrassMaxDistance = 80.f; +static const float sparseGrassMaxDistance = 250.f; + +static const float flowerMaxDistance = 300.f; +static const float flowerSparseStartDistance = 100.f; + +static const float mushroomMaxDistance = denseGrassMaxDistance; + +static const float butterflyMaxDistance = 25.f; +static const float butterflyFadeStartDistance = 20.f; +static const float beeMaxDistance = 40.f; +static const float beeFadeStartDistance = 30.f; + +// Night time definition: start at 18:00 till 6:00 +// Bees and butterflies won't be rendered/generated at night +static const float nightStartTime = 18.f; +static const float nightEndTime = 6.f; + +// Radius of curved world +static const float earthRadius = 6000.f; + +// =================================== +// Record structs for work graph nodes + +// Record for each tile in a chunk & detailed tile in a tile +struct TileRecord { + int2 position; +}; + +// Record for drawing terrain segments inside a chunk +struct DrawTerrainChunkRecord { + uint3 dispatchGrid : SV_DispatchGrid; + int2 chunkGridPosition; + int levelOfDetail; + // indicated if neighboring terrain tiles have higher LOD + // x = (-1, 0) + // y = (0, -1) + // z = (1, 0) + // w = (0, 1) + bool4 levelOfDetailTransition; +}; + +struct GenerateTreeRecord { + float2 position; +}; + +static const uint maxSplinesPerRecord = 32; +static const uint splineMaxControlPointCount = 8; + +// Record for drawing multiple splines. Each spline is defined as a series of control points. +// Each control point defines a vertex ring with varying radius and vertex count. +struct DrawSplineRecord { + uint3 dispatchGrid : SV_DispatchGrid; + float3 color[maxSplinesPerRecord]; + float rotationOffset[maxSplinesPerRecord]; + // x is overall wind strength, y is blending factor for individual vertices + float2 windStrength[maxSplinesPerRecord]; + uint controlPointCount[maxSplinesPerRecord]; + float3 controlPointPositions[maxSplinesPerRecord * splineMaxControlPointCount]; + uint controlPointVertexCounts[maxSplinesPerRecord * splineMaxControlPointCount]; + float2 controlPointRadii[maxSplinesPerRecord * splineMaxControlPointCount]; + float controlPointNoiseAmplitudes[maxSplinesPerRecord * splineMaxControlPointCount]; +}; + +// Each thread in a biome tile can generate one insects +static const uint maxInsectsPerRecord = detailedTilesPerTile * detailedTilesPerTile; + +// Record for insects +// Used by +// - DrawBees +// - DrawButterflies +struct DrawInsectRecord { + uint3 dispatchGrid : SV_DispatchGrid; + float3 position[maxInsectsPerRecord]; +}; + +// Each thread in a biome tile can generate up to 3 mushrooms +static const uint maxMushroomsPerDetailedTile = 3; +static const uint maxMushroomsPerRecord = detailedTilesPerTile * detailedTilesPerTile * maxMushroomsPerDetailedTile; + +// Record for mushrooms +// Used by +// - DrawMushroomPatch +struct DrawMushroomRecord { + uint3 dispatchGrid : SV_DispatchGrid; + float3 position[maxMushroomsPerRecord]; +}; + +// Each thread in a biome tile can generate up to 12 flowers +static const int maxFlowersPerDetailedTile = 12; +static const int maxFlowersPerRecord = (detailedTilesPerTile * detailedTilesPerTile) * maxFlowersPerDetailedTile; +// scaling factor for dispatch grid size when using sparse flowers +static const int flowersInSparseFlowerThreadGroup = 5; + +// Record for flowers +// Used by +// - DrawFlowerPatch +struct DrawFlowerRecord { + uint3 dispatchGrid : SV_DispatchGrid; + uint flowerPatchCount; + float2 position[maxFlowersPerRecord]; +}; + +// Each thread in a detailed tile corresponds to one or two dense grass patches +static const uint maxDenseGrassPatchesPerRecord = 2 * grassPatchesPerDetailedTile * grassPatchesPerDetailedTile; + +// Record for dense grass +// Used by +// - DrawDenseGrassPatch +struct DrawDenseGrassRecord { + uint3 dispatchGrid : SV_DispatchGrid; + float3 position[maxDenseGrassPatchesPerRecord]; + float height[maxDenseGrassPatchesPerRecord]; + uint bladeOffset[maxDenseGrassPatchesPerRecord]; +}; + +// Each thread in a biome tile corresponds to a sparse grass patch +static const uint maxSparseGrassPatchesPerRecord = detailedTilesPerTile * detailedTilesPerTile; +// Number of sparse grass mesh shader thread groups needed to render one detailed tile +static const uint sparseGrassThreadGroupsPerRecord = 8; + +// record for DrawSparseGrassPatch +struct DrawSparseGrassRecord { + uint3 dispatchGrid : SV_DispatchGrid; + int2 position[maxSparseGrassPatchesPerRecord]; +}; + +// ===================================== +// Common MS & PS input & output structs + +// Vertex definition for InsectPixelShader +// Used by +// - BeeMeshShader +// - ButterflyMeshShader +// - FlowerMeshShader +// - MushroomMeshShader +struct InsectVertex { + float4 clipSpacePosition : SV_POSITION; + // Vertex position in object space for computing normals + // object to world space transforms are always only translations + // thus we can safely compute normals in object space + float3 objectSpacePosition : POSITION0; + float2 clipSpaceMotion : TEXCOORD0; + float3 color : NORMAL0; +}; + +// Vertex definition for GrassPixelShader +// Used by +// - DenseGrassMeshShader +// - SparseGrassMeshShader +struct GrassVertex { + float4 clipSpacePosition : SV_POSITION; + float3 worldSpacePosition : POSITION0; + float2 clipSpaceMotion : TEXCOORD0; + float3 worldSpaceNormal : NORMAL0; + float3 worldSpaceGroundNormal : NORMAL1; + float rootHeight : BLENDWEIGHT0; + float height : BLENDWEIGHT1; +}; + +// Primitive definition for mesh shaders +// Used by +// - SparseGrassMeshShader +struct GrassCullPrimitive { + bool cull : SV_CullPrimitive; +}; + +// Output struct for deferred pixel shaders +struct DeferredPixelShaderOutput { + float4 baseColor : SV_Target0; + float4 normal : SV_Target1; + float2 motion : SV_Target2; +}; + +// ====================================================== +// Common functions for accessing data in constant buffer + +float GetTimeOfDay() +{ + return 12; +} + +float3 GetCameraPosition() +{ + return CameraPosition.xyz; +} + +float3 GetPreviousCameraPosition() +{ + return PreviousCameraPosition.xyz; +} + +ClipPlanes ComputeClipPlanes() +{ + return ComputeClipPlanes(ViewProjection); +} + +uint GetTime() +{ + return ShaderTime; +} + +uint GetPreviousTime() +{ + return PreviousShaderTime; +} + +float GetWindStrength() +{ + return WindStrength; +} + +// Rotation of wind direction around y-Axis; 0 = float3(1, 0, 0); +float GetWindDirection() +{ + return WindDirection; +} + +// ===================================================== +// Common functions for grass placement & wind animation + +float2 GetGrassOffset(in const int2 grid) +{ + float theta = 2. * PI * Random(grid.x, grid.y, 1337); + float radius = sqrt(Random(grid.x, 19, grid.y)); + static const float patchCenterVariance = 0.4; + + return patchCenterVariance * radius * float2(cos(theta), sin(theta)); +} + +// Returns 2D wind offset as 3D vector for convenience +float3 GetWindOffset(in const float2 pos, in const float time) +{ + float posOnSineWave = cos(GetWindDirection()) * pos.x - sin(GetWindDirection()) * pos.y; + + float t = 0.007 * time + posOnSineWave + 4 * PerlinNoise2D(0.1 * pos); + float windx = 2 * sin(.5 * t); + float windz = 1 * sin(1. * t); + + return 0.04 * float3(windx, 0, windz); +} + +// ================================================== +// Common functions for curved world & motion vectors + +// Computes position on curved world relative to current camera position +float3 GetCurvedWorldSpacePosition(in float3 worldSpacePosition, in bool previousCenter = false) +{ + const float2 center = previousCenter ? GetPreviousCameraPosition().xz : GetCameraPosition().xz; + const float2 centerToPos = worldSpacePosition.xz - center; + const float distanceToCenter = length(centerToPos); + const float2 direction = centerToPos / distanceToCenter; + + const float alpha = distanceToCenter / earthRadius; + const float s = sin(alpha); + const float c = cos(alpha); + + const float3 curvedPosUp = normalize(float3(direction.x * s, c, direction.y * s)); + const float3 centerToCurvedPos = + float3(direction.x * s * earthRadius, (c * earthRadius) - earthRadius, direction.y * s * earthRadius); + + const float heightScale = smoothstep(2000, 1000, distanceToCenter); + + return float3(center.x, 0, center.y) + centerToCurvedPos + // base postion + curvedPosUp * worldSpacePosition.y * heightScale; // add rotated y component +} + +// Computes bounding box for a grid element (e.g. chunk) on curved world +AxisAlignedBoundingBox GetGridBoundingBox(in int2 gridPosition, + in float elementSize, + in float minHeight, + in float maxHeight) +{ + AxisAlignedBoundingBox result; + + const float3 minWorldPosition = float3(gridPosition.x, 0, gridPosition.y) * elementSize; + const float3 maxWorldPosition = float3(gridPosition.x + 1, 0, gridPosition.y + 1) * elementSize; + + result.min = GetCurvedWorldSpacePosition(minWorldPosition) + float3(0, minHeight, 0); + result.max = GetCurvedWorldSpacePosition(maxWorldPosition) + float3(0, maxHeight, 0); + + return result; +} + +// Computes position on curved world, projects it into clip space & assigns it to vertex.clipSpacePosition +// Computes motion vector and assigns it to vertex.clipSpaceMotion +template +void ComputeClipSpacePositionAndMotion(inout T vertex, + in float3 worldSpacePosition, + in float3 previousWorldSpacePosition) +{ + // project vertex onto curved world + const float3 curvedWorldSpacePosition = GetCurvedWorldSpacePosition(worldSpacePosition); + const float3 previousCurvedWorldSpacePosition = GetCurvedWorldSpacePosition(previousWorldSpacePosition, true); + + vertex.clipSpacePosition = mul(ViewProjection, float4(curvedWorldSpacePosition, 1)); + + const float4 previousClipSpacePosition = + mul(PreviousViewProjection, float4(previousCurvedWorldSpacePosition, 1)); + vertex.clipSpaceMotion = (previousClipSpacePosition.xy / previousClipSpacePosition.w) - + (vertex.clipSpacePosition.xy / vertex.clipSpacePosition.w); +} + +// Computes position on curved world, projects it into clip space & assigns it to vertex.clipSpacePosition +// Computes motion vector and assigns it to vertex.clipSpaceMotion +template +void ComputeClipSpacePositionAndMotion(inout T vertex, in float3 worldSpacePosition) +{ + ComputeClipSpacePositionAndMotion(vertex, worldSpacePosition, worldSpacePosition); +} \ No newline at end of file diff --git a/meshNodeSample/shaders/densegrassmeshshader.hlsl b/meshNodeSample/shaders/densegrassmeshshader.hlsl new file mode 100644 index 0000000..7ea8c36 --- /dev/null +++ b/meshNodeSample/shaders/densegrassmeshshader.hlsl @@ -0,0 +1,206 @@ +// This file is part of the AMD Work Graph Mesh Node Sample. +// +// Copyright (c) 2024 Advanced Micro Devices, Inc. All rights reserved. +// +// 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 +// AUTHORS OR COPYRIGHT HOLDERS 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. + +#include "common.hlsl" + +float3 bezier(float3 v0, float3 v1, float3 v2, float t) +{ + float3 a = lerp(v0, v1, t); + float3 b = lerp(v1, v2, t); + return lerp(a, b, t); +} + +float3 bezierDerivative(float3 v0, float3 v1, float3 v2, float t) +{ + return 2. * (1. - t) * (v1 - v0) + 2. * t * (v2 - v1); +} + +// The following function (MakePersistentLength) is taken from +// https://github.com/klejah/ResponsiveGrassDemo/blob/6ce514717467acc80fd965a6f7695d5151ba8c03/ResponsiveGrassDemo/shader/Grass/GrassUpdateForcesShader.cs#L67 +// Licensed under BSD 3-Clause: +// +// Copyright (c) 2016, klejah +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// * Redistributions of source code must retain the above copyright notice, this +// list of conditions and the following disclaimer. +// +// * 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. +// +// * Neither the name of the copyright holder nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +void MakePersistentLength(in float3 v0, inout float3 v1, inout float3 v2, in float height) +{ + // Persistent length + float3 v01 = v1 - v0; + float3 v12 = v2 - v1; + float lv01 = length(v01); + float lv12 = length(v12); + + float L1 = lv01 + lv12; + float L0 = length(v2 - v0); + float L = (2.0f * L0 + L1) / 3.0f; // http://steve.hollasch.net/cgindex/curves/cbezarclen.html + + float ldiff = height / L; + v01 = v01 * ldiff; + v12 = v12 * ldiff; + v1 = v0 + v01; + v2 = v1 + v12; +} + +static const int denseGrassGroupSize = 128; +static const int maxNumOutputVerticesLimit = 256; +static const int maxNumOutputTrianglesLimit = 192; +static const int numOutputVerticesLimit = 128; +static const int numOutputTrianglesLimit = 96; + +// 4 vertices per edge; 2 edges per blade +static const int numGrassBladeVerticesPerEdge = 4; +static const int numGrassBladeVertices = 2 * numGrassBladeVerticesPerEdge; +static const int numGrassBladeTriangles = 6; +static const int maxNumGrassBlades = + min(32, + min(maxNumOutputVerticesLimit / numGrassBladeVertices, maxNumOutputTrianglesLimit / numGrassBladeTriangles)); +static const int maxNumOutputGrassBlades = + min(32, min(numOutputVerticesLimit / numGrassBladeVertices, numOutputTrianglesLimit / numGrassBladeTriangles)); +static const int numOutputVertices = maxNumOutputGrassBlades * numGrassBladeVertices; +static const int numOutputTriangles = maxNumOutputGrassBlades * numGrassBladeTriangles; + +static const int numOutputVertexIterations = (numOutputVertices + (denseGrassGroupSize - 1)) / denseGrassGroupSize; +static const int numOutputTriangleIterations = (numOutputTriangles + (denseGrassGroupSize - 1)) / denseGrassGroupSize; + +[Shader("node")] +[NodeLaunch("mesh")] +[NodeId("DrawDenseGrassPatch", 0)] +[NodeMaxDispatchGrid(maxDenseGrassPatchesPerRecord, 1, 1)] +// This limit was set through instrumentation and is not required on AMD GPUs. +// If you wish to change any of the procedural generation parameters, +// and you are running on a non-AMD GPU, you may need to adjust this limit. +// You can learn more at: +// https://gpuopen.com/learn/work_graphs_mesh_nodes/work_graphs_mesh_nodes-tips_tricks_best_practices +[NodeMaxInputRecordsPerGraphEntryRecord(400, true)] +[NumThreads(denseGrassGroupSize, 1, 1)] +[OutputTopology("triangle")] +void DenseGrassMeshShader( + uint gtid : SV_GroupThreadID, + uint gid : SV_GroupID, + DispatchNodeInputRecord inputRecord, + out indices uint3 tris[numOutputTriangles], + out vertices GrassVertex verts[numOutputVertices]) +{ + const float3 patchCenter = inputRecord.Get().position[gid]; + const float patchHeight = inputRecord.Get().height[gid]; + const uint bladeOffset = inputRecord.Get().bladeOffset[gid]; + const float patchWindStrength = GetWindStrength(); + const float3 patchNormal = GetTerrainNormal(patchCenter.xz); + const int seed = CombineSeed(asuint(int(patchCenter.x / grassSpacing)), asuint(int(patchCenter.z / grassSpacing))); + + const float dist = distance(patchCenter, GetCameraPosition()); + const float bladeCountF = + lerp(float(maxNumGrassBlades), 2., pow(saturate(dist / (denseGrassMaxDistance * 1.05)), 0.75)); + + const int tileBladeCount = ceil(bladeCountF); + const int threadGroupBladeOffset = bladeOffset * maxNumOutputGrassBlades; + const int threadGroupBladeCount = clamp(tileBladeCount - threadGroupBladeOffset, 0, maxNumOutputGrassBlades); + + const int vertexCount = threadGroupBladeCount * numGrassBladeVertices; + const int triangleCount = threadGroupBladeCount * numGrassBladeTriangles; + + SetMeshOutputCounts(vertexCount, triangleCount); + + const int vertId = gtid; + if (vertId < vertexCount) { + const int bladeId = (vertId / numGrassBladeVertices) + threadGroupBladeOffset; + const int vertIdLocal = vertId % numGrassBladeVertices; + + const float height = patchHeight + float(Random(seed, bladeId, 20)) / 40.; + + // Position the grass in a circle around the hitPosition and angled using the hitNormal + float3 tangent = normalize(cross(float3(0, 0, 1), patchNormal)); + float3 bitangent = normalize(cross(patchNormal, tangent)); + + float bladeDirectionAngle = 2. * PI * Random(seed, 4, bladeId); + float2 bladeDirection = float2(cos(bladeDirectionAngle), sin(bladeDirectionAngle)) * height * 0.3; + + float offsetAngle = 2. * PI * Random(seed, bladeId); + float offsetRadius = grassSpacing * sqrt(Random(seed, 19, bladeId)); + float3 bladeOffset = offsetRadius * (cos(offsetAngle) * tangent + sin(offsetAngle) * bitangent); + + float3 v0 = patchCenter + bladeOffset; + float3 v1 = v0 + float3(0, height, 0); + float3 v2 = v1 + float3(bladeDirection.x, 0, bladeDirection.y); + + float3 v1prev = v1; + float3 v2prev = v2 + patchWindStrength * GetWindOffset(v0.xz, GetPreviousTime()); + + v2 += patchWindStrength * GetWindOffset(v0.xz, GetTime()); + + MakePersistentLength(v0, v1, v2, height); + MakePersistentLength(v0, v1prev, v2prev, height); + + float width = 0.03; + + width *= maxNumGrassBlades / bladeCountF; + + if (bladeId == (tileBladeCount - 1)) { + width *= frac(bladeCountF); + } + + GrassVertex vertex; + vertex.height = patchHeight; + vertex.worldSpaceGroundNormal = patchNormal; + vertex.rootHeight = v0.y; + + const float3 sideVec = normalize(float3(bladeDirection.y, 0, -bladeDirection.x)); + const float3 offset = BitSign(vertIdLocal, 0) * width * sideVec; + + v0 += offset * 1.0; + v1 += offset * 0.7; + v2 += offset * 0.3; + + v1prev += offset * 0.7; + v2prev += offset * 0.3; + + float t = (vertIdLocal / 2) / float(numGrassBladeVerticesPerEdge - 1); + vertex.worldSpacePosition = bezier(v0, v1, v2, t); + vertex.worldSpaceNormal = cross(sideVec, normalize(bezierDerivative(v0, v1, v2, t))); + + ComputeClipSpacePositionAndMotion(vertex, vertex.worldSpacePosition, bezier(v0, v1prev, v2prev, t)); + + verts[vertId] = vertex; + } + + const int triId = gtid; + if (triId < triangleCount) { + const int bladeId = triId / numGrassBladeTriangles; + const int triIdLocal = triId % numGrassBladeTriangles; + + const int offset = bladeId * numGrassBladeVertices + 2 * (triIdLocal / 2); + + tris[triId] = offset + (((triIdLocal & 1) == 0) ? uint3(0, 1, 2) : uint3(3, 2, 1)); + } +} \ No newline at end of file diff --git a/meshNodeSample/shaders/flowermeshshader.hlsl b/meshNodeSample/shaders/flowermeshshader.hlsl new file mode 100644 index 0000000..69dcf42 --- /dev/null +++ b/meshNodeSample/shaders/flowermeshshader.hlsl @@ -0,0 +1,397 @@ +// This file is part of the AMD Work Graph Mesh Node Sample. +// +// Copyright (c) 2024 Advanced Micro Devices, Inc. All rights reserved. +// +// 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 +// AUTHORS OR COPYRIGHT HOLDERS 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. + +#include "common.hlsl" + +static const int flowerGroupSize = 128; + +static const int stemVertexCount = 6; +static const int stemTriangleCount = 6; + +static const int headMaxRingCount = 6; +static const int headMaxVertexCount = headMaxRingCount * 2 + 2; +static const int headMaxTriangleCount = headMaxRingCount * 4; + +static const int flowerMaxVertexCount = stemVertexCount + headMaxVertexCount; +static const int flowerMaxTriangleCount = stemTriangleCount + headMaxTriangleCount; + +static const int outputMaxVertexCount = 128; +static const int outputMaxTriangleCount = 256; +static const int maxFlowerCount = + min(outputMaxVertexCount / flowerMaxVertexCount, outputMaxTriangleCount / flowerMaxTriangleCount); + +static const int numOutputVertices = maxFlowerCount * flowerMaxVertexCount; +static const int numOutputTriangles = maxFlowerCount * flowerMaxTriangleCount; + +static const int numOutputVertexIterations = (numOutputVertices + (flowerGroupSize - 1)) / flowerGroupSize; +static const int numOutputTriangleIterations = (numOutputTriangles + (flowerGroupSize - 1)) / flowerGroupSize; + +static const int sparseFlowerVertexCount = 4; +static const int sparseFlowerTriangleCount = 2; + +static const int sparseOutputMaxVertexCount = 128; +static const int sparseOutputMaxTriangleCount = 64; +// maximum number of flower patches that can be rendered by one sparse flower thread group +static const int maxSparseFlowerPatchesPerThreadGroup = min(sparseOutputMaxVertexCount / sparseFlowerVertexCount, + sparseOutputMaxTriangleCount / sparseFlowerTriangleCount) / + maxFlowerCount; + +static const int numSparseOutputVertices = + maxSparseFlowerPatchesPerThreadGroup * maxFlowerCount * sparseFlowerVertexCount; +static const int numSparseOutputTriangles = + maxSparseFlowerPatchesPerThreadGroup * maxFlowerCount * sparseFlowerTriangleCount; + + +float GetFlowerHeight(in int flowerId, in uint seed) +{ + return .5f + Random(seed, 79823, flowerId) * 0.2f; +} + +float2 GetFlowerPosition(in int flowerId, in uint seed) +{ + const float flowerPositionAngle = flowerId + Random(seed, 324897, flowerId); + const float flowerPositionRadius = 0.05f + (flowerId * 0.05f) + Random(seed, flowerId, 4732) * 0.1f; + return float2(cos(flowerPositionAngle), sin(flowerPositionAngle)) * flowerPositionRadius; +} + +float3 GetFlowerColor(in int flowerId, in uint seed) +{ + static const float3 flowerColor[] = { + float3(1.0, 0.95, 0.95), + float3(1.0, 0.95, 0.95), + float3(1.0, 0.95, 0.95), + float3(1.0, 0.2, 0.3), + float3(1.0, 0.4, 1.0), + float3(0.95, 0.8, 0.0), + float3(0.7, 0.7, 1.0), + }; + + return flowerColor[Random(seed, flowerId) * 7]; +} + +int GetFlowerCount(in int seed) { + return round(lerp(2, maxFlowerCount, Random(seed, 6145))); +} + +static const float3 flowerStemColor = pow(float3(0.82, 0.89, 0.58), 2.2); + +[Shader("node")] +[NodeLaunch("mesh")] +[NodeId("DrawFlowerPatch", 0)] +[NodeMaxDispatchGrid(maxFlowersPerRecord, 1, 1)] +// This limit was set through instrumentation and is not required on AMD GPUs. +// If you wish to change any of the procedural generation parameters, +// and you are running on a non-AMD GPU, you may need to adjust this limit. +// You can learn more at: +// https://gpuopen.com/learn/work_graphs_mesh_nodes/work_graphs_mesh_nodes-tips_tricks_best_practices +[NodeMaxInputRecordsPerGraphEntryRecord(200, true)] +[NumThreads(flowerGroupSize, 1, 1)] +[OutputTopology("triangle")] +void FlowerMeshShader( + uint gtid : SV_GroupThreadID, + uint gid : SV_GroupID, + DispatchNodeInputRecord inputRecord, + out indices uint3 tris[numOutputTriangles], + out vertices InsectVertex verts[numOutputVertices]) +{ + const DrawFlowerRecord record = inputRecord.Get(); + + const float3 patchPosition = GetTerrainPosition(inputRecord.Get().position[gid]); + const uint seed = CombineSeed(asuint(patchPosition.x), asuint(patchPosition.z)); + + const int flowerCount = GetFlowerCount(seed); + const int headRingVertexCount = round(lerp(4, headMaxRingCount, Random(seed, 7878))); + + const int headVertexCount = headRingVertexCount * 2 + 2; + const int headTriangleCount = headRingVertexCount * 4; + + const int totalStemVertexCount = flowerCount * stemVertexCount; + const int totalStemTriangleCount = flowerCount * stemTriangleCount; + + const int totalHeadVertexCount = flowerCount * headVertexCount; + const int totalHeadTriangleCount = flowerCount * headTriangleCount; + + const int vertexCount = totalStemVertexCount + totalHeadVertexCount; + const int triangleCount = totalStemTriangleCount + totalHeadTriangleCount; + + SetMeshOutputCounts(vertexCount, triangleCount); + + [[unroll]] + for (uint i = 0; i < numOutputVertexIterations; ++i) + { + const int vertId = gtid + flowerGroupSize * i; + + int flowerId; + float3 localVertexPosition; + float3 color; + + if (vertId < totalStemVertexCount) { + // vertex is stem vertex + + flowerId = vertId / stemVertexCount; + const int stemVertexId = vertId % stemVertexCount; + + const bool isTopVertex = stemVertexId >= 3; + + const float flowerHeight = GetFlowerHeight(flowerId, seed); + const float stemRadius = .03f * (isTopVertex ? 0.8f : 1.f) + Random(seed, 87324, flowerId) * 0.02f; + const float stemRotationOffset = flowerId; + + const float vertexAngle = stemRotationOffset + stemVertexId * ((2 * PI) / 3.f); + const float2 vertexRingPosition = float2(cos(vertexAngle), sin(vertexAngle)) * stemRadius; + + const float vertexY = isTopVertex ? flowerHeight : 0; + localVertexPosition = float3(vertexRingPosition.x, vertexY, vertexRingPosition.y); + + color = flowerStemColor; + } else if (vertId < (totalStemVertexCount + totalHeadVertexCount)) { + const int vertexOffset = totalStemVertexCount; + + flowerId = (vertId - vertexOffset) / headVertexCount; + const int headVertexId = (vertId - vertexOffset) % headVertexCount; + + const bool isBottomVertex = headVertexId == 0; + const bool isTopVertex = headVertexId == (headVertexCount - 1); + const int headVertexRing = (headVertexId - 1) / headRingVertexCount; + + const float flowerHeight = GetFlowerHeight(flowerId, seed); + const float headRadius = (isBottomVertex || isTopVertex) ? 0.f : (.08f * (1 + (headVertexRing * 0.2))); + const float headRotationOffset = flowerId; + + const float vertexAngle = headRotationOffset + headVertexId * ((2 * PI) / float(headRingVertexCount)); + const float2 vertexRingPosition = float2(cos(vertexAngle), sin(vertexAngle)) * headRadius; + + const float ringHeight = 0.05f; + float vertexY = flowerHeight + headVertexRing * ringHeight; + if (isTopVertex) { + vertexY = flowerHeight + 0 * ringHeight; + } + if (isBottomVertex) { + vertexY = flowerHeight - ringHeight; + } + + localVertexPosition = float3(vertexRingPosition.x, vertexY, vertexRingPosition.y); + + color = GetFlowerColor(flowerId, seed); + } + + if (vertId < vertexCount) { + const float2 flowerPositionOffset = GetFlowerPosition(flowerId, seed); + const float3 windOffset = localVertexPosition.y * GetWindStrength() * + GetWindOffset(patchPosition.xz + flowerPositionOffset, GetTime()); + const float3 previousWindOffset = localVertexPosition.y * GetWindStrength() * + GetWindOffset(patchPosition.xz + flowerPositionOffset, GetPreviousTime()); + + InsectVertex vertex; + vertex.objectSpacePosition = + float3(flowerPositionOffset.x, 0, flowerPositionOffset.y) + localVertexPosition + windOffset; + vertex.color = color; + + const float3 worldSpaceBasePosition = + patchPosition + float3(flowerPositionOffset.x, 0, flowerPositionOffset.y) + localVertexPosition; + + ComputeClipSpacePositionAndMotion( + vertex, worldSpaceBasePosition + windOffset, worldSpaceBasePosition + previousWindOffset); + + verts[vertId] = vertex; + } + } + + [[unroll]] + for (uint i = 0; i < numOutputTriangleIterations; ++i) + { + const int triId = gtid + flowerGroupSize * i; + + uint3 triangleIndices = uint3(0, 1, 2); + + if (triId < totalStemTriangleCount) { + // triangle is stem triangle + + const int flowerId = triId / stemTriangleCount; + const int stemTriangleId = triId % stemTriangleCount; + + const int stemVertexOffset = flowerId * stemVertexCount; + + const uint base = stemTriangleId / 2; + // z -- w + // | \ | + // | \ | + // y -- x + const uint4 quad = uint4(base, (base + 1) % 3, (base + 1) % 3 + 3, base + 3); + + triangleIndices = stemVertexOffset + ((stemTriangleId & 0x1) ? quad.xyz : quad.xzw); + } else if (triId < (totalStemTriangleCount + totalHeadTriangleCount)) { + // triangle is head triangle + + const int triangleOffset = totalStemTriangleCount; + + const int headId = (triId - triangleOffset) / headTriangleCount; + const int headTriangleId = (triId - triangleOffset) % headTriangleCount; + + const int bottomVertexId = 0; + const int topVertexId = 1 + (2 * headRingVertexCount); + const int firstRingVertexOffset = 1; + const int secondRingVertexOffset = 1 + headRingVertexCount; + + const int headVertexOffset = totalStemVertexCount + headId * headVertexCount; + + triangleIndices = headVertexOffset + uint3(0, 0, 0); + + if (headTriangleId < (2 * headRingVertexCount)) { + const uint base = headTriangleId / 2; + const uint3 ringTriangle = uint3(bottomVertexId, + firstRingVertexOffset + base, + firstRingVertexOffset + (base + 1) % headRingVertexCount); + + triangleIndices = + headVertexOffset + ((headTriangleId & 0x1) ? (topVertexId - ringTriangle) : ringTriangle); + } else { + const uint base = (headTriangleId - (2 * headRingVertexCount)) / 2; + + const uint3 ringTriangle = uint3(firstRingVertexOffset + base, + firstRingVertexOffset + (base + 1) % headRingVertexCount, + firstRingVertexOffset + base + headRingVertexCount); + + triangleIndices = + headVertexOffset + ((headTriangleId & 0x1) ? (topVertexId - ringTriangle) : ringTriangle); + } + } + + if (triId < triangleCount) { + tris[triId] = triangleIndices; + } + } +} + +[Shader("node")] +[NodeLaunch("mesh")] +[NodeId("DrawFlowerPatch", 1)] +[NodeMaxDispatchGrid(maxFlowersPerRecord / flowersInSparseFlowerThreadGroup, 1, 1)] +// This limit was set through instrumentation and is not required on AMD GPUs. +// If you wish to change any of the procedural generation parameters, +// and you are running on a non-AMD GPU, you may need to adjust this limit. +// You can learn more at: +// https://gpuopen.com/learn/work_graphs_mesh_nodes/work_graphs_mesh_nodes-tips_tricks_best_practices +[NodeMaxInputRecordsPerGraphEntryRecord(200, true)] +[NumThreads(flowerGroupSize, 1, 1)] +[OutputTopology("triangle")] +void SparseFlowerMeshShader( + uint gtid : SV_GroupThreadID, + uint gid : SV_GroupID, + DispatchNodeInputRecord inputRecord, + out indices uint3 tris[numOutputTriangles], + out vertices InsectVertex verts[numOutputVertices]) +{ + const int recordPositionOffset = gid * maxSparseFlowerPatchesPerThreadGroup; + const int threadGroupPatchCount = + clamp(int(inputRecord.Get().flowerPatchCount) - recordPositionOffset, 0, maxSparseFlowerPatchesPerThreadGroup); + + int totalFlowerCount = 0; + + if (WaveGetLaneIndex() < threadGroupPatchCount) { + const float2 lanePatchPosition = inputRecord.Get().position[recordPositionOffset + WaveGetLaneIndex()]; + const int laneSeed = CombineSeed(asuint(lanePatchPosition.x), asuint(lanePatchPosition.y)); + const int laneFlowerCount = GetFlowerCount(laneSeed); + + totalFlowerCount = laneFlowerCount; + } + + totalFlowerCount = WaveActiveSum(totalFlowerCount); + + const int vertexCount = totalFlowerCount * sparseFlowerVertexCount; + const int triangleCount = totalFlowerCount * sparseFlowerTriangleCount; + + SetMeshOutputCounts(vertexCount, triangleCount); + + if (gtid < vertexCount) { + float3 patchPosition = 0; + uint seed = 0; + int vertexId = 0; + + { + int runningVertexCount = 0; + + for (int i = 0; i < maxSparseFlowerPatchesPerThreadGroup; ++i) { + const float2 candidatePatchPosition = inputRecord.Get().position[recordPositionOffset + i]; + const int candidateSeed = + CombineSeed(asuint(candidatePatchPosition.x), asuint(candidatePatchPosition.y)); + const int candidateFlowerCount = GetFlowerCount(candidateSeed); + const int candidateVertexCount = candidateFlowerCount * sparseFlowerVertexCount; + + if ((gtid >= runningVertexCount) && (gtid < (runningVertexCount + candidateVertexCount))) { + patchPosition = GetTerrainPosition(candidatePatchPosition); + seed = candidateSeed; + vertexId = gtid - runningVertexCount; + } + + runningVertexCount += candidateVertexCount; + } + } + + const int flowerId = vertexId / sparseFlowerVertexCount; + const int flowerVertexId = vertexId % sparseFlowerVertexCount; + + const float2 flowerPositionOffset = GetFlowerPosition(flowerId, seed); + const float flowerHeight = GetFlowerHeight(flowerId, seed); + + const float3 viewVector = normalize(patchPosition - GetCameraPosition()); + const float3 side = normalize(cross(viewVector, float3(0, 1, 0))); + const float3 back = normalize(float3(viewVector.x, 0, viewVector.z)); + + const float width = 0.1; + const float depth = 0.15; + + float3 localVertexPosition = 0; + + if (flowerVertexId == 1) { + localVertexPosition = float3(0, flowerHeight, 0) + side * width; + } else if (flowerVertexId == 2) { + localVertexPosition = float3(0, flowerHeight, 0) - side * width; + } else if (flowerVertexId == 3) { + localVertexPosition = float3(0, flowerHeight, 0) + back * depth; + } + + InsectVertex vertex; + vertex.objectSpacePosition = + float3(flowerPositionOffset.x, 0, flowerPositionOffset.y) + localVertexPosition; + + if (flowerVertexId == 0) { + vertex.color = flowerStemColor; + } else { + vertex.color = GetFlowerColor(flowerId, seed); + } + + ComputeClipSpacePositionAndMotion( + vertex, patchPosition + float3(flowerPositionOffset.x, 0, flowerPositionOffset.y) + localVertexPosition); + + verts[gtid] = vertex; + + } + + if (gtid < triangleCount) { + const int flowerId = gtid / sparseFlowerTriangleCount; + const int flowerTriangleId = gtid % sparseFlowerTriangleCount; + + const int flowerVertexOffset = flowerId * sparseFlowerVertexCount; + + tris[gtid] = flowerVertexOffset + ((flowerTriangleId & 0x1) ? uint3(0, 1, 2) : uint3(2, 1, 3)); + } +} \ No newline at end of file diff --git a/meshNodeSample/shaders/grasspixelshader.hlsl b/meshNodeSample/shaders/grasspixelshader.hlsl new file mode 100644 index 0000000..91fd2cd --- /dev/null +++ b/meshNodeSample/shaders/grasspixelshader.hlsl @@ -0,0 +1,48 @@ +// This file is part of the AMD Work Graph Mesh Node Sample. +// +// Copyright (c) 2024 Advanced Micro Devices, Inc. All rights reserved. +// +// 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 +// AUTHORS OR COPYRIGHT HOLDERS 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. + +#include "common.hlsl" + +DeferredPixelShaderOutput GrassPixelShader(const GrassVertex input, bool isFrontFace : SV_IsFrontFace) +{ + DeferredPixelShaderOutput output; + output.motion = input.clipSpaceMotion.xy; + + const float3 biomeWeights = GetBiomeWeights(input.worldSpacePosition.xz); + const float biomeFactor = lerp(1.0, 0.75, biomeWeights.y); + + float selfshadow = clamp(pow((input.worldSpacePosition.y - input.rootHeight) / input.height, 1.5), 0, 1); + output.baseColor.rgb = pow(float3(0.41, 0.44, 0.29) * 2, 2.2) * selfshadow * biomeFactor; + output.baseColor.rgb *= 0.75 + 0.25 * PerlinNoise2D(0.25 * input.worldSpacePosition.xz); + output.baseColor.a = 1; + + float3 normal = normalize(input.worldSpaceNormal); + + if (!isFrontFace) { + normal = -normal; + } + + float3 groundNormal = normalize(lerp(normalize(input.worldSpaceGroundNormal), float3(0, 1, 0), 0.5)); + output.normal.xyz = normalize(lerp(groundNormal, normal, 0.25)); + output.normal.w = 1.0; + + return output; +} \ No newline at end of file diff --git a/meshNodeSample/shaders/heightmap.hlsl b/meshNodeSample/shaders/heightmap.hlsl new file mode 100644 index 0000000..9d0235f --- /dev/null +++ b/meshNodeSample/shaders/heightmap.hlsl @@ -0,0 +1,121 @@ +// This file is part of the AMD Work Graph Mesh Node Sample. +// +// Copyright (c) 2024 Advanced Micro Devices, Inc. All rights reserved. +// +// 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 +// AUTHORS OR COPYRIGHT HOLDERS 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. + +#pragma once + +#include "utils.hlsl" + +// x = mountain +// y = woodland +// z = grassland +float3 GetBiomeWeights(in float2 position) +{ + const float2 pos = position * 0.01; + + float mountainFactor = 0; + mountainFactor += 1 * PerlinNoise2D(0.5 * pos); + mountainFactor += 2 * PerlinNoise2D(0.2 * pos + float2(38, 23)); + mountainFactor += 4 * PerlinNoise2D(0.1 * pos); + + float woodlandMountainFactor = 1.f - smoothstep(0, 1, 4 * pow(mountainFactor - 0.5, 2)); + woodlandMountainFactor = woodlandMountainFactor - pow(4 * PerlinNoise2D(0.1 * pos), 4); + mountainFactor = clamp(pow(clamp(mountainFactor, 0, 1), 2), 0, 1); + + float woodlandFactor = 0; + woodlandFactor += 1 * pow(4 * PerlinNoise2D(0.3 * pos), 3); + woodlandFactor += 5 * pow(1 * PerlinNoise2D(0.1 * pos), 2); + woodlandFactor = clamp(smoothstep(0, 1, woodlandFactor), 0, 1); + + woodlandFactor = smoothstep(0, 1, max(woodlandMountainFactor, woodlandFactor - mountainFactor)); + + float grasslandFactor = clamp(1 - (mountainFactor + woodlandFactor), 0, 1); + + return float3(mountainFactor, woodlandFactor, grasslandFactor); +} + +float GetTerrainHeight(in float2 pos) +{ + const float3 biomes = GetBiomeWeights(pos); + + // scale position down for low-frequency perlin noise + const float2 samplePosition = pos / 400.0; + + // Add multiple perlin noise layers to achieve base terrain height + float baseHeight = 0; + baseHeight += 1.0 * PerlinNoise2D(1.0 * samplePosition + float2(34, 98)); + baseHeight += 0.35 * PerlinNoise2D(2.0 * samplePosition + float2(73, 42)); + baseHeight += 0.25 * max(PerlinNoise2D(3.2 * samplePosition + float2(+0.5, -0.5)), + PerlinNoise2D(3.5 * samplePosition + float2(-0.5, +0.5))); + baseHeight += 0.15 * PerlinNoise2D(4.0 * samplePosition); + baseHeight += 0.08 * PerlinNoise2D(8.0 * samplePosition); + baseHeight += 0.07 * PerlinNoise2D(9.0 * samplePosition); + + // square height to make hills a bit more pronounced and scale to final height + float height = 140.0 * baseHeight * baseHeight; + + // Add additional high-frequency noise in mountain biome + float mountainHeight = 0; + mountainHeight += 0.97 * PerlinNoise2D(1.0 * samplePosition); + mountainHeight += 0.95 * max(PerlinNoise2D(2.8 * samplePosition + float2(+2.3, -4.5)), + PerlinNoise2D(3.1 * samplePosition + float2(-6.5, +3.6))); + mountainHeight += 0.75 * PerlinNoise2D(2.0 * samplePosition + float2(34, 56)); + + height += 70.0 * mountainHeight * mountainHeight * smoothstep(0.5, 1.0, biomes.x); + + // raise mountain biome up + height += 40.0 * smoothstep(0.0, 1.0, biomes.x); + + return height; +} + +float GetTerrainHeight(in float x, in float y) +{ + return GetTerrainHeight(float2(x, y)); +} + +float3 GetTerrainPosition(in float x, in float z) +{ + return float3(x, GetTerrainHeight(x, z), z); +} + +float3 GetTerrainPosition(in float2 pos) +{ + return float3(pos.x, GetTerrainHeight(pos.x, pos.y), pos.y); +} + +float3 GetTerrainNormal(in float x, in float z) +{ + const float height = GetTerrainHeight(x, z); + + static const float h = 0.01; + float dx = (height - GetTerrainHeight(x + h, z)); + float dz = (height - GetTerrainHeight(x, z + h)); + + float3 a = normalize(float3(h, -dx, 0)); + float3 b = normalize(float3(0, -dz, h)); + + return normalize(cross(b, a)); +} + +float3 GetTerrainNormal(in float2 pos) +{ + return GetTerrainNormal(pos.x, pos.y); +} \ No newline at end of file diff --git a/meshNodeSample/shaders/insectpixelshader.hlsl b/meshNodeSample/shaders/insectpixelshader.hlsl new file mode 100644 index 0000000..dd3650e --- /dev/null +++ b/meshNodeSample/shaders/insectpixelshader.hlsl @@ -0,0 +1,37 @@ +// This file is part of the AMD Work Graph Mesh Node Sample. +// +// Copyright (c) 2024 Advanced Micro Devices, Inc. All rights reserved. +// +// 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 +// AUTHORS OR COPYRIGHT HOLDERS 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. + +#include "common.hlsl" + +DeferredPixelShaderOutput InsectPixelShader(const InsectVertex input) +{ + DeferredPixelShaderOutput output; + + output.motion = input.clipSpaceMotion.xy; + output.baseColor.rgb = input.color.rgb; + output.baseColor.a = 1.f; + + // compute normal from object space position derivatives + output.normal.xyz = normalize(cross(ddy(input.objectSpacePosition.xyz), ddx(input.objectSpacePosition.xyz))); + output.normal.w = 1.0; + + return output; +} \ No newline at end of file diff --git a/meshNodeSample/shaders/mushroommeshshader.hlsl b/meshNodeSample/shaders/mushroommeshshader.hlsl new file mode 100644 index 0000000..12827ff --- /dev/null +++ b/meshNodeSample/shaders/mushroommeshshader.hlsl @@ -0,0 +1,256 @@ +// This file is part of the AMD Work Graph Mesh Node Sample. +// +// Copyright (c) 2024 Advanced Micro Devices, Inc. All rights reserved. +// +// 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 +// AUTHORS OR COPYRIGHT HOLDERS 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. + +#include "common.hlsl" + +struct ShroomType { + int hatPoints; + int stemPoints; + + float hatRingInnerRadius; + float hatRingOuterRadius; + float stemRingRadius; + + float hatRingInnerDepth; + float hatRingOuterDepth; + + float hatTilt; + float shroomCountBiasPow; + float positionNoise; + + float3 stemColor; + float3 hatColor; +}; + +// Mushroom definitions +static const int numShroomTypes = 2; +static const ShroomType shroomTypes[numShroomTypes] = { // + { + // brown shroom + 7, // int hatPoints; + 5, // int stemPoints; + .25, // float hatRingInnerRadius; + .4, // float hatRingOuterRadius; + .1, // float stemRingRadius; + .075, // float hatRingInnerDepth; + .25, // float hatRingOuterDepth; + .65, // float hatTilt; + 1, // float shroomCountBiasPow; + .025, // float positionNoise; + float3(0.33, 0.21, 0.14) * .8, // float3 stemColor + float3(0.33, 0.21, 0.14) * .8 // float3 hatColor + }, + { + // red shroom + 8, // int hatPoints; + 5, // int stemPoints; + .25, // float hatRingInnerRadius; + .4, // float hatRingOuterRadius; + .1, // float stemRingRadius; + .05, // float hatRingInnerDepth; + .15, // float hatRingOuterDepth; + .1, // float hatTilt; + 1, // float shroomCountBiasPow; + .025, // float positionNoise; + float3(1, 1, 1) * .6, // float3 stemColor + float3(.225, 0.05, 0.) * .5 // float3 hatColor + }, +}; + +static const float radiusMin = 0.2; +static const float radiusV = 0.2; +static const float scale = .6; + +static const int mushroomGroupSize = 128; +static const int numOutputVerticesLimit = 256; +static const int numOutputTrianglesLimit = 192; + +static const int numOutputVertexIterations = (numOutputVerticesLimit + (mushroomGroupSize - 1)) / mushroomGroupSize; +static const int numOutputTriangleIterations = (numOutputTrianglesLimit + (mushroomGroupSize - 1)) / mushroomGroupSize; + +[Shader("node")] +[NodeLaunch("mesh")] +[NodeId("DrawMushroomPatch", 0)] +[NodeMaxDispatchGrid(maxMushroomsPerRecord, 1, 1)] +// This limit was set through instrumentation and is not required on AMD GPUs. +// If you wish to change any of the procedural generation parameters, +// and you are running on a non-AMD GPU, you may need to adjust this limit. +// You can learn more at: +// https://gpuopen.com/learn/work_graphs_mesh_nodes/work_graphs_mesh_nodes-tips_tricks_best_practices +[NodeMaxInputRecordsPerGraphEntryRecord(50, true)] +[NumThreads(mushroomGroupSize, 1, 1)] +[OutputTopology("triangle")] +void MushroomMeshShader( + uint gtid : SV_GroupThreadID, + uint gid : SV_GroupID, + DispatchNodeInputRecord inputRecord, + out indices uint3 tris[numOutputTrianglesLimit], + out vertices InsectVertex verts[numOutputVerticesLimit]) +{ + const float3 patchCenter = inputRecord.Get().position[gid]; + + const int seed = CombineSeed(asuint(patchCenter.x), asuint(patchCenter.z)); + + const int shroomType = numShroomTypes * Random(seed, 11002); + + const int vertsPerStem = 2 * shroomTypes[shroomType].stemPoints; + const int vertsPerHat = 2 * shroomTypes[shroomType].hatPoints + 1; + const int vertsPerShroom = vertsPerStem + vertsPerHat; + + const int trisPerStem = 2 * shroomTypes[shroomType].stemPoints; + const int trisPerHat = 3 * shroomTypes[shroomType].hatPoints; + const int trisPerShroom = trisPerStem + trisPerHat; + + const int maxNumShrooms = min(numOutputVerticesLimit / vertsPerShroom, numOutputTrianglesLimit / trisPerShroom); + + const float radiusLookup[5] = { + shroomTypes[shroomType].stemRingRadius, + shroomTypes[shroomType].stemRingRadius, + 0., + shroomTypes[shroomType].hatRingInnerRadius, + shroomTypes[shroomType].hatRingOuterRadius, + }; + const float heightLookup[5] = { + 0., + 0.1, + .2, + .2 - shroomTypes[shroomType].hatRingInnerDepth, + .2 - shroomTypes[shroomType].hatRingOuterDepth, + }; + + + const int numShrooms = + min(maxNumShrooms, 1 + maxNumShrooms * pow(Random(seed, 99990001), shroomTypes[shroomType].shroomCountBiasPow)); + + const int vertexCount = numShrooms * vertsPerShroom; + const int triangleCount = numShrooms * trisPerShroom; + + SetMeshOutputCounts(vertexCount, triangleCount); + + [[unroll]] + for (int i = 0; i < numOutputTriangleIterations; ++i) + { + const int triId = gtid + mushroomGroupSize * i; + + if (triId < triangleCount) { + const int shroomIdx = triId / trisPerShroom; + int ti = triId % trisPerShroom; + + const bool isHat = ti < trisPerHat; + + if (!isHat) { + ti -= trisPerHat; + } + + const int points = isHat ? shroomTypes[shroomType].hatPoints : shroomTypes[shroomType].stemPoints; + const int ring = ti / points; + + const int baseVertex = isHat ? (1 + (ring == 2) * points) : (vertsPerHat + ring * points); + + const int vi = ti - ring * points; + + const int a = baseVertex + vi; + const int b = baseVertex + ((vi + 1) % points); + int c = (ring == 1) ? b : a; + c += ((ring == 1) ^ !isHat) ? points : -points; + c = max(c, 0); + + tris[triId] = shroomIdx * vertsPerShroom + uint3(a, b, c); + } + } + + [[unroll]] + for (int i = 0; i < numOutputVertexIterations; ++i) + { + const int vertId = gtid + mushroomGroupSize * i; + + if (vertId < vertexCount) { + const int shroomIdx = vertId / vertsPerShroom; + int vi = vertId % vertsPerShroom; + float3 pos = float3(0, 0, 0); + bool isHat = vi < vertsPerHat; + + vi -= (!isHat) * vertsPerHat; + + int points = isHat ? shroomTypes[shroomType].hatPoints : shroomTypes[shroomType].stemPoints; + + int ring = (vi + (shroomTypes[shroomType].hatPoints - 1) * isHat) / points; + + float angle = frac((vi - isHat) / float(points)); + + angle += (isHat && ring == 2) * -1. / (2 * points); + + angle *= 2 * PI; + + float radius = radiusLookup[2 * isHat + ring]; + + pos.x += radius * cos(angle); + pos.y += heightLookup[2 * isHat + ring]; + pos.z += radius * sin(angle); + + float theta = 2 * PI * shroomIdx / numShrooms + .1 * Random(seed, shroomIdx) * PI * 2; + float rad = sqrt(Random(seed, 19, shroomIdx)) * shroomTypes[shroomType].hatTilt; + + float3 offset = float3(sin(theta), 0, cos(theta)); + float3 dir = rad * offset; + + dir.y = sqrt(1 - dir.x * dir.x - dir.z * dir.z); + + float3x3 rotation; + rotation[0] = normalize(cross(dir, float3(0, 0, 1))); + rotation[1] = dir; + rotation[2] = normalize(cross(rotation[0], dir)); + rotation[0] = normalize(cross(dir, rotation[2])); + + if (isHat) { + // add a little bit of noise + pos.x += shroomTypes[shroomType].positionNoise * (2. * Random(vertId, 0xFEFA, seed) - 1.); + pos.y += shroomTypes[shroomType].positionNoise * (2. * Random(vertId, 0xFEFB, seed) - 1.); + pos.z += shroomTypes[shroomType].positionNoise * (2. * Random(vertId, 0xFEFC, seed) - 1.); + + pos = mul(transpose(rotation), pos); + } + + float r = Random(seed, 877, shroomIdx); + + float distance = radiusMin + radiusV * r; + + static const float heightMin = .5; + static const float heightV = 1.; + if (isHat || ring == 1) { + pos.y += heightMin + heightV * (1 - r); + } + + InsectVertex vertex; + vertex.color.rgb = isHat ? shroomTypes[shroomType].hatColor : shroomTypes[shroomType].stemColor; + if (!isHat && ring == 0) { + vertex.color.xyz *= .1; + } + vertex.color.rgb *= 3.5; + + vertex.objectSpacePosition = scale * pos + distance * offset; + + ComputeClipSpacePositionAndMotion(vertex, patchCenter + vertex.objectSpacePosition); + + verts[vertId] = vertex; + } + } +} \ No newline at end of file diff --git a/meshNodeSample/shaders/rock.hlsl b/meshNodeSample/shaders/rock.hlsl new file mode 100644 index 0000000..7354f94 --- /dev/null +++ b/meshNodeSample/shaders/rock.hlsl @@ -0,0 +1,92 @@ +// This file is part of the AMD Work Graph Mesh Node Sample. +// +// Copyright (c) 2024 Advanced Micro Devices, Inc. All rights reserved. +// +// 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 +// AUTHORS OR COPYRIGHT HOLDERS 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. + +#include "common.hlsl" + +// Rock generation is single-threaded, this we use a coalescing node to generate multiple rocks in parallel. +// Rocks are rendered with the same spline mesh node as the trees. +[Shader("node")] +[NodeLaunch("coalescing")] +[NumThreads(maxSplinesPerRecord, 1, 1)] +void GenerateRock( + [MaxRecords(maxSplinesPerRecord)] + GroupNodeInputRecords inputRecord, + + uint threadId : SV_GroupThreadID, + + [MaxRecords(1)] + [NodeId("DrawSpline")] + NodeOutput output) +{ + GroupNodeOutputRecords outputRecord = output.GetGroupNodeOutputRecords(1); + + outputRecord.Get().dispatchGrid = uint3(inputRecord.Count(), 1, 1); + + if (threadId < inputRecord.Count()) { + const float2 basePositionXZ = inputRecord.Get(threadId).position; + const uint seed = CombineSeed(asuint(basePositionXZ.x), asuint(basePositionXZ.y)); + + const float3 basePosition = GetTerrainPosition(basePositionXZ); + const float3 terrainNormal = GetTerrainNormal(basePositionXZ); + const float3 basePositionUp = lerp(float3(0, 1, 0), terrainNormal, 1 + Random(seed, 456) * 0.5); + + const float rotationAngle = Random(seed, 14658) * 2 * PI; + + const float upScale = lerp(0.5, 1.2, Random(seed, 546)); + const float a = 1.05f + Random(seed, 6514); + const float2 sideScale = lerp(0.6, 5.0, Random(seed, 9487)) * float2(a, 1); + + const float f = 1.05f + Random(seed, 1564); + const float c = lerp(0.5, 0.9, Random(seed, 49827)); + + outputRecord.Get(0).color[threadId] = float3(0.1, 0.1, 0.1) * 3.5; + outputRecord.Get(0).rotationOffset[threadId] = rotationAngle; + outputRecord.Get(0).windStrength[threadId] = 0; + outputRecord.Get(0).controlPointCount[threadId] = 4; + + int controlPointIndex = threadId * splineMaxControlPointCount; + + outputRecord.Get(0).controlPointPositions[controlPointIndex] = basePosition - terrainNormal; + outputRecord.Get(0).controlPointVertexCounts[controlPointIndex] = 1; + outputRecord.Get(0).controlPointRadii[controlPointIndex] = 0; + outputRecord.Get(0).controlPointNoiseAmplitudes[controlPointIndex] = 0.0; + controlPointIndex++; + + outputRecord.Get(0).controlPointPositions[controlPointIndex] = basePosition; + outputRecord.Get(0).controlPointVertexCounts[controlPointIndex] = round(lerp(5, 7, Random(seed, 4145))); + outputRecord.Get(0).controlPointRadii[controlPointIndex] = sideScale; + outputRecord.Get(0).controlPointNoiseAmplitudes[controlPointIndex] = 0.5 * upScale; + controlPointIndex++; + + outputRecord.Get(0).controlPointPositions[controlPointIndex] = basePosition + upScale * basePositionUp; + outputRecord.Get(0).controlPointVertexCounts[controlPointIndex] = round(lerp(5, 7, Random(seed, 4578))); + outputRecord.Get(0).controlPointRadii[controlPointIndex] = c * sideScale; + outputRecord.Get(0).controlPointNoiseAmplitudes[controlPointIndex] = 0.5 * upScale; + controlPointIndex++; + + outputRecord.Get(0).controlPointPositions[controlPointIndex] = basePosition + f * upScale * basePositionUp; + outputRecord.Get(0).controlPointVertexCounts[controlPointIndex] = 1; + outputRecord.Get(0).controlPointRadii[controlPointIndex] = Random(seed, 89514); + outputRecord.Get(0).controlPointNoiseAmplitudes[controlPointIndex] = 0; + } + + outputRecord.OutputComplete(); +} \ No newline at end of file diff --git a/meshNodeSample/shaders/shading.hlsl b/meshNodeSample/shaders/shading.hlsl new file mode 100644 index 0000000..88f39a6 --- /dev/null +++ b/meshNodeSample/shaders/shading.hlsl @@ -0,0 +1,74 @@ +// This file is part of the AMD Work Graph Mesh Node Sample. +// +// Copyright (c) 2024 Advanced Micro Devices, Inc. All rights reserved. +// +// 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 +// AUTHORS OR COPYRIGHT HOLDERS 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. + +#include "fullscreen.hlsl" +#include "shadingcommon.h" +#include "upscaler.h" +#include "skybox.hlsl" + +//-------------------------------------------------------------------------------------- +// Texture definitions +//-------------------------------------------------------------------------------------- +RWTexture2D RenderTarget : register(u0); + +Texture2D BaseColor : register(t0); +Texture2D Normal : register(t1); + +//-------------------------------------------------------------------------------------- +// Main function +//-------------------------------------------------------------------------------------- +[numthreads(s_shadingThreadGroupSizeX, s_shadingThreadGroupSizeY, 1)] + +void MainCS(uint3 dtID : SV_DispatchThreadID) +{ + if (any(dtID.xy > UpscalerInfo.FullScreenScaleRatio.xy)) { + return; + } + + const float2 uv = GetUV(dtID.xy, 1.f / UpscalerInfo.FullScreenScaleRatio.xy); + const float3 clip = float3(2 * uv.x - 1, 1 - 2 * uv.y, 1); + const float3 viewDirection = normalize(PerspectiveProject(InverseViewProjection, clip) - CameraPosition.xyz); + + const LightingData lightingData = GetLightingData(); + + const float4 baseColor = BaseColor[dtID.xy]; + + if (baseColor.a < 0.5) { + RenderTarget[dtID.xy] = float4(GetSkyboxColor(viewDirection, lightingData), 1); + + return; + } + + const float3 normal = Normal[dtID.xy]; + + // Ambient + const float sunZenithDot = lightingData.sunDirection.y; + const float sunZenithDot01 = (sunZenithDot + 1.0) * 0.5; + const float3 ambientContrib = baseColor.rgb * 0.2 * saturate(pow(dot(normal, -viewDirection), .25)) * 1 * + (skybox::SunZenith_Gradient(0.5) + skybox::ViewZenith_Gradient(sunZenithDot01)); + + // Diffuse + const float3 diffuseContrib = saturate(dot(normal, lightingData.globalLightDirection)); + + float3 color = ambientContrib + diffuseContrib * baseColor.rgb; + + RenderTarget[dtID.xy] = float4(color.rgb, 1); +} \ No newline at end of file diff --git a/meshNodeSample/shaders/shadingcommon.h b/meshNodeSample/shaders/shadingcommon.h new file mode 100644 index 0000000..47ff90b --- /dev/null +++ b/meshNodeSample/shaders/shadingcommon.h @@ -0,0 +1,44 @@ +// This file is part of the AMD Work Graph Mesh Node Sample. +// +// Copyright (c) 2024 Advanced Micro Devices, Inc. All rights reserved. +// +// 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 +// AUTHORS OR COPYRIGHT HOLDERS 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. + +#pragma once + +#if __cplusplus +#include "misc/math.h" +#endif // __cplusplus + +static const unsigned int s_shadingThreadGroupSizeX = 8; +static const unsigned int s_shadingThreadGroupSizeY = 8; + +#if __cplusplus +struct ShadingCBData +{ + Mat4 InverseViewProjection; + Vec4 CameraPosition; +}; +#else +// Fullscreen.hlsl binds to b0, so contants need to start at b1 if using fullscreen.hlsl +cbuffer ShadingCBData : register(b1) +{ + matrix InverseViewProjection; + float4 CameraPosition; +} +#endif // __cplusplus \ No newline at end of file diff --git a/meshNodeSample/shaders/skybox.hlsl b/meshNodeSample/shaders/skybox.hlsl new file mode 100644 index 0000000..5693ea8 --- /dev/null +++ b/meshNodeSample/shaders/skybox.hlsl @@ -0,0 +1,255 @@ +// This file is part of the AMD Work Graph Mesh Node Sample. +// +// Copyright (c) 2024 Advanced Micro Devices, Inc. All rights reserved. +// +// 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 +// AUTHORS OR COPYRIGHT HOLDERS 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. + +#pragma once + +#include "shadingcommon.h" +#include "utils.hlsl" + +// namespace contains skybox lookup gradients based on the lookup textures from https://kelvinvanhoorn.com/2022/03/17/skybox-tutorial-part-1/ +namespace skybox { + + + float SunZenith_Gradient_b(float x) + { + const int count = 5; + const float xs[count] = { 0.0, 0.375, 0.515625, 0.625, 0.9921875 }; + const float ys[count] = { + 0.09119905696129081, 0.17743197428764693, 0.5457624421381186, 0.8458267513775317, 0.8470588235294116 }; + for (int i = 0; i < (count - 1); ++i) { + if (xs[i] <= x && x < xs[i + 1]) { + float t = (x - xs[i]) / (xs[i + 1] - xs[i]); + return lerp(ys[i], ys[i + 1], smoothstep(0., 1., t)); + } + } + return ys[count - 1]; + } + + float SunZenith_Gradient_g(float x) + { + const int count = 4; + const float xs[count] = { 0.0, 0.3828125, 0.6171875, 0.9921875 }; + const float ys[count] = { 0.055852483484183674, 0.1324827899848155, 0.678304263482747, 0.5670582583360976 }; + for (int i = 0; i < (count - 1); ++i) { + if (xs[i] <= x && x < xs[i + 1]) { + float t = (x - xs[i]) / (xs[i + 1] - xs[i]); + return lerp(ys[i], ys[i + 1], smoothstep(0., 1., t)); + } + } + return ys[count - 1]; + } + + float SunZenith_Gradient_r(float x) + { + const int count = 4; + const float xs[count] = { 0.0, 0.375, 0.6171875, 0.9921875 }; + const float ys[count] = { 0.05266772050977707, 0.0846283802271616, 0.37306694022972375, 0.2979585185575305 }; + for (int i = 0; i < (count - 1); ++i) { + if (xs[i] <= x && x < xs[i + 1]) { + float t = (x - xs[i]) / (xs[i + 1] - xs[i]); + return lerp(ys[i], ys[i + 1], smoothstep(0., 1., t)); + } + } + return ys[count - 1]; + } + + float3 SunZenith_Gradient(float x) + { + return float3(SunZenith_Gradient_r(x), SunZenith_Gradient_g(x), SunZenith_Gradient_b(x)); + } + + float ViewZenith_Gradient_b(float x) + { + const int count = 6; + const float xs[count] = { 0.0, 0.375, 0.484375, 0.5390625, 0.6484375, 0.9921875 }; + const float ys[count] = { 0.020563663948531673, + 0.3419597608904451, + 0.04161602600815216, + 0.1095349428231567, + 0.8149446289251109, + 0.9900099167444902 }; + for (int i = 0; i < (count - 1); ++i) { + if (xs[i] <= x && x < xs[i + 1]) { + float t = (x - xs[i]) / (xs[i + 1] - xs[i]); + return lerp(ys[i], ys[i + 1], smoothstep(0., 1., t)); + } + } + return ys[count - 1]; + } + + float ViewZenith_Gradient_g(float x) + { + const int count = 5; + const float xs[count] = { 0.0, 0.359375, 0.53125, 0.6171875, 0.9921875 }; + const float ys[count] = { + 0.010815067628993518, 0.19845916353774884, 0.5742594966049783, 0.7342900528103369, 0.748949825687303 }; + for (int i = 0; i < (count - 1); ++i) { + if (xs[i] <= x && x < xs[i + 1]) { + float t = (x - xs[i]) / (xs[i + 1] - xs[i]); + return lerp(ys[i], ys[i + 1], smoothstep(0., 1., t)); + } + } + return ys[count - 1]; + } + + float ViewZenith_Gradient_r(float x) + { + const int count = 6; + const float xs[count] = { 0.0, 0.359375, 0.4921875, 0.59375, 0.640625, 0.9921875 }; + const float ys[count] = { 0.009057957120245073, + 0.15106019459324935, + 0.9180293234405212, + 0.47611197653854354, + 0.5406124274378104, + 0.500948270549165 }; + for (int i = 0; i < (count - 1); ++i) { + if (xs[i] <= x && x < xs[i + 1]) { + float t = (x - xs[i]) / (xs[i + 1] - xs[i]); + return lerp(ys[i], ys[i + 1], smoothstep(0., 1., t)); + } + } + return ys[count - 1]; + } + + float3 ViewZenith_Gradient(float x) + { + return float3(ViewZenith_Gradient_r(x), ViewZenith_Gradient_g(x), ViewZenith_Gradient_b(x)); + } + + float SunView_Gradient_b(float x) + { + const int count = 5; + const float xs[count] = { 0.0, 0.4765625, 0.6328125, 0.984375, 0.9921875 }; + const float ys[count] = { + 0.0, 0.025240814536934993, 0.35683113031269376, 0.6095478205423517, 0.6113290117056305 }; + for (int i = 0; i < (count - 1); ++i) { + if (xs[i] <= x && x < xs[i + 1]) { + float t = (x - xs[i]) / (xs[i + 1] - xs[i]); + return lerp(ys[i], ys[i + 1], smoothstep(0., 1., t)); + } + } + return ys[count - 1]; + } + + float SunView_Gradient_g(float x) + { + const int count = 5; + const float xs[count] = { 0.0, 0.3828125, 0.515625, 0.6171875, 0.9921875 }; + const float ys[count] = { + 0.0038584077592145796, 0.11097681754988054, 0.7754699617187375, 0.5145669601324688, 0.6615264387746628 }; + for (int i = 0; i < (count - 1); ++i) { + if (xs[i] <= x && x < xs[i + 1]) { + float t = (x - xs[i]) / (xs[i + 1] - xs[i]); + return lerp(ys[i], ys[i + 1], smoothstep(0., 1., t)); + } + } + return ys[count - 1]; + } + + float SunView_Gradient_r(float x) + { + const int count = 5; + const float xs[count] = { 0.0, 0.3828125, 0.515625, 0.6328125, 0.9921875 }; + const float ys[count] = { + 0.005119371666456357, 0.147390195920971, 0.9702326103489829, 0.26112308728542827, 0.39095905970609257 }; + for (int i = 0; i < (count - 1); ++i) { + if (xs[i] <= x && x < xs[i + 1]) { + float t = (x - xs[i]) / (xs[i + 1] - xs[i]); + return lerp(ys[i], ys[i + 1], smoothstep(0., 1., t)); + } + } + return ys[count - 1]; + } + + float3 SunView_Gradient(float x) + { + return float3(SunView_Gradient_r(x), SunView_Gradient_g(x), SunView_Gradient_b(x)); + } + +} // namespace skybox + +struct LightingData { + float3 sunDirection; + float3 moonDirection; + + float3 globalLightDirection; +}; + +LightingData GetLightingData() +{ + LightingData result; + + const float southAngle = ToRadians(0.0); + const float latitude = ToRadians(0.0); + const float timeOfDay = 12.0; + + const float3 up = float3(0, 1, 0); + const float3 south = float3(cos(southAngle), 0, sin(southAngle)); + + const float3 right = normalize(cross(south, up)); + + const float sunAngle = (timeOfDay / 24.f) * 2 * PI; + + const float3 sunVector = -cos(sunAngle) * up + -sin(sunAngle) * right; + result.sunDirection = normalize(cos(latitude) * sunVector + sin(latitude) * south); + result.moonDirection = normalize(cos(latitude) * -sunVector + sin(latitude) * -south); + + result.globalLightDirection = (result.sunDirection.y < 0) ? result.moonDirection : result.sunDirection; + + return result; +} + +// Skybox based on https://kelvinvanhoorn.com/2022/03/17/skybox-tutorial-part-1/ +float3 GetSkyboxColor(in float3 direction, in LightingData lightingData) +{ + const float sunViewDot = dot(lightingData.sunDirection, direction); + const float moonViewDot = dot(lightingData.moonDirection, direction); + const float sunZenithDot = lightingData.sunDirection.y; + const float viewZenithDot = direction.y; + const float sunMoonDot = dot(lightingData.sunDirection, lightingData.moonDirection); + + float sunViewDot01 = (sunViewDot + 1.0) * 0.5; + float sunZenithDot01 = (sunZenithDot + 1.0) * 0.5; + + float3 sunZenithColor = skybox::SunZenith_Gradient(sunZenithDot01); + + float3 viewZenithColor = skybox::ViewZenith_Gradient(sunZenithDot01) ; + float vzMask = pow(saturate(1.0 - viewZenithDot), 4); + + float3 sunViewColor = skybox::SunView_Gradient(sunZenithDot01) * 0.7; + float svMask = pow(saturate(sunViewDot), 4); + + float3 skyColor = sunZenithColor + vzMask * viewZenithColor + svMask * sunViewColor; + + const float sunRadius = 0.05; + const float sunMask = step(1 - (sunRadius * sunRadius), sunViewDot); + const float sunVisible = clamp((lightingData.sunDirection.y + 5 * sunRadius) / (5 * sunRadius), 0, 1); + + const float3 sunColor = sunMask * sunVisible; + + const float moonRadius = 0.03; + const float moonMask = step(1 - (moonRadius * moonRadius), moonViewDot); + const float moonVisible = clamp((lightingData.moonDirection.y + 5 * moonRadius) / (5 * moonRadius), 0, 1); + + const float3 moonColor = moonMask * moonVisible; + + return skyColor + sunColor + moonColor; +} \ No newline at end of file diff --git a/meshNodeSample/shaders/sparsegrassmeshshader.hlsl b/meshNodeSample/shaders/sparsegrassmeshshader.hlsl new file mode 100644 index 0000000..c82a7e8 --- /dev/null +++ b/meshNodeSample/shaders/sparsegrassmeshshader.hlsl @@ -0,0 +1,145 @@ +// This file is part of the AMD Work Graph Mesh Node Sample. +// +// Copyright (c) 2024 Advanced Micro Devices, Inc. All rights reserved. +// +// 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 +// AUTHORS OR COPYRIGHT HOLDERS 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. + +#include "common.hlsl" + +static const int sparseGrassGroupSize = 128; +static const int numOutputVerticesLimit = 128; +static const int numOutputTrianglesLimit = 64; + +// multiple 8x4 patches fill a detailed tile +static const int2 sparseGrassThreadGroupGridSize = int2(8, 4); +static const int2 spraseGrassThreadGroupsPerAxis = grassPatchesPerDetailedTile / sparseGrassThreadGroupGridSize; + +float2 GetPatchPosition(in int patch, in int patchOffset, in int2 gridBase) +{ + const int x = patch % sparseGrassThreadGroupGridSize.x; + const int z = patch / sparseGrassThreadGroupGridSize.x; + + const int offsetX = patchOffset % spraseGrassThreadGroupsPerAxis.x; + const int offsetZ = patchOffset / spraseGrassThreadGroupsPerAxis.x; + + const int2 grid = int2(x, z) + int2(offsetX, offsetZ) * sparseGrassThreadGroupGridSize; + + return grassSpacing * gridBase + + (grid + GetGrassOffset(gridBase + grid)) * grassSpacing * (8.0 / sparseGrassThreadGroupGridSize.x); +} + + +[Shader("node")] +[NodeLaunch("mesh")] +[NodeId("DrawSparseGrassPatch", 0)] +[NodeMaxDispatchGrid(maxSparseGrassPatchesPerRecord, sparseGrassThreadGroupsPerRecord, 1)] +// This limit was set through instrumentation and is not required on AMD GPUs. +// If you wish to change any of the procedural generation parameters, +// and you are running on a non-AMD GPU, you may need to adjust this limit. +// You can learn more at: +// https://gpuopen.com/learn/work_graphs_mesh_nodes/work_graphs_mesh_nodes-tips_tricks_best_practices +[NodeMaxInputRecordsPerGraphEntryRecord(100, true)] +[NumThreads(sparseGrassGroupSize, 1, 1)] +[OutputTopology("triangle")] +void SparseGrassMeshShader( + uint gtid : SV_GroupThreadID, + uint2 gid : SV_GroupID, + DispatchNodeInputRecord inputRecord, + out indices uint3 tris[numOutputTrianglesLimit], + out primitives GrassCullPrimitive prims[numOutputTrianglesLimit], + out vertices GrassVertex verts[numOutputVerticesLimit]) +{ + const int bladeCount = sparseGrassThreadGroupGridSize.x * sparseGrassThreadGroupGridSize.y; + // 4 vertices per blade + const int vertexCount = bladeCount * 4; + // 2 triangles per blade + const int triangleCount = bladeCount * 2; + + SetMeshOutputCounts(vertexCount, triangleCount); + + GrassVertex vertex; + + float low = .05; + float high = .45; + + float3 color = pow(float3(0.41, 0.44, 0.29), 2.2) * .775; + + const int2 gridBase = inputRecord.Get().position[gid.x] * grassPatchesPerDetailedTile; + + static const float3 grassColor = float3(0.130139, 0.149961, 0.059513); + + if (gtid < vertexCount) { + int vertexId = gtid; + int patch = vertexId / 4; + int vi = vertexId % 4; + bool isLow = vi == 0 || vi == 1; + bool isRight = vi == 0 || vi == 2; + + const float2 pos = GetPatchPosition(patch, gid.y, gridBase); + + float3 patchNormal = GetTerrainNormal(pos); + + float3 center = float3(pos.x, GetTerrainHeight(pos), pos.y); + + // Fade grass into the ground in the distance + const float distanceScale = smoothstep(sparseGrassMaxDistance * 0.9, sparseGrassMaxDistance, distance(center, GetCameraPosition())); + center.y -= high * distanceScale; + + float3 center2cam = normalize(GetCameraPosition() - center); + + float3 forward = normalize(float3(center2cam.x, min(0.2, center2cam.y), center2cam.z)); + float3 right = normalize(cross(center2cam, float3(0, 1, 0))); + + float3 up = normalize(cross(right, forward)); + + vertex.worldSpacePosition = center; + vertex.worldSpacePosition += right * BitSign((uint)isRight, 0) * grassSpacing; + vertex.worldSpacePosition += up * (isLow ? (low) : high); + + vertex.worldSpacePosition.xz += center2cam.xz * (length(center2cam) / 1000.); + vertex.worldSpacePosition.y = center.y + (isLow ? (low + center2cam.y * 0.2) : high); + + vertex.rootHeight = center.y + .08; + vertex.height = high; + vertex.worldSpaceNormal = isLow ? normalize(float3(center2cam.x, 0, center2cam.z)) : float3(0, 1, 0); + vertex.worldSpaceGroundNormal = patchNormal; + + ComputeClipSpacePositionAndMotion(vertex, vertex.worldSpacePosition); + + verts[vertexId] = vertex; + } + + if (gtid < triangleCount) { + const int patch = gtid / 2; + const int base = 4 * patch; + + const float2 pos = GetPatchPosition(patch, gid.y, gridBase); + const float3 center = float3(pos.x, GetTerrainHeight(pos), pos.y); + + const float3 terrainNormal = GetTerrainNormal(pos); + const float3 biomeWeight = GetBiomeWeights(pos); + + const bool cull = (Random(asuint(pos.x), asuint(pos.y), 2378) < biomeWeight.x * 2) || + (terrainNormal.y < 0.55); + + uint3 tri = (gtid % 2) == 0 ? uint3(base, base + 1, base + 2) : uint3(base + 3, base + 2, base + 1); + + tris[gtid] = tri; + prims[gtid].cull = cull; + } +} \ No newline at end of file diff --git a/meshNodeSample/shaders/splinerenderer.hlsl b/meshNodeSample/shaders/splinerenderer.hlsl new file mode 100644 index 0000000..98f7a55 --- /dev/null +++ b/meshNodeSample/shaders/splinerenderer.hlsl @@ -0,0 +1,333 @@ +// This file is part of the AMD Work Graph Mesh Node Sample. +// +// Copyright (c) 2024 Advanced Micro Devices, Inc. All rights reserved. +// +// 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 +// AUTHORS OR COPYRIGHT HOLDERS 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. + +#include "common.hlsl" + +struct TransformedVertex { + float4 clipSpacePosition : SV_POSITION; + float3 objectSpacePosition : NORMAL0; + float2 clipSpaceMotion : TEXCOORD0; + float3 color : NORMAL1; +}; + +// Returns number of line sections in a vertex ring +int GetRingSectionCount(in int ringVertexCount) { + return ringVertexCount == 1 ? 0 : ringVertexCount; +} + +static const int splineGroupSize = 128; +static const int numOutputVerticesLimit = 64; +static const int numOutputTrianglesLimit = 128; + +[Shader("node")] +[NodeLaunch("mesh")] +[NodeId("DrawSpline", 0)] +[NodeMaxDispatchGrid(maxSplinesPerRecord, 1, 1)] +// This limit was set through instrumentation and is not required on AMD GPUs. +// If you wish to change any of the procedural generation parameters, +// and you are running on a non-AMD GPU, you may need to adjust this limit. +// You can learn more at: +// https://gpuopen.com/learn/work_graphs_mesh_nodes/work_graphs_mesh_nodes-tips_tricks_best_practices +[NodeMaxInputRecordsPerGraphEntryRecord(10000, true)] +[NumThreads(splineGroupSize, 1, 1)] +[OutputTopology("triangle")] +void SplineMeshShader( + uint threadId : SV_GroupThreadID, + uint gid : SV_GroupID, + DispatchNodeInputRecord inputRecord, + out indices uint3 tris[numOutputTrianglesLimit], + out vertices TransformedVertex verts[numOutputVerticesLimit]) +{ + const uint splineControlPointCount = clamp(inputRecord.Get().controlPointCount[gid], 0, splineMaxControlPointCount); + const uint splineSectionCount = clamp(int(splineControlPointCount) - 1, 0, splineMaxControlPointCount - 1); + + const uint controlPointOffset = gid * splineMaxControlPointCount; + + uint vertexOutputCount = 0; + uint primitiveOutputCount = 0; + + // control point for which the current thread will create a vertex + int threadVertexControlPoint = 0; + // index on control point ring which the current thread will generate + int threadVertexControlPointVertex = 0; + + // control point section for which the current thread will create a triangle + int threadPrimitiveSection = 0; + // index on control point ring which the current thread will generate + int threadPrimitiveSectionTriangle = 0; + int threadPrimitiveSectionVertexOffset = 0; + + { + // Number of vertices in last vertex ring + int lastRingVertexCount = 0; + + // count vertices in first ring + { + const int controlPointVertexCount = inputRecord.Get().controlPointVertexCounts[controlPointOffset]; + + // check if current thread will generate a vertex on this ring + if (threadId < controlPointVertexCount) + { + threadVertexControlPoint = 0; + threadVertexControlPointVertex = threadId; + } + + // Count total number of vertices + vertexOutputCount += controlPointVertexCount; + + // Update last ring size + lastRingVertexCount = controlPointVertexCount; + } + + // count vertex & triangles count for every ring + for (int ring = 1; ring < splineControlPointCount; ++ring) + { + const int controlPointVertexCount = inputRecord.Get().controlPointVertexCounts[controlPointOffset + ring]; + + if ((vertexOutputCount <= threadId) && ((vertexOutputCount + controlPointVertexCount) > threadId)) + { + threadVertexControlPoint = ring; + threadVertexControlPointVertex = threadId - int(vertexOutputCount); + } + + // lower sections are on last ring + const int lowerSectionCount = GetRingSectionCount(lastRingVertexCount); + // upper sections are on current ring + const int upperSectionCount = GetRingSectionCount(controlPointVertexCount); + + // Count number of regular sections (i.e. one edge of the lower ring maps to one section on the upper ring) + const int sectionCount = min(lowerSectionCount, upperSectionCount); + const int regularTriangleCount = sectionCount * 2; + // Count number of irregular trianlges (i.e. a edge connects with a single vertex on the other ring) + const int irregularTriangleCount = max(lowerSectionCount, upperSectionCount) - sectionCount; + + // Total number of triangles on this ring + const int triangleCount = regularTriangleCount + irregularTriangleCount; + + if ((primitiveOutputCount <= threadId) && ((primitiveOutputCount + triangleCount) > threadId)) + { + // Primitives are generated from lower to upper ring, i.e. we need the index of the last ring + threadPrimitiveSection = ring - 1; + threadPrimitiveSectionTriangle = threadId - primitiveOutputCount; + // Get index of first vertex in last ring + threadPrimitiveSectionVertexOffset = vertexOutputCount - lastRingVertexCount; + } + + // Count total number of vertices & triangles + vertexOutputCount += controlPointVertexCount; + primitiveOutputCount += triangleCount; + + // Update last ring size + lastRingVertexCount = controlPointVertexCount; + } + } + + vertexOutputCount = min(vertexOutputCount, numOutputVerticesLimit); + primitiveOutputCount = min(primitiveOutputCount, numOutputTrianglesLimit); + + SetMeshOutputCounts(vertexOutputCount, primitiveOutputCount); + + if (threadId < vertexOutputCount) { + TransformedVertex vertex; + + // Base position to compute object-local positions + const float3 splineBasePosition = inputRecord.Get().controlPointPositions[controlPointOffset]; + + const float3 controlPointPosition = inputRecord.Get().controlPointPositions[controlPointOffset + threadVertexControlPoint]; + const uint controlPointVertexCount = inputRecord.Get().controlPointVertexCounts[controlPointOffset + threadVertexControlPoint]; + + // Compute forward vector based on previous and next control point positions + float3 forward = float3(0, 0, 0); + // Add direction from previous control point + if (threadVertexControlPoint > 0) + { + const float3 previousControlPointPosition = inputRecord.Get().controlPointPositions[controlPointOffset + threadVertexControlPoint - 1]; + forward += controlPointPosition - previousControlPointPosition; + } + // Add direction to next control point + if (threadVertexControlPoint < (splineControlPointCount - 1)) + { + const float3 nextControlPointPosition = inputRecord.Get().controlPointPositions[controlPointOffset + threadVertexControlPoint + 1]; + forward += nextControlPointPosition - controlPointPosition; + } + + forward = normalize(forward); + + // get perpendicular vector to forward + float3 right = normalize(cross(forward, float3(1, 0, 0))); + float3 up = normalize(cross(forward, right)); + + const float rotationOffset = inputRecord.Get().rotationOffset[gid]; + const float vertexAlpha = rotationOffset + (threadVertexControlPointVertex / float(controlPointVertexCount)) * 2.f * PI; + + const float2 radius = inputRecord.Get().controlPointRadii[controlPointOffset + threadVertexControlPoint]; + const float noiseAmplitude = inputRecord.Get().controlPointNoiseAmplitudes[controlPointOffset + threadVertexControlPoint]; + + // random noise value in [-noiseAmplitude; noiseAmplitude] + const float noise = (Random(Hash(controlPointPosition), Hash(vertexAlpha)) * 2.0 - 1.0) * noiseAmplitude; + + const float3 worldSpaceBasePosition = + controlPointPosition + // base position + cos(vertexAlpha) * right * radius.y + // position on vertex ring in right direction + sin(vertexAlpha) * up * radius.x + // position on vertex ring in up direction + forward * noise; // random noise offset in spline direction + + // x = wind strength for current spline + // y = factor for how much the actual vertex position in influencing the wind offset + // 0 = wind offset is only determined by control point position + // 1 = wind offset is only determined by vertex position + const float2 windStrength = inputRecord.Get().windStrength[gid]; + const float3 windReferencePosition = lerp(controlPointPosition, worldSpaceBasePosition, windStrength.y); + // Get Height above terrain scaled by wind strength + const float vertexHeight = max(windReferencePosition.y - GetTerrainHeight(windReferencePosition.xz), 0) * windStrength.x; + + // Compute wind offset for current and last frame + const float3 windOffset = + vertexHeight * GetWindStrength() * GetWindOffset(windReferencePosition.xz, GetTime()); + const float3 previousWindOffset = + vertexHeight * GetWindStrength() * GetWindOffset(windReferencePosition.xz, GetPreviousTime()); + + // compute position relative to first control point + // this improve floating-point precision of ddx & ddy derivatives in pixel shader + vertex.objectSpacePosition = worldSpaceBasePosition - splineBasePosition + windOffset; + vertex.color = inputRecord.Get().color[gid]; + + ComputeClipSpacePositionAndMotion( + vertex, worldSpaceBasePosition + windOffset, worldSpaceBasePosition + previousWindOffset); + + + verts[threadId] = vertex; + } + + if (threadId < primitiveOutputCount) { + // Get number of vertices in current (lower) and next (upper) ring + const int lowerVertexCount = inputRecord.Get().controlPointVertexCounts[controlPointOffset + threadPrimitiveSection]; + const int upperVertexCount = inputRecord.Get().controlPointVertexCounts[controlPointOffset + threadPrimitiveSection + 1]; + + // Get number of sections in current and next ring + const int lowerSectionCount = GetRingSectionCount(lowerVertexCount); + const int upperSectionCount = GetRingSectionCount(upperVertexCount); + + // Get index of first vertex in current and next ring + const int lowerVertexOffset = threadPrimitiveSectionVertexOffset; + const int upperVertexOffset = lowerVertexOffset + lowerVertexCount; + + // The number of full sections (i.e. one edge in the lower ring corresponds to one edge in the upper ring) + // is determined by the smaller vertex ring. + // Irregular triangles will be generated from the larger ring towards the smaller ring + const bool isLower = lowerSectionCount <= upperSectionCount; + + // Total number of regular sections + const int sectionCount = isLower ? lowerSectionCount : upperSectionCount; + // Ratio between sections in the smaller and larger ring + const float sectionFactor = isLower ? upperSectionCount / float(lowerSectionCount) : lowerSectionCount / float(upperSectionCount); + + const int regularTriangleCount = sectionCount * 2; + // check if current triangle is irregular (i.e. connects an edge to a single vertex) + const bool isIrregularTriangle = threadPrimitiveSectionTriangle >= regularTriangleCount; + // index of irregular triangle + const int irregularTriangleIndex = threadPrimitiveSectionTriangle - regularTriangleCount; + + // running counters + int lowerSection = 0; + int upperSection = 0; + int sectionJumpCount = 0; + + // indices for smaller and larger (=other) section + int section = 0; + int otherSection = 0; + for (; section < sectionCount; ++section) + { + // compute which section on the larger ring should match up with the current section + int otherSectionTarget = section * sectionFactor; + + // Generate irregular triangles for skipped sections + for (; otherSection < otherSectionTarget; ++otherSection) + { + if (isIrregularTriangle && (sectionJumpCount == irregularTriangleIndex)) + { + lowerSection = isLower ? section : otherSection; + upperSection = isLower ? otherSection : section; + } + sectionJumpCount++; + } + + // Generate a regular triangles for both sections + if (!isIrregularTriangle && (section == (threadPrimitiveSectionTriangle / 2))) + { + lowerSection = isLower ? section : otherSection; + upperSection = isLower ? otherSection : section; + } + + otherSection++; + } + // Generate remaining irregular triangles to close the ring + for (; otherSection < max(lowerSectionCount, upperSectionCount); ++otherSection) + { + if (isIrregularTriangle && (sectionJumpCount == irregularTriangleIndex)) + { + lowerSection = isLower ? section : otherSection; + upperSection = isLower ? otherSection : section; + } + sectionJumpCount++; + } + + uint3 tri = 0; + + if (isIrregularTriangle) { + if (isLower) { + tri = uint3(lowerVertexOffset + ((lowerSection + 1) % lowerVertexCount), + upperVertexOffset + ((upperSection + 1) % upperVertexCount), + upperVertexOffset + ((upperSection + 0) % upperVertexCount)); + } else { + tri = uint3(lowerVertexOffset + ((lowerSection + 0) % lowerVertexCount), + lowerVertexOffset + ((lowerSection + 1) % lowerVertexCount), + upperVertexOffset + ((upperSection + 0) % upperVertexCount)); + } + } else { + if (threadPrimitiveSectionTriangle & 0x1) { + tri = uint3(upperVertexOffset + ((upperSection + 0) % upperVertexCount), + lowerVertexOffset + ((lowerSection + 1) % lowerVertexCount), + upperVertexOffset + ((upperSection + 1) % upperVertexCount)); + } else { + tri = uint3(lowerVertexOffset + ((lowerSection + 0) % lowerVertexCount), + lowerVertexOffset + ((lowerSection + 1) % lowerVertexCount), + upperVertexOffset + ((upperSection + 0) % upperVertexCount)); + } + } + + tris[threadId] = tri; + } +} + +DeferredPixelShaderOutput SplinePixelShader(TransformedVertex input) +{ + DeferredPixelShaderOutput output; + + output.baseColor = float4(input.color, 1); + output.motion = input.clipSpaceMotion; + + // compute normal from object space position derivatives + output.normal.xyz = normalize(cross(ddy(input.objectSpacePosition.xyz), ddx(input.objectSpacePosition.xyz))); + output.normal.w = 1.0; + + return output; +} \ No newline at end of file diff --git a/meshNodeSample/shaders/terrainrenderer.hlsl b/meshNodeSample/shaders/terrainrenderer.hlsl new file mode 100644 index 0000000..6128570 --- /dev/null +++ b/meshNodeSample/shaders/terrainrenderer.hlsl @@ -0,0 +1,156 @@ +// This file is part of the AMD Work Graph Mesh Node Sample. +// +// Copyright (c) 2024 Advanced Micro Devices, Inc. All rights reserved. +// +// 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 +// AUTHORS OR COPYRIGHT HOLDERS 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. + +#include "common.hlsl" + +struct TransformedVertex { + float4 clipSpacePosition : SV_POSITION; + float3 worldSpacePosition : NORMAL0; + float3 normal : NORMAL1; + float2 clipSpaceMotion : TEXCOORD0; +}; + +uint3 GetPrimitive(uint index, in uint primitivesPerRow) +{ + uint verticesPerRow = primitivesPerRow + 1; + + uint cell = index / 2; + uint row = cell / primitivesPerRow; + cell = cell % primitivesPerRow; + + uint base = (row * verticesPerRow) + cell; + + // c - d + // | / | + // a - b + const uint a = base; + const uint b = base + 1; + const uint c = base + verticesPerRow; + const uint d = base + verticesPerRow + 1; + + return (index % 2) == 0 ? uint3(a, c, d) : uint3(d, b, a); +} + +[Shader("node")] +[NodeLaunch("mesh")] +[NodeId("DrawTerrainChunk", 0)] +[NodeMaxDispatchGrid(8, 8, 1)] +// This limit reflects the maximum dispatch size of the chunk grid and is not required on AMD GPUs. +// If you wish to change any of the procedural generation parameters, +// and you are running on a non-AMD GPU, you may need to adjust this limit. +// You can learn more at: +// https://gpuopen.com/learn/work_graphs_mesh_nodes/work_graphs_mesh_nodes-tips_tricks_best_practices +[NodeMaxInputRecordsPerGraphEntryRecord(32 * 32, true)] +[NumThreads(128, 1, 1)] +[OutputTopology("triangle")] +void TerrainMeshShader( + uint gtid : SV_GroupThreadID, + uint2 gid : SV_GroupID, + DispatchNodeInputRecord inputRecord, + out indices uint3 tris[128], + out vertices TransformedVertex verts[81]) +{ + const DrawTerrainChunkRecord record = inputRecord.Get(); + + const int levelOfDetail = record.levelOfDetail; + // number of thread groups per chunk axis for LOD 0 + const int baseThreadGroupsPerChunkAxis = 8; + + const int threadGroupsPerChunkAxis = + baseThreadGroupsPerChunkAxis / clamp(1L << levelOfDetail, 1, baseThreadGroupsPerChunkAxis); + const int threadGroupIdScale = baseThreadGroupsPerChunkAxis / threadGroupsPerChunkAxis; + + const int primitivesPerAxis = 8; + const int verticesPerAxis = primitivesPerAxis + 1; + const float scale = chunkSize / float(primitivesPerAxis * baseThreadGroupsPerChunkAxis); + + const int vertexCount = verticesPerAxis * verticesPerAxis; + const int primitiveCount = primitivesPerAxis * primitivesPerAxis * 2; + + SetMeshOutputCounts(vertexCount, primitiveCount); + + const int2 tile = record.chunkGridPosition * baseThreadGroupsPerChunkAxis + int2(gid.xy) * threadGroupIdScale; + + const bool4 localLevelOfDetailTransition = + bool4(record.levelOfDetailTransition.x && (gid.x == 0), + record.levelOfDetailTransition.y && (gid.y == 0), + record.levelOfDetailTransition.z && (gid.x == (record.dispatchGrid.x - 1)), + record.levelOfDetailTransition.w && (gid.y == (record.dispatchGrid.y - 1))); + + if (gtid < vertexCount) { + TransformedVertex vertex; + + int2 localVertexIndex = int2(gtid % verticesPerAxis, gtid / verticesPerAxis); + + // collapse vertices along LOD borders + if (localLevelOfDetailTransition.x && (localVertexIndex.x == 0) && ((localVertexIndex.y % 2) == 1)) { + localVertexIndex.y = int(localVertexIndex.y / 2) * 2; + } + if (localLevelOfDetailTransition.y && (localVertexIndex.y == 0) && ((localVertexIndex.x % 2) == 1)) { + localVertexIndex.x = int(localVertexIndex.x / 2) * 2; + } + if (localLevelOfDetailTransition.z && (localVertexIndex.x == 8) && ((localVertexIndex.y % 2) == 1)) { + localVertexIndex.y = int(localVertexIndex.y / 2) * 2; + } + if (localLevelOfDetailTransition.w && (localVertexIndex.y == 8) && ((localVertexIndex.x % 2) == 1)) { + localVertexIndex.x = int(localVertexIndex.x / 2) * 2; + } + + localVertexIndex *= threadGroupIdScale; + + const int2 globalVertexIndex = tile * primitivesPerAxis + localVertexIndex; + + const float2 globalVertexPosition = globalVertexIndex * scale; + + const float3 worldSpacePosition = + float3(globalVertexPosition.x, GetTerrainHeight(globalVertexPosition), globalVertexPosition.y); + + vertex.normal = GetTerrainNormal(worldSpacePosition.xz); + vertex.worldSpacePosition = worldSpacePosition; + ComputeClipSpacePositionAndMotion(vertex, worldSpacePosition); + + verts[gtid] = vertex; + } + + { + tris[gtid] = GetPrimitive(gtid, 8); + } +} + +DeferredPixelShaderOutput TerrainPixelShader(TransformedVertex input) +{ + DeferredPixelShaderOutput output; + + output.normal = float4(normalize(input.normal), 1); + output.motion = input.clipSpaceMotion; + + const float3 biomeWeights = GetBiomeWeights(input.worldSpacePosition.xz); + const float biomeFactor = lerp(1.0, 0.75, biomeWeights.y); + + const float3 grassColor = pow(float3(0.41, 0.44, 0.29) * 2, 2.2) * 0.65 * biomeFactor * + (0.75 + 0.25 * PerlinNoise2D(0.25 * input.worldSpacePosition.xz)); + const float3 rockColor = float3(0.24, 0.24, 0.24); + + output.baseColor.rgb = lerp(grassColor, rockColor, biomeWeights.x); + output.baseColor.a = 1.0; + + return output; +} \ No newline at end of file diff --git a/meshNodeSample/shaders/tree.hlsl b/meshNodeSample/shaders/tree.hlsl new file mode 100644 index 0000000..b45bf90 --- /dev/null +++ b/meshNodeSample/shaders/tree.hlsl @@ -0,0 +1,300 @@ +// This file is part of the AMD Work Graph Mesh Node Sample. +// +// Copyright (c) 2024 Advanced Micro Devices, Inc. All rights reserved. +// +// 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 +// AUTHORS OR COPYRIGHT HOLDERS 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. + +#include "common.hlsl" + +// Oak tree generation is single-threaded, so we use a coalescing node to generate multiple trees at once. +// Each oka tree consists of three splines: the trunk, a branch and the leafes. +// Thus we can process maxSplinesPerRecord (=32) trees in parallel +[Shader("node")] +[NodeId("GenerateTree", 0)] +[NodeLaunch("coalescing")] +[NumThreads(maxSplinesPerRecord, 1, 1)] +void GenerateOakTree( + [MaxRecords(maxSplinesPerRecord)] + GroupNodeInputRecords inputRecord, + + uint threadId : SV_GroupThreadID, + + [MaxRecords(3)] + [NodeId("DrawSpline")] + NodeOutput output) +{ + GroupNodeOutputRecords outputRecord = output.GetGroupNodeOutputRecords(3); + + if (threadId < inputRecord.Count()) { + const float2 basePositionXZ = inputRecord.Get(threadId).position; + const float3 basePosition = GetTerrainPosition(basePositionXZ); + + const uint seed = CombineSeed(asuint(basePositionXZ.x), asuint(basePositionXZ.y)); + + const float rotationAngle = Random(seed, 78923) * 2 * PI; + const float3 forward = float3(sin(rotationAngle), 0, cos(rotationAngle)); + const float3 up = lerp(float3(0, 1, 0), GetTerrainNormal(basePositionXZ), 0.1); + const float3 side = normalize(cross(forward, up)); + + const float upScale = lerp(0.5, 1.2, Random(seed, 546)); + const float sideScale = lerp(0.6, 1.0, Random(seed, 9487)); + + const int splineIndex = threadId; + + // Tree trunk + { + // Set dispatch grid to number of splines per record + outputRecord.Get(0).dispatchGrid = uint3(inputRecord.Count(), 1, 1); + outputRecord.Get(0).color[splineIndex] = float3(0.18, 0.12, 0.10) * 6; + outputRecord.Get(0).rotationOffset[splineIndex] = 0; + outputRecord.Get(0).windStrength[splineIndex] = float2(0, 0); + outputRecord.Get(0).controlPointCount[splineIndex] = 5; + + int controlPointIndex = splineIndex * splineMaxControlPointCount; + + outputRecord.Get(0).controlPointPositions[controlPointIndex] = basePosition - up; + outputRecord.Get(0).controlPointVertexCounts[controlPointIndex] = 5; + outputRecord.Get(0).controlPointRadii[controlPointIndex] = 0.5 * sideScale; + outputRecord.Get(0).controlPointNoiseAmplitudes[controlPointIndex] = 0.0; + controlPointIndex++; + + outputRecord.Get(0).controlPointPositions[controlPointIndex] = basePosition + 2 * upScale * up; + outputRecord.Get(0).controlPointVertexCounts[controlPointIndex] = 4; + outputRecord.Get(0).controlPointRadii[controlPointIndex] = 0.35 * sideScale; + outputRecord.Get(0).controlPointNoiseAmplitudes[controlPointIndex] = 0.5; + controlPointIndex++; + + outputRecord.Get(0).controlPointPositions[controlPointIndex] = + basePosition + 4 * upScale * up + 1 * sideScale * forward; + outputRecord.Get(0).controlPointVertexCounts[controlPointIndex] = 3; + outputRecord.Get(0).controlPointRadii[controlPointIndex] = 0.25 * sideScale; + outputRecord.Get(0).controlPointNoiseAmplitudes[controlPointIndex] = 0.0; + controlPointIndex++; + + outputRecord.Get(0).controlPointPositions[controlPointIndex] = + basePosition + 4.5 * upScale * up + 1.5 * sideScale * forward + 0.5 * sideScale * side; + outputRecord.Get(0).controlPointVertexCounts[controlPointIndex] = 2; + outputRecord.Get(0).controlPointRadii[controlPointIndex] = 0.3 * sideScale; + outputRecord.Get(0).controlPointNoiseAmplitudes[controlPointIndex] = 0.0; + controlPointIndex++; + + outputRecord.Get(0).controlPointPositions[controlPointIndex] = + basePosition + 5.5 * upScale * up + 2 * sideScale * forward + 1 * sideScale * side; + outputRecord.Get(0).controlPointVertexCounts[controlPointIndex] = 1; + outputRecord.Get(0).controlPointRadii[controlPointIndex] = 0.0; + outputRecord.Get(0).controlPointNoiseAmplitudes[controlPointIndex] = 0.0; + } + + // Tree branch + { + outputRecord.Get(1).dispatchGrid = uint3(inputRecord.Count(), 1, 1); + outputRecord.Get(1).color[splineIndex] = float3(0.18, 0.12, 0.10) * 6; + outputRecord.Get(1).rotationOffset[splineIndex] = 0; + outputRecord.Get(1).windStrength[splineIndex] = float2(0, 0); + outputRecord.Get(1).controlPointCount[splineIndex] = 3; + + int controlPointIndex = splineIndex * splineMaxControlPointCount; + + outputRecord.Get(1).controlPointPositions[controlPointIndex] = + basePosition + 3 * upScale * up + 0.5 * sideScale * forward; + outputRecord.Get(1).controlPointVertexCounts[controlPointIndex] = 4; + outputRecord.Get(1).controlPointRadii[controlPointIndex] = 0.25 * sideScale; + outputRecord.Get(1).controlPointNoiseAmplitudes[controlPointIndex] = 0.0; + controlPointIndex++; + + outputRecord.Get(1).controlPointPositions[controlPointIndex] = + basePosition + 4 * upScale * up - 0.5 * sideScale * forward; + outputRecord.Get(1).controlPointVertexCounts[controlPointIndex] = 3; + outputRecord.Get(1).controlPointRadii[controlPointIndex] = 0.2 * sideScale; + outputRecord.Get(1).controlPointNoiseAmplitudes[controlPointIndex] = 0.25; + controlPointIndex++; + + outputRecord.Get(1).controlPointPositions[controlPointIndex] = + basePosition + 5 * upScale * up - 1 * sideScale * forward; + outputRecord.Get(1).controlPointVertexCounts[controlPointIndex] = 1; + outputRecord.Get(1).controlPointRadii[controlPointIndex] = 0.0; + outputRecord.Get(1).controlPointNoiseAmplitudes[controlPointIndex] = 0.0; + } + + // Tree leaves + { + outputRecord.Get(2).dispatchGrid = uint3(inputRecord.Count(), 1, 1); + outputRecord.Get(2).color[splineIndex] = float3(0.3, 0.3, 0.0) * lerp(0.7, 1.3, Random(seed, 1456)); + outputRecord.Get(2).rotationOffset[splineIndex] = rotationAngle; + outputRecord.Get(2).windStrength[splineIndex] = float2(0.125, 0.5); + outputRecord.Get(2).controlPointCount[splineIndex] = 4; + + int controlPointIndex = splineIndex * splineMaxControlPointCount; + + outputRecord.Get(2).controlPointPositions[controlPointIndex] = + basePosition + 4 * upScale * up + 0.5 * sideScale * forward; + outputRecord.Get(2).controlPointVertexCounts[controlPointIndex] = 1; + outputRecord.Get(2).controlPointRadii[controlPointIndex] = 0.0; + outputRecord.Get(2).controlPointNoiseAmplitudes[controlPointIndex] = 0.0; + controlPointIndex++; + + outputRecord.Get(2).controlPointPositions[controlPointIndex] = + basePosition + 5 * upScale * up + 0.5 * sideScale * forward; + outputRecord.Get(2).controlPointVertexCounts[controlPointIndex] = round(lerp(5, 7, Random(seed, 2156))); + outputRecord.Get(2).controlPointRadii[controlPointIndex] = float2(2.5, 4) * sideScale; + outputRecord.Get(2).controlPointNoiseAmplitudes[controlPointIndex] = 0.7 * upScale; + controlPointIndex++; + + outputRecord.Get(2).controlPointPositions[controlPointIndex] = + basePosition + 6.5 * upScale * up + 0.5 * sideScale * forward; + outputRecord.Get(2).controlPointVertexCounts[controlPointIndex] = round(lerp(3, 5, Random(seed, 458))); + outputRecord.Get(2).controlPointRadii[controlPointIndex] = 3.5 * sideScale; + outputRecord.Get(2).controlPointNoiseAmplitudes[controlPointIndex] = 0.7 * upScale; + controlPointIndex++; + + outputRecord.Get(2).controlPointPositions[controlPointIndex] = + basePosition + 8.5 * upScale * up + 0.5 * sideScale * forward + 0.5 * sideScale * side; + outputRecord.Get(2).controlPointVertexCounts[controlPointIndex] = 1; + outputRecord.Get(2).controlPointRadii[controlPointIndex] = 0.0; + outputRecord.Get(2).controlPointNoiseAmplitudes[controlPointIndex] = 0.0; + } + } + + outputRecord.OutputComplete(); +} + +// Pine tree generation works the same way as the oak tree generation. +// Each pine tree consists of two splines: the tree trunk and the "leaves". +[Shader("node")] +[NodeId("GenerateTree", 1)] +[NodeLaunch("coalescing")] +[NumThreads(maxSplinesPerRecord, 1, 1)] +void GeneratePineTree( + [MaxRecords(maxSplinesPerRecord)] + GroupNodeInputRecords inputRecord, + + uint threadId : SV_GroupThreadID, + + [MaxRecords(2)] + [NodeId("DrawSpline")] + NodeOutput output) +{ + GroupNodeOutputRecords outputRecord = output.GetGroupNodeOutputRecords(2); + + if (threadId < inputRecord.Count()) { + const float2 basePositionXZ = inputRecord.Get(threadId).position; + const float3 basePosition = GetTerrainPosition(basePositionXZ); + const float3 terrainNormal = GetTerrainNormal(basePositionXZ); + const float3 basePositionUp = lerp(float3(0, 1, 0), terrainNormal, 0.1); + + const uint seed = CombineSeed(asuint(basePositionXZ.x), asuint(basePositionXZ.y)); + + const float stemTerrainFactor = 1.f + (1.f - smoothstep(0.6, 1.0, terrainNormal.y)) * 0.5; + + const float rotationAngle = Random(seed, 14658) * 2 * PI; + const float stemHeight = 1 + Random(seed, 2384) * 2 * stemTerrainFactor; + const float leafRadiusScale = 1.5 + Random(seed, 3827); + const float leafSectionScale = 1.5 + Random(seed, 78934) * 2 * stemTerrainFactor; + + const int splineIndex = threadId; + + // Tree trunk + { + outputRecord.Get(0).dispatchGrid = uint3(inputRecord.Count(), 1, 1); + outputRecord.Get(0).color[splineIndex] = float3(1.08, 0.72, 0.6); + outputRecord.Get(0).rotationOffset[splineIndex] = rotationAngle; + outputRecord.Get(0).windStrength[splineIndex] = float2(0.125, 0); + outputRecord.Get(0).controlPointCount[splineIndex] = 2; + + int controlPointIndex = splineIndex * splineMaxControlPointCount; + + outputRecord.Get(0).controlPointPositions[controlPointIndex] = basePosition - basePositionUp * 4.f; + outputRecord.Get(0).controlPointVertexCounts[controlPointIndex] = 5; + outputRecord.Get(0).controlPointRadii[controlPointIndex] = 0.4; + outputRecord.Get(0).controlPointNoiseAmplitudes[controlPointIndex] = 0.0; + controlPointIndex++; + + outputRecord.Get(0).controlPointPositions[controlPointIndex] = + basePosition + float3(0, stemHeight + 0.5, 0); + outputRecord.Get(0).controlPointVertexCounts[controlPointIndex] = 4; + outputRecord.Get(0).controlPointRadii[controlPointIndex] = 0.3; + outputRecord.Get(0).controlPointNoiseAmplitudes[controlPointIndex] = 0; + } + + // Tree leaves + { + const float green = saturate(PerlinNoise2D(0.05 * basePositionXZ)); + const float brightness = PerlinNoise2D(0.4 * basePositionXZ + float2(498, 345)); + const float3 color = float3(0.24, 0.25 + green * 0.15, 0.0) * (1.0 + brightness * 0.4); + + outputRecord.Get(1).dispatchGrid = uint3(inputRecord.Count(), 1, 1); + outputRecord.Get(1).color[splineIndex] = color; + outputRecord.Get(1).rotationOffset[splineIndex] = rotationAngle; + outputRecord.Get(1).windStrength[splineIndex] = float2(0.125, 0.5); + outputRecord.Get(1).controlPointCount[splineIndex] = 7; + + int controlPointIndex = splineIndex * splineMaxControlPointCount; + + const float ringHeight0 = stemHeight; + outputRecord.Get(1).controlPointPositions[controlPointIndex] = basePosition + float3(0, ringHeight0, 0); + outputRecord.Get(1).controlPointVertexCounts[controlPointIndex] = 1; + outputRecord.Get(1).controlPointRadii[controlPointIndex] = 0.0; + outputRecord.Get(1).controlPointNoiseAmplitudes[controlPointIndex] = 0.0; + controlPointIndex++; + + outputRecord.Get(1).controlPointPositions[controlPointIndex] = + basePosition + float3(0, ringHeight0 + 0.5, 0); + outputRecord.Get(1).controlPointVertexCounts[controlPointIndex] = 7; + outputRecord.Get(1).controlPointRadii[controlPointIndex] = leafRadiusScale; + outputRecord.Get(1).controlPointNoiseAmplitudes[controlPointIndex] = 0.2; + controlPointIndex++; + + const float ringHeight1 = stemHeight + 1 * leafSectionScale; + outputRecord.Get(1).controlPointPositions[controlPointIndex] = basePosition + float3(0, ringHeight1, 0); + outputRecord.Get(1).controlPointVertexCounts[controlPointIndex] = 7; + outputRecord.Get(1).controlPointRadii[controlPointIndex] = leafRadiusScale * 0.3; + outputRecord.Get(1).controlPointNoiseAmplitudes[controlPointIndex] = 0.1; + controlPointIndex++; + + outputRecord.Get(1).controlPointPositions[controlPointIndex] = + basePosition + float3(0, ringHeight1 + 0.5, 0); + outputRecord.Get(1).controlPointVertexCounts[controlPointIndex] = 7; + outputRecord.Get(1).controlPointRadii[controlPointIndex] = leafRadiusScale * 0.8; + outputRecord.Get(1).controlPointNoiseAmplitudes[controlPointIndex] = 0.2; + controlPointIndex++; + + const float ringHeight2 = stemHeight + 2 * leafSectionScale; + outputRecord.Get(1).controlPointPositions[controlPointIndex] = basePosition + float3(0, ringHeight2, 0); + outputRecord.Get(1).controlPointVertexCounts[controlPointIndex] = 7; + outputRecord.Get(1).controlPointRadii[controlPointIndex] = leafRadiusScale * 0.3; + outputRecord.Get(1).controlPointNoiseAmplitudes[controlPointIndex] = 0.1; + controlPointIndex++; + + outputRecord.Get(1).controlPointPositions[controlPointIndex] = + basePosition + float3(0, ringHeight2 + 0.5, 0); + outputRecord.Get(1).controlPointVertexCounts[controlPointIndex] = 7; + outputRecord.Get(1).controlPointRadii[controlPointIndex] = leafRadiusScale * 0.6; + outputRecord.Get(1).controlPointNoiseAmplitudes[controlPointIndex] = 0.2; + controlPointIndex++; + + const float ringHeight3 = stemHeight + 3 * leafSectionScale; + outputRecord.Get(1).controlPointPositions[controlPointIndex] = basePosition + float3(0, ringHeight3, 0); + outputRecord.Get(1).controlPointVertexCounts[controlPointIndex] = 1; + outputRecord.Get(1).controlPointRadii[controlPointIndex] = 0.0; + outputRecord.Get(1).controlPointNoiseAmplitudes[controlPointIndex] = 0.0; + controlPointIndex++; + } + } + + outputRecord.OutputComplete(); +} \ No newline at end of file diff --git a/meshNodeSample/shaders/utils.hlsl b/meshNodeSample/shaders/utils.hlsl new file mode 100644 index 0000000..c2355aa --- /dev/null +++ b/meshNodeSample/shaders/utils.hlsl @@ -0,0 +1,307 @@ +// This file is part of the AMD Work Graph Mesh Node Sample. +// +// Copyright (c) 2024 Advanced Micro Devices, Inc. All rights reserved. +// +// 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 +// AUTHORS OR COPYRIGHT HOLDERS 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. + +#pragma once + +#define PI 3.14159265359 + +// ======================== +// Projection Utils + +float3 PerspectiveDivision(in float4 vec) +{ + return vec.xyz / vec.w; +} + +float3 PerspectiveProject(in float4x4 projectionMatrix, in float4 vec) +{ + return PerspectiveDivision(mul(projectionMatrix, vec)); +} + +float3 PerspectiveProject(in float4x4 projectionMatrix, in float3 vec) +{ + return PerspectiveProject(projectionMatrix, float4(vec, 1)); +} + +// ======================== +// Bit Utils + +bool IsBitSet(in uint data, in int bitIndex) +{ + return data & (1u << bitIndex); +} + +int BitSign(in uint data, in int bitIndex) +{ + return IsBitSet(data, bitIndex) ? 1 : -1; +} + +// ======================== +// Randon & Noise functions + +// Random gradient at 2D position +float2 PerlinNoiseDir2D(in int2 position) +{ + const int2 pos = position % 289; + + float f = 0; + f = (34 * pos.x + 1); + f = f * pos.x % 289 + pos.y; + f = (34 * f + 1) * f % 289; + f = frac(f / 43) * 2 - 1; + + float x = f - round(f); + float y = abs(f) - 0.5; + + return normalize(float2(x, y)); +} + +float PerlinNoise2D(in float2 position) +{ + const int2 gridPositon = floor(position); + const float2 gridOffset = frac(position); + + const float d00 = dot(PerlinNoiseDir2D(gridPositon + int2(0, 0)), gridOffset - float2(0, 0)); + const float d01 = dot(PerlinNoiseDir2D(gridPositon + int2(0, 1)), gridOffset - float2(0, 1)); + const float d10 = dot(PerlinNoiseDir2D(gridPositon + int2(1, 0)), gridOffset - float2(1, 0)); + const float d11 = dot(PerlinNoiseDir2D(gridPositon + int2(1, 1)), gridOffset - float2(1, 1)); + + const float2 interpolationWeights = gridOffset * gridOffset * gridOffset * (gridOffset * (gridOffset * 6 - 15) + 10); + + const float d0 = lerp(d00, d01, interpolationWeights.y); + const float d1 = lerp(d10, d11, interpolationWeights.y); + + return lerp(d0, d1, interpolationWeights.x); +} + +uint Hash(uint seed) +{ + seed = (seed ^ 61u) ^ (seed >> 16u); + seed *= 9u; + seed = seed ^ (seed >> 4u); + seed *= 0x27d4eb2du; + seed = seed ^ (seed >> 15u); + return seed; +} + +uint CombineSeed(uint a, uint b) +{ + return a ^ Hash(b) + 0x9e3779b9 + (a << 6) + (a >> 2); +} + +uint CombineSeed(uint a, uint b, uint c) +{ + return CombineSeed(CombineSeed(a, b), c); +} + +uint CombineSeed(uint a, uint b, uint c, uint d) +{ + return CombineSeed(CombineSeed(a, b), c, d); +} + +uint Hash(in float seed) +{ + return Hash(asuint(seed)); +} + +uint Hash(in float3 vec) +{ + return CombineSeed(Hash(vec.x), Hash(vec.y), Hash(vec.z)); +} + +uint Hash(in float4 vec) +{ + return CombineSeed(Hash(vec.x), Hash(vec.y), Hash(vec.z), Hash(vec.w)); +} + +float Random(uint seed) +{ + return Hash(seed) / float(~0u); +} + +float Random(uint a, uint b) +{ + return Random(CombineSeed(a, b)); +} + +float Random(uint a, uint b, uint c) +{ + return Random(CombineSeed(a, b), c); +} + +float Random(uint a, uint b, uint c, uint d) +{ + return Random(CombineSeed(a, b), c, d); +} + +float Random(uint a, uint b, uint c, uint d, uint e) +{ + return Random(CombineSeed(a, b), c, d, e); +} + +// ======================== + +float ToRadians(in float degrees) +{ + return PI * (degrees / 180.0); +} + +template +T IdentityMatrix() +{ + // float4x4 identity matrix should(TM) convert to identity matrix for smaller matrices + return (T)float4x4(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1); +} + +template <> +float3x3 IdentityMatrix() +{ + return float3x3(1, 0, 0, 0, 1, 0, 0, 0, 0); +} + +template <> +float4x4 IdentityMatrix() +{ + return float4x4(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1); +} + +float2 RotateAroundPoint2d(in const float2 position, in const float angle, in const float2 rotationPoint) +{ + // Move reference position to origin + const float2 p = position - rotationPoint; + + const float s = sin(angle); + const float c = cos(angle); + + return float2(p.x * c - p.y * s, p.x * s + p.y * c) + rotationPoint; +} + +// ===================================== +// Bounding box & visibility test utils + +struct ClipPlanes { + float4 planes[6]; +}; + +float4 PlaneNormalize(in float4 plane) +{ + const float l = length(plane.xyz); + + if (l > 0.0) { + return plane / l; + } + + return 0; +} + +ClipPlanes ComputeClipPlanes(in float4x4 viewProjectionMatrix) +{ + ClipPlanes result; + + result.planes[0] = PlaneNormalize(viewProjectionMatrix[3] + viewProjectionMatrix[0]); + result.planes[1] = PlaneNormalize(viewProjectionMatrix[3] - viewProjectionMatrix[0]); + result.planes[2] = PlaneNormalize(viewProjectionMatrix[3] + viewProjectionMatrix[1]); + result.planes[3] = PlaneNormalize(viewProjectionMatrix[3] - viewProjectionMatrix[1]); + result.planes[4] = PlaneNormalize(viewProjectionMatrix[3] + viewProjectionMatrix[2]); + result.planes[5] = PlaneNormalize(viewProjectionMatrix[3] - viewProjectionMatrix[2]); + + return result; +} + +bool IsSphereVisible(const in float3 center, const in float radius, const in float4 clipPlanes[6]) +{ + for (int i = 0; i < 6; ++i) { + if (dot(float4(center, 1), clipPlanes[i]) < -radius) { + return false; + } + } + + return true; +} + +bool IsSphereVisible(const in float3 center, const in float radius, const in ClipPlanes clipPlanes) +{ + return IsSphereVisible(center, radius, clipPlanes.planes); +} + +bool IsPointVisible(const in float3 position, const in float4 clipPlanes[6]) +{ + return IsSphereVisible(position, 0, clipPlanes); +} + +bool IsPointVisible(const in float3 position, const in ClipPlanes clipPlanes) +{ + return IsPointVisible(position, clipPlanes.planes); +} + +struct AxisAlignedBoundingBox { + float3 min; + float3 max; + + void Transform(const in float4x4 transform) + { + const float3 center = (max + min) * 0.5; + const float3 extents = max - center; + + const float3 transformedCenter = mul(transform, float4(center, 1.0)).xyz; + + float3x3 absMatrix = abs((float3x3)transform); + float3 transformedExtents = mul(absMatrix, extents); + + min = transformedCenter - transformedExtents; + max = transformedCenter + transformedExtents; + } + + bool IsVisible(const in float4 clipPlanes[6]) + { + for (int i = 0; i < 6; ++i) { + float4 plane = clipPlanes[i]; + + float3 axis = float3(plane.x < 0.f ? min.x : max.x, // + plane.y < 0.f ? min.y : max.y, // + plane.z < 0.f ? min.z : max.z); + + if ((dot(plane.xyz, axis) + plane.w) < 0.0f) { + return false; + } + } + + return true; + } + + bool IsVisible(const in ClipPlanes clipPlanes) + { + return IsVisible(clipPlanes.planes); + } + + bool IsVisible(const in float4x4 transform, const in float4 clipPlanes[6]) + { + AxisAlignedBoundingBox tmp = {min, max}; + tmp.Transform(transform); + + return tmp.IsVisible(clipPlanes); + } + + bool IsVisible(const in float4x4 transform, const in ClipPlanes clipPlanes) + { + return IsVisible(transform, clipPlanes.planes); + } +}; \ No newline at end of file diff --git a/meshNodeSample/shaders/workgraphcommon.h b/meshNodeSample/shaders/workgraphcommon.h new file mode 100644 index 0000000..5da31fc --- /dev/null +++ b/meshNodeSample/shaders/workgraphcommon.h @@ -0,0 +1,53 @@ +// This file is part of the AMD Work Graph Mesh Node Sample. +// +// Copyright (c) 2024 Advanced Micro Devices, Inc. All rights reserved. +// +// 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 +// AUTHORS OR COPYRIGHT HOLDERS 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. + +#pragma once + +#if __cplusplus +#include "misc/math.h" +#endif // __cplusplus + +#if __cplusplus +struct WorkGraphCBData { + Mat4 ViewProjection; + Mat4 PreviousViewProjection; + Mat4 InverseViewProjection; + Vec4 CameraPosition; + Vec4 PreviousCameraPosition; + uint32_t ShaderTime; + uint32_t PreviousShaderTime; + float WindStrength; + float WindDirection; +}; +#else +cbuffer WorkGraphCBData : register(b0) +{ + matrix ViewProjection; + matrix PreviousViewProjection; + matrix InverseViewProjection; + float4 CameraPosition; + float4 PreviousCameraPosition; + uint ShaderTime; + uint PreviousShaderTime; + float WindStrength; + float WindDirection; +} +#endif // __cplusplus \ No newline at end of file diff --git a/meshNodeSample/shaders/world.hlsl b/meshNodeSample/shaders/world.hlsl new file mode 100644 index 0000000..17fbe81 --- /dev/null +++ b/meshNodeSample/shaders/world.hlsl @@ -0,0 +1,176 @@ +// This file is part of the AMD Work Graph Mesh Node Sample. +// +// Copyright (c) 2024 Advanced Micro Devices, Inc. All rights reserved. +// +// 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 +// AUTHORS OR COPYRIGHT HOLDERS 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. + +#include "common.hlsl" + +// Record for launching a grid of chunks +// grid size & offset are computed based on current camera view +struct ChunkGridRecord { + uint2 grid : SV_DispatchGrid; + int2 offset; +}; + +float2 ComputeFarPlaneCorner(in float clipX, in float clipY) +{ + // compute position of frustum corner on far plane + const float3 cornerWorldPosition = PerspectiveProject(InverseViewProjection, float3(clipX, clipY, 1.f)); + + const float2 viewVector = cornerWorldPosition.xz - GetCameraPosition().xz; + const float viewVectorLength = length(viewVector); + // limit view vector to maximum terrain distance + const float viewVectorScale = min(worldGridMaxDistance / viewVectorLength, 1.f); + + return GetCameraPosition().xz + viewVector * viewVectorScale; +} + +void minmax(inout float2 minTerrainPosition, inout float2 maxTerrainPosition, in float2 position) +{ + minTerrainPosition = min(minTerrainPosition, position); + maxTerrainPosition = max(maxTerrainPosition, position); +} + +[Shader("node")] +[NodeLaunch("thread")] +void World( + [MaxRecords(1)] + [NodeId("ChunkGrid")] + NodeOutput chunkGridOutput) +{ + // This node computes the world-space extends of the chunk grid based on the current camera view frustum + + // Compute bounding box of view frustum + // Start with camera position + float2 minTerrainPosition = GetCameraPosition().xz; + float2 maxTerrainPosition = minTerrainPosition; + + // Add far plane corners to view frustum bounding box + minmax(minTerrainPosition, maxTerrainPosition, ComputeFarPlaneCorner(-1, -1)); + minmax(minTerrainPosition, maxTerrainPosition, ComputeFarPlaneCorner(-1, +1)); + minmax(minTerrainPosition, maxTerrainPosition, ComputeFarPlaneCorner(+1, -1)); + minmax(minTerrainPosition, maxTerrainPosition, ComputeFarPlaneCorner(+1, +1)); + + // Compute & round chunk coordinates + const int2 minChunkPosition = floor(minTerrainPosition / chunkSize); + const int2 maxChunkPosition = ceil(maxTerrainPosition / chunkSize); + + // Dispatch one thread group per chunk + ThreadNodeOutputRecords chunkGridRecord = chunkGridOutput.GetThreadNodeOutputRecords(1); + + chunkGridRecord.Get().grid = clamp(maxChunkPosition - minChunkPosition, 0, 32); + chunkGridRecord.Get().offset = minChunkPosition; + + chunkGridRecord.OutputComplete(); +} + +int GetTerrainChunkLevelOfDetail(in int2 chunkGridPosition) +{ + const float2 chunkWorldPosition = chunkGridPosition * chunkSize; + const float3 chunkWorldCenterPosition = GetTerrainPosition(chunkWorldPosition + chunkSize * 0.5); + const float distanceToCamera = distance(GetCameraPosition(), chunkWorldCenterPosition); + + return clamp(distanceToCamera / (3 * chunkSize), 0, 3); +} + +[Shader("node")] +[NodeLaunch("broadcasting")] +[NodeMaxDispatchGrid(32, 32, 1)] +// each thread corresponds to one tile +[NumThreads(tilesPerChunk, tilesPerChunk, 1)] +void ChunkGrid( + DispatchNodeInputRecord inputRecord, + + int2 groupId : SV_GroupId, + int2 groupThreadId : SV_GroupThreadID, + + [MaxRecords(1)] + [NodeId("DrawTerrainChunk")] + NodeOutput terrainOutput, + + [MaxRecords(tilesPerChunk * tilesPerChunk)] + [NodeId("Tile")] + [NodeArraySize(3)] + NodeOutputArray tileOutput) +{ + const ChunkGridRecord input = inputRecord.Get(); + const int2 chunkGridPosition = input.offset + groupId; + const float2 chunkWorldPosition = chunkGridPosition * chunkSize; + + const ClipPlanes clipPlanes = ComputeClipPlanes(); + + const AxisAlignedBoundingBox chunkBoundingBox = GetGridBoundingBox(chunkGridPosition, chunkSize, -100, 300); + const bool isChunkVisible = chunkBoundingBox.IsVisible(clipPlanes); + + // Terrain output + { + const bool hasTerrainOutput = isChunkVisible; + + GroupNodeOutputRecords terrainOutputRecord = + terrainOutput.GetGroupNodeOutputRecords(hasTerrainOutput); + + if (hasTerrainOutput) { + const int levelOfDetail = GetTerrainChunkLevelOfDetail(chunkGridPosition); + const uint dispatchSize = 8 / clamp(1U << levelOfDetail, 1, 8); + + terrainOutputRecord.Get().dispatchGrid = uint3(dispatchSize, dispatchSize, 1); + terrainOutputRecord.Get().chunkGridPosition = chunkGridPosition; + terrainOutputRecord.Get().levelOfDetail = levelOfDetail; + + terrainOutputRecord.Get().levelOfDetailTransition.x = + GetTerrainChunkLevelOfDetail(chunkGridPosition + int2(-1, 0)) > levelOfDetail; + terrainOutputRecord.Get().levelOfDetailTransition.y = + GetTerrainChunkLevelOfDetail(chunkGridPosition + int2(0, -1)) > levelOfDetail; + terrainOutputRecord.Get().levelOfDetailTransition.z = + GetTerrainChunkLevelOfDetail(chunkGridPosition + int2(1, 0)) > levelOfDetail; + terrainOutputRecord.Get().levelOfDetailTransition.w = + GetTerrainChunkLevelOfDetail(chunkGridPosition + int2(0, 1)) > levelOfDetail; + } + + terrainOutputRecord.OutputComplete(); + } + + // Tile output + if (isChunkVisible) + { + const int2 threadGridPosition = chunkGridPosition * tilesPerChunk + groupThreadId; + const float2 threadWorldPosition = threadGridPosition * tileSize; + + const AxisAlignedBoundingBox tileBoundingBox = GetGridBoundingBox(threadGridPosition, tileSize, -100, 300); + + const bool hasTileOutput = tileBoundingBox.IsVisible(clipPlanes); + + // Get biome weights in center of tile + const float3 biomeWeights = GetBiomeWeights(threadWorldPosition + tileSize * 0.5); + + // Classify biome tile to launch by dominant biome + const uint biome = biomeWeights.x > biomeWeights.y ? (biomeWeights.x > biomeWeights.z ? 0 : 2) + : (biomeWeights.y > biomeWeights.z ? 1 : 2); + + ThreadNodeOutputRecords tileOutputRecord = + tileOutput[biome].GetThreadNodeOutputRecords(hasTileOutput); + + if (hasTileOutput) { + + tileOutputRecord.Get().position = chunkGridPosition * tilesPerChunk + groupThreadId; + } + + tileOutputRecord.OutputComplete(); + } +} diff --git a/meshNodeSample/workgraphrendermodule.cpp b/meshNodeSample/workgraphrendermodule.cpp new file mode 100644 index 0000000..fc2176e --- /dev/null +++ b/meshNodeSample/workgraphrendermodule.cpp @@ -0,0 +1,538 @@ +// This file is part of the AMD Work Graph Mesh Node Sample. +// +// Copyright (c) 2024 Advanced Micro Devices, Inc. All rights reserved. +// +// 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 +// AUTHORS OR COPYRIGHT HOLDERS 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. + +#include "workgraphrendermodule.h" + +#include "core/framework.h" +#include "core/scene.h" +#include "core/uimanager.h" +#include "misc/assert.h" + +// Render components +#include "render/buffer.h" +#include "render/device.h" +#include "render/dynamicresourcepool.h" +#include "render/parameterset.h" +#include "render/pipelinedesc.h" +#include "render/pipelineobject.h" +#include "render/profiler.h" +#include "render/rasterview.h" +#include "render/rootsignature.h" +#include "render/rootsignaturedesc.h" +#include "render/texture.h" + +// D3D12 Cauldron implementation +#include "render/dx12/buffer_dx12.h" +#include "render/dx12/commandlist_dx12.h" +#include "render/dx12/device_dx12.h" +#include "render/dx12/gpuresource_dx12.h" +#include "render/dx12/rootsignature_dx12.h" + +// common files with shaders +#include "shaders/shadingcommon.h" +#include "shaders/workgraphcommon.h" + +// shader compiler +#include "shadercompiler.h" + +#include + +using namespace cauldron; + +// Name for work graph program inside the state object +static const wchar_t* WorkGraphProgramName = L"WorkGraph"; + +WorkGraphRenderModule::WorkGraphRenderModule() + : RenderModule(L"WorkGraphRenderModule") +{ +} + +WorkGraphRenderModule::~WorkGraphRenderModule() +{ + // Delete work graph + if (m_pWorkGraphStateObject) + m_pWorkGraphStateObject->Release(); + if (m_pWorkGraphParameterSet) + delete m_pWorkGraphParameterSet; + if (m_pWorkGraphRootSignature) + delete m_pWorkGraphRootSignature; + if (m_pWorkGraphBackingMemoryBuffer) + delete m_pWorkGraphBackingMemoryBuffer; + + // Delete shading pipeline + if (m_pShadingPipeline) + delete m_pShadingPipeline; + if (m_pShadingRootSignature) + delete m_pShadingRootSignature; + if (m_pShadingParameterSet) + delete m_pShadingParameterSet; +} + +void WorkGraphRenderModule::Init(const json& initData) +{ + InitTextures(); + InitWorkGraphProgram(); + InitShadingPipeline(); + + cauldron::UISection uiSection = {}; + uiSection.SectionName = "Procedural Generation"; + + uiSection.AddFloatSlider("Wind Strength", &m_WindStrength, 0.f, 2.5f); + uiSection.AddFloatSlider("Wind Direction", &m_WindDirection, 0.f, 360.f, nullptr, nullptr, false, "%.1f"); + + GetUIManager()->RegisterUIElements(uiSection); + + SetModuleReady(true); +} + +void WorkGraphRenderModule::Execute(double deltaTime, cauldron::CommandList* pCmdList) +{ + const auto previousShaderTime = m_shaderTime; + + // Increment shader time + m_shaderTime += static_cast(deltaTime * 1000.0); + + // Get render resolution based on upscaler state + const auto upscaleState = GetFramework()->GetUpscalingState(); + const auto& resInfo = GetFramework()->GetResolutionInfo(); + + uint32_t width, height; + if (upscaleState == UpscalerState::None || upscaleState == UpscalerState::PostUpscale) + { + width = resInfo.DisplayWidth; + height = resInfo.DisplayHeight; + } + else + { + width = resInfo.RenderWidth; + height = resInfo.RenderHeight; + } + + { + GPUScopedProfileCapture workGraphMarker(pCmdList, L"Work Graph"); + + std::vector barriers; + barriers.push_back(Barrier::Transition(m_pGBufferColorOutput->GetResource(), + ResourceState::NonPixelShaderResource | ResourceState::PixelShaderResource, + ResourceState::RenderTargetResource)); + barriers.push_back(Barrier::Transition(m_pGBufferNormalOutput->GetResource(), + ResourceState::NonPixelShaderResource | ResourceState::PixelShaderResource, + ResourceState::RenderTargetResource)); + barriers.push_back(Barrier::Transition(m_pGBufferMotionOutput->GetResource(), + ResourceState::NonPixelShaderResource | ResourceState::PixelShaderResource, + ResourceState::RenderTargetResource)); + barriers.push_back(Barrier::Transition( + m_pGBufferDepthOutput->GetResource(), ResourceState::NonPixelShaderResource | ResourceState::PixelShaderResource, ResourceState::DepthWrite)); + + ResourceBarrier(pCmdList, static_cast(barriers.size()), barriers.data()); + + // Clear color targets + float clearColor[4] = {0.0f, 0.0f, 0.0f, 0.0f}; + for (const auto* rasterView : m_pGBufferRasterViews) + { + ClearRenderTarget(pCmdList, &rasterView->GetResourceView(), clearColor); + } + + // Clear depth target + ClearDepthStencil(pCmdList, &m_pGBufferDepthRasterView->GetResourceView(), 0); + + // Begin raster with render targets + BeginRaster(pCmdList, static_cast(m_pGBufferRasterViews.size()), m_pGBufferRasterViews.data(), m_pGBufferDepthRasterView, nullptr); + SetViewportScissorRect(pCmdList, 0, 0, width, height, 0.f, 1.f); + + const auto* currentCamera = GetScene()->GetCurrentCamera(); + + WorkGraphCBData workGraphData = {}; + workGraphData.ViewProjection = currentCamera->GetProjectionJittered() * currentCamera->GetView(); + workGraphData.PreviousViewProjection = currentCamera->GetPrevProjectionJittered() * currentCamera->GetPreviousView(); + workGraphData.InverseViewProjection = InverseMatrix(workGraphData.ViewProjection); + workGraphData.CameraPosition = currentCamera->GetCameraTranslation(); + workGraphData.PreviousCameraPosition = InverseMatrix(currentCamera->GetPreviousView()).getCol3(); + workGraphData.ShaderTime = m_shaderTime; + workGraphData.PreviousShaderTime = previousShaderTime; + workGraphData.WindStrength = m_WindStrength; + workGraphData.WindDirection = DEG_TO_RAD(m_WindDirection); + + BufferAddressInfo workGraphDataInfo = GetDynamicBufferPool()->AllocConstantBuffer(sizeof(WorkGraphCBData), &workGraphData); + m_pWorkGraphParameterSet->UpdateRootConstantBuffer(&workGraphDataInfo, 0); + + // Bind all the parameters + m_pWorkGraphParameterSet->Bind(pCmdList, nullptr); + + // Dispatch the work graph + { + D3D12_DISPATCH_GRAPH_DESC dispatchDesc = {}; + dispatchDesc.Mode = D3D12_DISPATCH_MODE_NODE_CPU_INPUT; + dispatchDesc.NodeCPUInput = {}; + dispatchDesc.NodeCPUInput.EntrypointIndex = m_WorkGraphEntryPointIndex; + // Launch graph with one record + dispatchDesc.NodeCPUInput.NumRecords = 1; + // Record does not contain any data + dispatchDesc.NodeCPUInput.RecordStrideInBytes = 0; + dispatchDesc.NodeCPUInput.pRecords = nullptr; + + // Get ID3D12GraphicsCommandList10 from Cauldron command list + ID3D12GraphicsCommandList10* commandList; + CauldronThrowOnFail(pCmdList->GetImpl()->DX12CmdList()->QueryInterface(IID_PPV_ARGS(&commandList))); + + commandList->SetProgram(&m_WorkGraphProgramDesc); + commandList->DispatchGraph(&dispatchDesc); + + // Release command list (only releases additional reference created by QueryInterface) + commandList->Release(); + + // Clear backing memory initialization flag, as the graph has run at least once now + m_WorkGraphProgramDesc.WorkGraph.Flags &= ~D3D12_SET_WORK_GRAPH_FLAG_INITIALIZE; + } + + EndRaster(pCmdList, nullptr); + + // Transition render targets back to readable state + for (auto& barrier : barriers) + { + std::swap(barrier.DestState, barrier.SourceState); + } + + ResourceBarrier(pCmdList, static_cast(barriers.size()), barriers.data()); + } + + { + GPUScopedProfileCapture shadingMarker(pCmdList, L"Shading"); + + // Render modules expect resources coming in/going out to be in a shader read state + Barrier barrier = Barrier::Transition( + m_pShadingOutput->GetResource(), ResourceState::NonPixelShaderResource | ResourceState::PixelShaderResource, ResourceState::UnorderedAccess); + ResourceBarrier(pCmdList, 1, &barrier); + + BufferAddressInfo upscaleInfo = + GetDynamicBufferPool()->AllocConstantBuffer(sizeof(UpscalerInformation), &GetScene()->GetSceneInfo().UpscalerInfo.FullScreenScaleRatio); + m_pShadingParameterSet->UpdateRootConstantBuffer(&upscaleInfo, 0); + + const auto* currentCamera = GetScene()->GetCurrentCamera(); + + ShadingCBData shadingData = {}; + shadingData.InverseViewProjection = InverseMatrix(currentCamera->GetProjectionJittered() * currentCamera->GetView()); + shadingData.CameraPosition = currentCamera->GetCameraTranslation(); + + BufferAddressInfo shadingInfo = GetDynamicBufferPool()->AllocConstantBuffer(sizeof(ShadingCBData), &shadingData); + m_pShadingParameterSet->UpdateRootConstantBuffer(&shadingInfo, 1); + + // Bind all the parameters + m_pShadingParameterSet->Bind(pCmdList, m_pShadingPipeline); + + SetPipelineState(pCmdList, m_pShadingPipeline); + + const uint32_t numGroupX = DivideRoundingUp(width, s_shadingThreadGroupSizeX); + const uint32_t numGroupY = DivideRoundingUp(height, s_shadingThreadGroupSizeY); + Dispatch(pCmdList, numGroupX, numGroupY, 1); + + // Render modules expect resources coming in/going out to be in a shader read state + barrier = Barrier::Transition( + m_pShadingOutput->GetResource(), ResourceState::UnorderedAccess, ResourceState::NonPixelShaderResource | ResourceState::PixelShaderResource); + ResourceBarrier(pCmdList, 1, &barrier); + } +} + +void WorkGraphRenderModule::OnResize(const cauldron::ResolutionInfo& resInfo) +{ +} + +void WorkGraphRenderModule::InitTextures() +{ + m_pShadingOutput = GetFramework()->GetColorTargetForCallback(GetName()); + CauldronAssert(ASSERT_CRITICAL, m_pShadingOutput != nullptr, L"Couldn't find or create the render target of WorkGraphRenderModule."); + + m_pGBufferColorOutput = GetFramework()->GetRenderTexture(L"GBufferColorTarget"); + m_pGBufferNormalOutput = GetFramework()->GetRenderTexture(L"GBufferNormalTarget"); + m_pGBufferMotionOutput = GetFramework()->GetRenderTexture(L"GBufferMotionVectorTarget"); + m_pGBufferDepthOutput = GetFramework()->GetRenderTexture(L"GBufferDepthTarget"); + + m_pGBufferRasterViews[0] = GetRasterViewAllocator()->RequestRasterView(m_pGBufferColorOutput, ViewDimension::Texture2D); + m_pGBufferRasterViews[1] = GetRasterViewAllocator()->RequestRasterView(m_pGBufferNormalOutput, ViewDimension::Texture2D); + m_pGBufferRasterViews[2] = GetRasterViewAllocator()->RequestRasterView(m_pGBufferMotionOutput, ViewDimension::Texture2D); + + m_pGBufferDepthRasterView = GetRasterViewAllocator()->RequestRasterView(m_pGBufferDepthOutput, ViewDimension::Texture2D); +} + +void WorkGraphRenderModule::InitWorkGraphProgram() +{ + // Create root signature for work graph + RootSignatureDesc workGraphRootSigDesc; + workGraphRootSigDesc.AddConstantBufferView(0, ShaderBindStage::Compute, 1); + // Work graphs with mesh nodes use graphics root signature instead of compute root signature + workGraphRootSigDesc.m_PipelineType = PipelineType::Graphics; + + m_pWorkGraphRootSignature = RootSignature::CreateRootSignature(L"MeshNodeSample_WorkGraphRootSignature", workGraphRootSigDesc); + + // Create parameter set for root signature + m_pWorkGraphParameterSet = ParameterSet::CreateParameterSet(m_pWorkGraphRootSignature); + m_pWorkGraphParameterSet->SetRootConstantBufferResource(GetDynamicBufferPool()->GetResource(), sizeof(WorkGraphCBData), 0); + + // Get D3D12 device + // CreateStateObject is only available on ID3D12Device9 + ID3D12Device9* d3dDevice = nullptr; + CauldronThrowOnFail(GetDevice()->GetImpl()->DX12Device()->QueryInterface(IID_PPV_ARGS(&d3dDevice))); + + // Check if mesh nodes are supported + { + D3D12_FEATURE_DATA_D3D12_OPTIONS21 options = {}; + CauldronThrowOnFail(d3dDevice->CheckFeatureSupport(D3D12_FEATURE_D3D12_OPTIONS21, &options, sizeof(options))); + + // check if work graphs tier 1.1 (mesh nodes) is supported + if (options.WorkGraphsTier < D3D12_WORK_GRAPHS_TIER_1_1) + { + CauldronCritical(L"Work graphs tier 1.1 (mesh nodes) are not supported on the current device."); + } + } + + // Create work graph + CD3DX12_STATE_OBJECT_DESC stateObjectDesc(D3D12_STATE_OBJECT_TYPE_EXECUTABLE); + + // configure draw nodes to use graphics root signature + auto configSubobject = stateObjectDesc.CreateSubobject(); + configSubobject->SetFlags(D3D12_STATE_OBJECT_FLAG_WORK_GRAPHS_USE_GRAPHICS_STATE_FOR_GLOBAL_ROOT_SIGNATURE); + + // set root signature for work graph + auto rootSignatureSubobject = stateObjectDesc.CreateSubobject(); + rootSignatureSubobject->SetRootSignature(m_pWorkGraphRootSignature->GetImpl()->DX12RootSignature()); + + auto workgraphSubobject = stateObjectDesc.CreateSubobject(); + workgraphSubobject->IncludeAllAvailableNodes(); + workgraphSubobject->SetProgramName(WorkGraphProgramName); + + // add DXIL shader libraries + ShaderCompiler shaderCompiler; + + // list of compiled shaders to be released once the work graph is created + std::vector compiledShaders; + + // Helper function for adding a shader library to the work graph state object + const auto AddShaderLibrary = [&](const wchar_t* shaderFileName) { + // compile shader as library + auto* blob = shaderCompiler.CompileShader(shaderFileName, L"lib_6_9", nullptr); + auto shaderBytecode = CD3DX12_SHADER_BYTECODE(blob->GetBufferPointer(), blob->GetBufferSize()); + + // add blob to state object + auto librarySubobject = stateObjectDesc.CreateSubobject(); + librarySubobject->SetDXILLibrary(&shaderBytecode); + + // add shader blob to be released later + compiledShaders.push_back(blob); + }; + + // Helper function for adding a pixel shader to the work graph state object + // Pixel shaders need to be compiled with "ps" target and as such the DXIL library object needs to specify a name + // for the pixel shader (exportName) with which the generic program can reference the pixel shader + const auto AddPixelShader = [&](const wchar_t* shaderFileName, const wchar_t* entryPoint) { + // compile shader as pixel shader + auto* blob = shaderCompiler.CompileShader(shaderFileName, L"ps_6_9", entryPoint); + auto shaderBytecode = CD3DX12_SHADER_BYTECODE(blob->GetBufferPointer(), blob->GetBufferSize()); + + // add blob to state object + auto librarySubobject = stateObjectDesc.CreateSubobject(); + librarySubobject->SetDXILLibrary(&shaderBytecode); + + // add shader blob to be released later + compiledShaders.push_back(blob); + }; + + // =================================================================== + // State object for graphics PSO state description in generic programs + + // Rasterizer state configuration without culling + auto rasterizerNoCullingSubobject = stateObjectDesc.CreateSubobject(); + rasterizerNoCullingSubobject->SetFrontCounterClockwise(true); + rasterizerNoCullingSubobject->SetFillMode(D3D12_FILL_MODE_SOLID); + rasterizerNoCullingSubobject->SetCullMode(D3D12_CULL_MODE_NONE); + + // Rasterizer state configuration with backface culling + auto rasterizerBackfaceCullingSubobject = stateObjectDesc.CreateSubobject(); + rasterizerBackfaceCullingSubobject->SetFrontCounterClockwise(true); + rasterizerBackfaceCullingSubobject->SetFillMode(D3D12_FILL_MODE_SOLID); + rasterizerBackfaceCullingSubobject->SetCullMode(D3D12_CULL_MODE_BACK); + + // Primitive topology configuration + auto primitiveTopologySubobject = stateObjectDesc.CreateSubobject(); + primitiveTopologySubobject->SetPrimitiveTopologyType(D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE); + + // Depth stencil format configuration + auto depthStencilFormatSubobject = stateObjectDesc.CreateSubobject(); + depthStencilFormatSubobject->SetDepthStencilFormat(GetDXGIFormat(m_pGBufferDepthOutput->GetFormat())); + + // Render target format configuration + auto renderTargetFormatSubobject = stateObjectDesc.CreateSubobject(); + renderTargetFormatSubobject->SetNumRenderTargets(3); + renderTargetFormatSubobject->SetRenderTargetFormat(0, GetDXGIFormat(m_pGBufferColorOutput->GetFormat())); + renderTargetFormatSubobject->SetRenderTargetFormat(1, GetDXGIFormat(m_pGBufferNormalOutput->GetFormat())); + renderTargetFormatSubobject->SetRenderTargetFormat(2, GetDXGIFormat(m_pGBufferMotionOutput->GetFormat())); + + // ============================= + // Generic programs (mesh nodes) + + // Helper function to add a mesh node generic program subobject + const auto AddMeshNode = [&](const wchar_t* meshShaderExportName, const wchar_t* pixelShaderExportName, bool backfaceCulling) { + auto genericProgramSubobject = stateObjectDesc.CreateSubobject(); + // add mesh shader + genericProgramSubobject->AddExport(meshShaderExportName); + // add pixel shader + genericProgramSubobject->AddExport(pixelShaderExportName); + + // add graphics state subobjects + if (backfaceCulling) + { + genericProgramSubobject->AddSubobject(*rasterizerBackfaceCullingSubobject); + } + else + { + genericProgramSubobject->AddSubobject(*rasterizerNoCullingSubobject); + } + genericProgramSubobject->AddSubobject(*primitiveTopologySubobject); + genericProgramSubobject->AddSubobject(*depthStencilFormatSubobject); + genericProgramSubobject->AddSubobject(*renderTargetFormatSubobject); + }; + + // =================================== + // Add shader libraries and mesh nodes + + // Shader libraries for procedural world generation + AddShaderLibrary(L"world.hlsl"); + AddShaderLibrary(L"biomes.hlsl"); + AddShaderLibrary(L"tree.hlsl"); + AddShaderLibrary(L"rock.hlsl"); + + // Terrain Mesh Node + AddShaderLibrary(L"terrainrenderer.hlsl"); + AddPixelShader(L"terrainrenderer.hlsl", L"TerrainPixelShader"); + AddMeshNode(L"TerrainMeshShader", L"TerrainPixelShader", true); + + // Spline Mesh Node for trees & rocks + AddShaderLibrary(L"splinerenderer.hlsl"); + AddPixelShader(L"splinerenderer.hlsl", L"SplinePixelShader"); + AddMeshNode(L"SplineMeshShader", L"SplinePixelShader", true); + + // Grass Nodes + AddShaderLibrary(L"densegrassmeshshader.hlsl"); + AddShaderLibrary(L"sparsegrassmeshshader.hlsl"); + AddPixelShader(L"grasspixelshader.hlsl", L"GrassPixelShader"); + AddMeshNode(L"DenseGrassMeshShader", L"GrassPixelShader", false); + AddMeshNode(L"SparseGrassMeshShader", L"GrassPixelShader", false); + + // Flowers, Insects & Mushroom Nodes + AddShaderLibrary(L"beemeshshader.hlsl"); + AddShaderLibrary(L"butterflymeshshader.hlsl"); + AddShaderLibrary(L"flowermeshshader.hlsl"); + AddShaderLibrary(L"mushroommeshshader.hlsl"); + AddPixelShader(L"insectpixelshader.hlsl", L"InsectPixelShader"); + AddMeshNode(L"BeeMeshShader", L"InsectPixelShader", false); + AddMeshNode(L"ButterflyMeshShader", L"InsectPixelShader", false); + AddMeshNode(L"FlowerMeshShader", L"InsectPixelShader", false); + AddMeshNode(L"SparseFlowerMeshShader", L"InsectPixelShader", false); + AddMeshNode(L"MushroomMeshShader", L"InsectPixelShader", false); + + // Create work graph state object + CauldronThrowOnFail(d3dDevice->CreateStateObject(stateObjectDesc, IID_PPV_ARGS(&m_pWorkGraphStateObject))); + + // release all compiled shaders + for (auto* shader : compiledShaders) + { + if (shader) + { + shader->Release(); + } + } + + // Get work graph properties + ID3D12StateObjectProperties1* stateObjectProperties; + ID3D12WorkGraphProperties1* workGraphProperties; + + CauldronThrowOnFail(m_pWorkGraphStateObject->QueryInterface(IID_PPV_ARGS(&stateObjectProperties))); + CauldronThrowOnFail(m_pWorkGraphStateObject->QueryInterface(IID_PPV_ARGS(&workGraphProperties))); + + // Get the index of our work graph inside the state object (state object can contain multiple work graphs) + const auto workGraphIndex = workGraphProperties->GetWorkGraphIndex(WorkGraphProgramName); + + // Set the input record limit. This is required for work graphs with mesh nodes. + // In this case we'll only have a single input record + workGraphProperties->SetMaximumInputRecords(workGraphIndex, 1, 1); + + // Create backing memory buffer + D3D12_WORK_GRAPH_MEMORY_REQUIREMENTS memoryRequirements = {}; + workGraphProperties->GetWorkGraphMemoryRequirements(workGraphIndex, &memoryRequirements); + if (memoryRequirements.MaxSizeInBytes > 0) + { + BufferDesc bufferDesc = BufferDesc::Data(L"MeshNodeSample_WorkGraphBackingMemory", + static_cast(memoryRequirements.MaxSizeInBytes), + 1, + D3D12_WORK_GRAPHS_BACKING_MEMORY_ALIGNMENT_IN_BYTES, + ResourceFlags::AllowUnorderedAccess); + + m_pWorkGraphBackingMemoryBuffer = Buffer::CreateBufferResource(&bufferDesc, ResourceState::UnorderedAccess); + } + + // Prepare work graph desc + m_WorkGraphProgramDesc.Type = D3D12_PROGRAM_TYPE_WORK_GRAPH; + m_WorkGraphProgramDesc.WorkGraph.ProgramIdentifier = stateObjectProperties->GetProgramIdentifier(WorkGraphProgramName); + // Set flag to initialize backing memory. + // We'll clear this flag once we've run the work graph for the first time. + m_WorkGraphProgramDesc.WorkGraph.Flags = D3D12_SET_WORK_GRAPH_FLAG_INITIALIZE; + // Set backing memory + if (m_pWorkGraphBackingMemoryBuffer) + { + const auto addressInfo = m_pWorkGraphBackingMemoryBuffer->GetAddressInfo(); + m_WorkGraphProgramDesc.WorkGraph.BackingMemory.StartAddress = addressInfo.GetImpl()->GPUBufferView; + m_WorkGraphProgramDesc.WorkGraph.BackingMemory.SizeInBytes = addressInfo.GetImpl()->SizeInBytes; + } + + // Query entry point index + m_WorkGraphEntryPointIndex = workGraphProperties->GetEntrypointIndex(workGraphIndex, {L"World", 0}); + + // Release state object properties + stateObjectProperties->Release(); + workGraphProperties->Release(); + + // Release ID3D12Device9 (only releases additional reference created by QueryInterface) + d3dDevice->Release(); +} + +void WorkGraphRenderModule::InitShadingPipeline() +{ + RootSignatureDesc shadingRootSigDesc; + shadingRootSigDesc.AddConstantBufferView(0, ShaderBindStage::Compute, 1); + shadingRootSigDesc.AddConstantBufferView(1, ShaderBindStage::Compute, 1); + shadingRootSigDesc.AddTextureSRVSet(0, ShaderBindStage::Compute, 2); + shadingRootSigDesc.AddTextureUAVSet(0, ShaderBindStage::Compute, 1); + + m_pShadingRootSignature = RootSignature::CreateRootSignature(L"MeshNodeSample_ShadingRootSignature", shadingRootSigDesc); + + PipelineDesc shadingPsoDesc; + shadingPsoDesc.SetRootSignature(m_pShadingRootSignature); + shadingPsoDesc.AddShaderDesc(ShaderBuildDesc::Compute(L"shading.hlsl", L"MainCS", ShaderModel::SM6_0)); + + m_pShadingPipeline = PipelineObject::CreatePipelineObject(L"MeshNodeSample_ShadingPipeline", shadingPsoDesc); + + m_pShadingParameterSet = ParameterSet::CreateParameterSet(m_pShadingRootSignature); + + m_pShadingParameterSet->SetRootConstantBufferResource(GetDynamicBufferPool()->GetResource(), sizeof(UpscalerInformation), 0); + m_pShadingParameterSet->SetRootConstantBufferResource(GetDynamicBufferPool()->GetResource(), sizeof(ShadingCBData), 1); + m_pShadingParameterSet->SetTextureSRV(m_pGBufferColorOutput, ViewDimension::Texture2D, 0); + m_pShadingParameterSet->SetTextureSRV(m_pGBufferNormalOutput, ViewDimension::Texture2D, 1); + m_pShadingParameterSet->SetTextureUAV(m_pShadingOutput, ViewDimension::Texture2D, 0); +} diff --git a/meshNodeSample/workgraphrendermodule.h b/meshNodeSample/workgraphrendermodule.h new file mode 100644 index 0000000..aa09dc1 --- /dev/null +++ b/meshNodeSample/workgraphrendermodule.h @@ -0,0 +1,104 @@ +// This file is part of the AMD Work Graph Mesh Node Sample. +// +// Copyright (c) 2024 Advanced Micro Devices, Inc. All rights reserved. +// +// 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 +// AUTHORS OR COPYRIGHT HOLDERS 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. + +#pragma once + +#include "render/rendermodule.h" +#include "render/shaderbuilder.h" + +// d3dx12 for work graphs +#include "d3dx12/d3dx12.h" + +// Forward declaration of Cauldron classes +namespace cauldron +{ + class Buffer; + class ParameterSet; + class PipelineObject; + class RasterView; + class RootSignature; + class Texture; +} // namespace cauldron + +class WorkGraphRenderModule : public cauldron::RenderModule +{ +public: + WorkGraphRenderModule(); + virtual ~WorkGraphRenderModule(); + + /** + * @brief Initialize work graphs, UI & other contexts + */ + void Init(const json& initData) override; + + /** + * @brief Execute the work graph. + */ + void Execute(double deltaTime, cauldron::CommandList* pCmdList) override; + + /** + * @brief Called by the framework when resolution changes. + */ + void OnResize(const cauldron::ResolutionInfo& resInfo) override; + +private: + /** + * @brief Create and initialize textures required for rendering and shading. + */ + void InitTextures(); + /** + * @brief Create and initialize the work graph program with mesh nodes. + */ + void InitWorkGraphProgram(); + /** + * @brief Create and initialize the shading compute pipeline. + */ + void InitShadingPipeline(); + + // time variable for shader animations in milliseconds + uint32_t m_shaderTime = 0; + + // UI controlled settings + float m_WindStrength = 1.f; + float m_WindDirection = 0.f; + + const cauldron::Texture* m_pGBufferDepthOutput = nullptr; + const cauldron::RasterView* m_pGBufferDepthRasterView = nullptr; + const cauldron::Texture* m_pGBufferColorOutput = nullptr; + const cauldron::Texture* m_pGBufferNormalOutput = nullptr; + const cauldron::Texture* m_pGBufferMotionOutput = nullptr; + std::array m_pGBufferRasterViews; + + cauldron::RootSignature* m_pWorkGraphRootSignature = nullptr; + cauldron::ParameterSet* m_pWorkGraphParameterSet = nullptr; + ID3D12StateObject* m_pWorkGraphStateObject = nullptr; + cauldron::Buffer* m_pWorkGraphBackingMemoryBuffer = nullptr; + // Program description for binding the work graph + // contains work graph identifier & backing memory + D3D12_SET_PROGRAM_DESC m_WorkGraphProgramDesc = {}; + // Index of entry point node + UINT m_WorkGraphEntryPointIndex = 0; + + const cauldron::Texture* m_pShadingOutput = nullptr; + cauldron::RootSignature* m_pShadingRootSignature = nullptr; + cauldron::ParameterSet* m_pShadingParameterSet = nullptr; + cauldron::PipelineObject* m_pShadingPipeline = nullptr; +}; \ No newline at end of file diff --git a/readme.md b/readme.md new file mode 100644 index 0000000..7434d99 --- /dev/null +++ b/readme.md @@ -0,0 +1,60 @@ +# Work Graphs Mesh Node Sample + +![](./screenshot.jpg) + +This sample shows fully GPU-driven rendering through work graphs and mesh nodes in action. +If you wish to learn more about this sample, work graphs or mesh nodes, you can check out our accompanying blog post on [GPUOpen](https://gpuopen.com/learn/work_graphs_mesh_nodes). + +## Building the sample + +### Prerequisites + +To build the Work Graphs Mesh Node Sample, you must first install the following tools: + +- [CMake 3.17](https://cmake.org/download/) +- [Visual Studio 2019](https://visualstudio.microsoft.com/downloads/) +- [Windows 10 SDK 10.0.18362.0](https://developer.microsoft.com/en-us/windows/downloads/windows-10-sdk) +- [Vulkan SDK 1.3.239](https://vulkan.lunarg.com/) (build dependency of Cauldron) + +You will also need a mesh node compatible driver. Information on driver availability can be found [here](https://gpuopen.com/learn/work_graphs_mesh_nodes/work_graphs_mesh_nodes-getting_started). + +### Getting up and running + +Clone the repository +``` +git clone https://github.com/GPUOpen-LibrariesAndSDKs/WorkGraphsMeshNodeSample.git +``` + +Inside the cloned repository, run +``` +cmake -B build . +``` +This will download the [FidelityFX SDK](https://github.com/GPUOpen-LibrariesAndSDKs/FidelityFX-SDK/tree/release-FSR3-3.0.4), [Agility SDK](https://www.nuget.org/packages/Microsoft.Direct3D.D3D12) and [Direct X Shader Compiler](https://www.nuget.org/packages/Microsoft.Direct3D.DXC) and put them all together with the sample project. +You can find the scripts for this in the [`imported`](./imported/) folder. + +Open the generated Visual Studio project with +``` +cmake --open build +``` + +Build & run the `MeshNodeSample` project. + +### Controls + +| Key | Action | +| ---------------------|---------------------------------------------------------------------------------| +| **Left Mouse + Drag**| Rotates the camera view direction. | +| **Mouse wheel** | Increase/Decrease camera movement speed. | +| **A** | Strafe the camera to the left. | +| **W** | Move the camera forward. | +| **S** | Strafe the camera to the right. | +| **D** | Move the camera backward. | +| **Q** | Move the camera upwards. | +| **E** | Move the camera downwards. | +| **F1** | Toggles the main UI on/off. | +| **F2** | Toggles the performance UI on/off. | +| **F3** | Toggles the message log UI on/off. (Defaults to on in debug and off in release) | +| **M** | Toggles magnifying glass. | +| **L** | Toggles magnifying glass lock when enabled. | +| **ESC** | Shutsdown and quits sample. | +| **Alt-Enter** | Toggles fullscreen mode. | \ No newline at end of file diff --git a/screenshot.jpg b/screenshot.jpg new file mode 100644 index 0000000000000000000000000000000000000000..c9615e43197b8a0b2f9a63ac96459d3be5b45acf GIT binary patch literal 946040 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�d650+&p8EsJ^EIkhc2S=mX6=r*2^2j-dbHL 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
f+}b$b)bF_r4c_dF&(6BEKIg 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 G+VwxsNVPKn literal 0 HcmV?d00001

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%0Ad_0IQ?md81&+9($s@W*-kFh|XaL5#$ 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 z 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 *@kg%0IJ<`5~Qbx&q@adlp5 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

4y0Av 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 &~+i{HuuZQ_H6K$5S)M<-eH0 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 jD8iB4~BIQ3*1g_ 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 #@|l8YQ>zb4Z9(YQZ@jRa1W{AQcq_z8Or%= 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¨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