XinJiangBBH_LBE/Plugins/Streamline/Source/StreamlineRHI/Public/StreamlineAPI.h

/*
* Copyright (c) 2022 - 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
*
* NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
* property and proprietary rights in and to this material, related
* documentation and any modifications thereto. Any use, reproduction,
* disclosure or distribution of this material and related documentation
* without an express license agreement from NVIDIA CORPORATION or
* its affiliates is strictly prohibited.
*/
#pragma once

#include "CoreMinimal.h"

#include "sl.h"
#include "sl_helpers.h"
#include "sl_dlss_g.h"
#include "sl_deepdvc.h"


// Those are the actual Streamline API calls
extern STREAMLINERHI_API sl::Result SLinit(const sl::Preferences& pref, uint64_t sdkVersion = sl::kSDKVersion);
extern STREAMLINERHI_API sl::Result SLshutdown();
extern STREAMLINERHI_API sl::Result SLisFeatureSupported(sl::Feature feature, const sl::AdapterInfo& adapterInfo);
extern STREAMLINERHI_API sl::Result SLisFeatureLoaded(sl::Feature feature, bool& loaded);
extern STREAMLINERHI_API sl::Result SLsetFeatureLoaded(sl::Feature feature, bool loaded);
extern STREAMLINERHI_API sl::Result SLevaluateFeature(sl::Feature feature, const sl::FrameToken& frame, const sl::BaseStructure** inputs, uint32_t numInputs, sl::CommandBuffer* cmdBuffer);
extern STREAMLINERHI_API sl::Result SLAllocateResources(sl::CommandBuffer* cmdBuffer, sl::Feature feature, const sl::ViewportHandle& viewport);
extern STREAMLINERHI_API sl::Result SLFreeResources(sl::Feature feature, const sl::ViewportHandle& viewport);
extern STREAMLINERHI_API sl::Result SLsetTag(const sl::ViewportHandle& viewport, const sl::ResourceTag* tags, uint32_t numTags, sl::CommandBuffer* cmdBuffer);
extern STREAMLINERHI_API sl::Result SLgetFeatureRequirements(sl::Feature feature, sl::FeatureRequirements& requirements);
extern STREAMLINERHI_API sl::Result SLgetFeatureVersion(sl::Feature feature, sl::FeatureVersion& version);
extern STREAMLINERHI_API sl::Result SLUpgradeInterface(void** baseInterface);
extern STREAMLINERHI_API sl::Result SLsetConstants(const sl::Constants& values, const sl::FrameToken& frame, const sl::ViewportHandle& viewport);
extern STREAMLINERHI_API sl::Result SLgetNativeInterface(void* proxyInterface, void** baseInterface);
extern STREAMLINERHI_API sl::Result SLgetFeatureFunction(sl::Feature feature, const char* functionName, void*& function);
extern STREAMLINERHI_API sl::Result SLgetNewFrameToken(sl::FrameToken*& token, uint32_t* frameIndex = nullptr);
extern STREAMLINERHI_API sl::Result SLsetD3DDevice(void* d3dDevice);


extern STREAMLINERHI_API void LogStreamlineFunctionCall(const FString& Function, const FString& Arguments);

struct StringifySLArgument
{
	TArray<FString> ArgStrings;
	
	template <typename Whatever>
	void operator()(const Whatever& In)
	{
		ArgStrings.Add(FString::Printf(TEXT("arg%d"), ArgStrings.Num()));
	}

	void operator()(const sl::PCLMarker& In)
	{
		ArgStrings.Add(FString(ANSI_TO_TCHAR(sl::getPCLMarkerAsStr(In))));
	}

	void operator()(const sl::FrameToken& In)
	{
		ArgStrings.Add(FString::Printf(TEXT("frame=%u"), In.operator unsigned int()));
	}

	void operator()(const sl::ViewportHandle& In)
	{
		ArgStrings.Add(FString::Printf(TEXT("viewport=%u"), In.operator unsigned int()));
	}

	// sl_helpers.h, where are thou?
	inline const char* getDLSSGModeAsStr(sl::DLSSGMode mode)
	{
		switch (mode)
		{
			SL_CASE_STR(sl::DLSSGMode::eOff);
			SL_CASE_STR(sl::DLSSGMode::eOn);
			SL_CASE_STR(sl::DLSSGMode::eAuto);
			SL_CASE_STR(sl::DLSSGMode::eCount);
		};
		return "Unknown";
	}

	void operator()(const sl::DLSSGOptions& In)
	{
		ArgStrings.Add(FString(ANSI_TO_TCHAR(getDLSSGModeAsStr(In.mode))));
	}

	void operator()(const sl::DeepDVCOptions& In)
	{
		ArgStrings.Add(FString::Printf(TEXT("%s intensity=%.3f saturationBoost=%.3f"), ANSI_TO_TCHAR(getDeepDVCModeAsStr(In.mode)), In.intensity, In.saturationBoost));
	}

	FString GetJoinedArgString() const
	{
		return FString::Join(ArgStrings, TEXT(", "));
	}
};




// Convenience function template and macro for using SLgetFeatureFunction
//
// Example use:
//	sl::Result Result = CALL_SL_FEATURE_FN(sl::kFeatureReflex, slReflexSleep, *FrameToken);
template<typename F, typename... Ts> static sl::Result CallSLFeatureFn(sl::Feature Feature, const char* FunctionName, Ts&&... args)
{
	static F PtrFn = nullptr;
	if (PtrFn == nullptr)
	{
		sl::Result Result = SLgetFeatureFunction(Feature, FunctionName,  reinterpret_cast<void*&>(PtrFn));
		checkf(Result == sl::Result::eOk, TEXT("%s: unable to map function %s (%s)"), ANSI_TO_TCHAR(__FUNCTION__), ANSI_TO_TCHAR(FunctionName), ANSI_TO_TCHAR(sl::getResultAsStr(Result)));
	}

	FString FunctionArgs;

	const TTuple<Ts...> Quarrel(args...);
	StringifySLArgument Stringifier;
	VisitTupleElements(Stringifier, Quarrel);

	bool bLogFeature = true;

	// Look at me, I'm the denoiser nows
	if (Feature == sl::kFeaturePCL)
	{
		bLogFeature = false;
	}

	if (Feature == sl::kFeatureReflex)
	{
		bLogFeature = false;
	}

	if (FString(FunctionName).Contains(TEXT("Get")))
	{
		bLogFeature = false;
	}

	if (bLogFeature)
	{
		LogStreamlineFunctionCall(FString::Printf(TEXT("%s"), ANSI_TO_TCHAR(FunctionName)), Stringifier.GetJoinedArgString());
	}

	return PtrFn(std::forward<Ts>(args)...);
}
#define CALL_SL_FEATURE_FN(Feature, FunctionName, ...) CallSLFeatureFn<decltype(&FunctionName)>(Feature, #FunctionName, __VA_ARGS__)

// workaround for bad operator& definition that returns bool in sl_consts.h macro, until Streamline header is fixed
// if you get a compile error for SLBitwiseAnd specialization, it's likely that Streamline has been fixed, so you can use & and remove this function template
using SLBitwiseAndOperatorReturnType = decltype(sl::operator&(sl::FeatureRequirementFlags::eD3D11Supported, sl::FeatureRequirementFlags::eD3D11Supported));
template<typename E, std::enable_if_t<!std::is_same_v<SLBitwiseAndOperatorReturnType, sl::FeatureRequirementFlags>, bool> = true>
constexpr E SLBitwiseAnd(E x1, E x2)
{
	return static_cast<E>(static_cast<std::underlying_type<E>::type>(x1) & static_cast<std::underlying_type<E>::type>(x2));
}