mirror of
https://github.com/jmarshall23/DoomRTX.git
synced 2026-08-16 16:20:42 +02:00
Justin Marshall
476 lines
16 KiB
C++
476 lines
16 KiB
C++
/*
|
|
* Copyright (c) 2022-2025 NVIDIA CORPORATION. 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 <string.h>
|
|
#include <vector>
|
|
|
|
#define FEATURE_SPECIFIC_BUFFER_TYPE_ID(feature, number) feature << 16 | number
|
|
|
|
#include "sl.h"
|
|
#include "sl_consts.h"
|
|
#include "sl_reflex.h"
|
|
#include "sl_pcl.h"
|
|
#include "sl_dlss.h"
|
|
#include "sl_nis.h"
|
|
#include "sl_dlss_d.h"
|
|
#include "sl_dlss_g.h"
|
|
|
|
#if defined(__clang__)
|
|
#define SL_DISABLE_DEPRECATED_WARNINGS \
|
|
_Pragma("clang diagnostic push") \
|
|
_Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"")
|
|
#define SL_RESTORE_DEPRECATED_WARNINGS \
|
|
_Pragma("clang diagnostic pop")
|
|
|
|
#elif defined(_MSC_VER)
|
|
#define SL_DISABLE_DEPRECATED_WARNINGS \
|
|
__pragma(warning(push)) \
|
|
__pragma(warning(disable: 4996))
|
|
#define SL_RESTORE_DEPRECATED_WARNINGS \
|
|
__pragma(warning(pop))
|
|
|
|
#else
|
|
#define SL_DISABLE_DEPRECATED_WARNINGS
|
|
#define SL_RESTORE_DEPRECATED_WARNINGS
|
|
#endif
|
|
|
|
|
|
namespace sl
|
|
{
|
|
|
|
inline float4x4 transpose(const float4x4& m)
|
|
{
|
|
float4x4 r;
|
|
r[0] = { m[0].x, m[1].x, m[2].x, m[3].x };
|
|
r[1] = { m[0].y, m[1].y, m[2].y, m[3].y };
|
|
r[2] = { m[0].z, m[1].z, m[2].z, m[3].z };
|
|
r[3] = { m[0].w, m[1].w, m[2].w, m[3].w };
|
|
return r;
|
|
};
|
|
|
|
#define SL_CASE_STR(a) case a : return #a;
|
|
|
|
// Check for c++17 features
|
|
#if __cplusplus >= 201703L
|
|
#define SL_FALLTHROUGH [[fallthrough]];
|
|
#else
|
|
#define SL_FALLTHROUGH
|
|
#endif
|
|
|
|
inline const char* getResultAsStr(Result v)
|
|
{
|
|
switch (v)
|
|
{
|
|
SL_CASE_STR(Result::eOk);
|
|
SL_CASE_STR(Result::eErrorIO);
|
|
SL_CASE_STR(Result::eErrorDriverOutOfDate);
|
|
SL_CASE_STR(Result::eErrorOSOutOfDate);
|
|
SL_CASE_STR(Result::eErrorOSDisabledHWS);
|
|
SL_CASE_STR(Result::eErrorDeviceNotCreated);
|
|
SL_CASE_STR(Result::eErrorNoSupportedAdapterFound);
|
|
SL_CASE_STR(Result::eErrorAdapterNotSupported);
|
|
SL_CASE_STR(Result::eErrorNoPlugins);
|
|
SL_CASE_STR(Result::eErrorVulkanAPI);
|
|
SL_CASE_STR(Result::eErrorDXGIAPI);
|
|
SL_CASE_STR(Result::eErrorD3DAPI);
|
|
SL_CASE_STR(Result::eErrorNRDAPI);
|
|
SL_CASE_STR(Result::eErrorNVAPI);
|
|
SL_CASE_STR(Result::eErrorReflexAPI);
|
|
SL_CASE_STR(Result::eErrorNGXFailed);
|
|
SL_CASE_STR(Result::eErrorJSONParsing);
|
|
SL_CASE_STR(Result::eErrorMissingProxy);
|
|
SL_CASE_STR(Result::eErrorMissingResourceState);
|
|
SL_CASE_STR(Result::eErrorInvalidIntegration);
|
|
SL_CASE_STR(Result::eErrorMissingInputParameter);
|
|
SL_CASE_STR(Result::eErrorNotInitialized);
|
|
SL_CASE_STR(Result::eErrorComputeFailed);
|
|
SL_CASE_STR(Result::eErrorInitNotCalled);
|
|
SL_CASE_STR(Result::eErrorExceptionHandler);
|
|
SL_CASE_STR(Result::eErrorInvalidParameter);
|
|
SL_CASE_STR(Result::eErrorMissingConstants);
|
|
SL_CASE_STR(Result::eErrorDuplicatedConstants);
|
|
SL_CASE_STR(Result::eErrorMissingOrInvalidAPI);
|
|
SL_CASE_STR(Result::eErrorCommonConstantsMissing);
|
|
SL_CASE_STR(Result::eErrorUnsupportedInterface);
|
|
SL_CASE_STR(Result::eErrorFeatureMissing);
|
|
SL_CASE_STR(Result::eErrorFeatureNotSupported);
|
|
SL_CASE_STR(Result::eErrorFeatureMissingHooks);
|
|
SL_CASE_STR(Result::eErrorFeatureFailedToLoad);
|
|
SL_CASE_STR(Result::eErrorFeatureWrongPriority);
|
|
SL_CASE_STR(Result::eErrorFeatureMissingDependency);
|
|
SL_CASE_STR(Result::eErrorFeatureManagerInvalidState);
|
|
SL_CASE_STR(Result::eErrorInvalidState);
|
|
SL_CASE_STR(Result::eWarnOutOfVRAM);
|
|
};
|
|
return "Unknown";
|
|
}
|
|
|
|
inline const char* getNISModeAsStr(NISMode v)
|
|
{
|
|
switch (v)
|
|
{
|
|
SL_CASE_STR(NISMode::eOff);
|
|
SL_CASE_STR(NISMode::eScaler);
|
|
SL_CASE_STR(NISMode::eSharpen);
|
|
case NISMode::eCount: break;
|
|
};
|
|
return "Unknown";
|
|
}
|
|
|
|
inline const char* getNISHDRAsStr(NISHDR v)
|
|
{
|
|
switch (v)
|
|
{
|
|
SL_CASE_STR(NISHDR::eNone);
|
|
SL_CASE_STR(NISHDR::eLinear);
|
|
SL_CASE_STR(NISHDR::ePQ);
|
|
case NISHDR::eCount: break;
|
|
};
|
|
return "Unknown";
|
|
}
|
|
|
|
inline const char* getReflexModeAsStr(ReflexMode mode)
|
|
{
|
|
switch (mode)
|
|
{
|
|
SL_CASE_STR(ReflexMode::eOff);
|
|
SL_CASE_STR(ReflexMode::eLowLatency);
|
|
SL_CASE_STR(ReflexMode::eLowLatencyWithBoost);
|
|
case ReflexMode::ReflexMode_eCount: break;
|
|
};
|
|
return "Unknown";
|
|
}
|
|
|
|
inline const char* getPCLMarkerAsStr(PCLMarker marker)
|
|
{
|
|
switch (marker)
|
|
{
|
|
SL_CASE_STR(PCLMarker::eSimulationStart);
|
|
SL_CASE_STR(PCLMarker::eSimulationEnd);
|
|
SL_CASE_STR(PCLMarker::eRenderSubmitStart);
|
|
SL_CASE_STR(PCLMarker::eRenderSubmitEnd);
|
|
SL_CASE_STR(PCLMarker::ePresentStart);
|
|
SL_CASE_STR(PCLMarker::ePresentEnd);
|
|
SL_CASE_STR(PCLMarker::eTriggerFlash);
|
|
SL_CASE_STR(PCLMarker::ePCLatencyPing);
|
|
SL_CASE_STR(PCLMarker::eOutOfBandRenderSubmitStart);
|
|
SL_CASE_STR(PCLMarker::eOutOfBandRenderSubmitEnd);
|
|
SL_CASE_STR(PCLMarker::eOutOfBandPresentStart);
|
|
SL_CASE_STR(PCLMarker::eOutOfBandPresentEnd);
|
|
SL_CASE_STR(PCLMarker::eControllerInputSample);
|
|
SL_CASE_STR(PCLMarker::eDeltaTCalculation);
|
|
SL_CASE_STR(PCLMarker::eLateWarpPresentStart);
|
|
SL_CASE_STR(PCLMarker::eLateWarpPresentEnd);
|
|
SL_CASE_STR(PCLMarker::eCameraConstructed);
|
|
SL_CASE_STR(PCLMarker::eLateWarpRenderSubmitStart);
|
|
SL_CASE_STR(PCLMarker::eLateWarpRenderSubmitEnd);
|
|
case PCLMarker::eMaximum: break;
|
|
};
|
|
return "Unknown";
|
|
}
|
|
|
|
inline const char* getDLSSModeAsStr(DLSSMode mode)
|
|
{
|
|
switch (mode)
|
|
{
|
|
SL_CASE_STR(DLSSMode::eOff);
|
|
SL_CASE_STR(DLSSMode::eDLAA);
|
|
SL_CASE_STR(DLSSMode::eMaxPerformance);
|
|
SL_CASE_STR(DLSSMode::eBalanced);
|
|
SL_CASE_STR(DLSSMode::eMaxQuality);
|
|
SL_CASE_STR(DLSSMode::eUltraPerformance);
|
|
SL_CASE_STR(DLSSMode::eUltraQuality);
|
|
case DLSSMode::eCount: break;
|
|
};
|
|
return "Unknown";
|
|
}
|
|
|
|
inline const char* getDLSSGModeAsStr(DLSSGMode mode)
|
|
{
|
|
switch (mode)
|
|
{
|
|
SL_CASE_STR(sl::DLSSGMode::eOff);
|
|
SL_CASE_STR(sl::DLSSGMode::eOn);
|
|
SL_CASE_STR(sl::DLSSGMode::eAuto);
|
|
case DLSSGMode::eCount: break;
|
|
};
|
|
return "Unknown";
|
|
}
|
|
|
|
inline const char* getBufferTypeAsStr(BufferType buf)
|
|
{
|
|
switch (buf)
|
|
{
|
|
SL_CASE_STR(kBufferTypeDepth);
|
|
SL_CASE_STR(kBufferTypeMotionVectors);
|
|
SL_CASE_STR(kBufferTypeHUDLessColor);
|
|
SL_CASE_STR(kBufferTypeScalingInputColor);
|
|
SL_CASE_STR(kBufferTypeScalingOutputColor);
|
|
SL_CASE_STR(kBufferTypeNormals);
|
|
SL_CASE_STR(kBufferTypeRoughness);
|
|
SL_CASE_STR(kBufferTypeAlbedo);
|
|
SL_CASE_STR(kBufferTypeSpecularAlbedo);
|
|
SL_CASE_STR(kBufferTypeIndirectAlbedo);
|
|
SL_CASE_STR(kBufferTypeSpecularMotionVectors);
|
|
SL_CASE_STR(kBufferTypeDisocclusionMask);
|
|
SL_CASE_STR(kBufferTypeEmissive);
|
|
SL_CASE_STR(kBufferTypeExposure);
|
|
SL_CASE_STR(kBufferTypeNormalRoughness);
|
|
SL_CASE_STR(kBufferTypeDiffuseHitNoisy);
|
|
SL_CASE_STR(kBufferTypeDiffuseHitDenoised);
|
|
SL_CASE_STR(kBufferTypeSpecularHitNoisy);
|
|
SL_CASE_STR(kBufferTypeSpecularHitDenoised);
|
|
SL_CASE_STR(kBufferTypeShadowNoisy);
|
|
SL_CASE_STR(kBufferTypeShadowDenoised);
|
|
SL_CASE_STR(kBufferTypeAmbientOcclusionNoisy);
|
|
SL_CASE_STR(kBufferTypeAmbientOcclusionDenoised);
|
|
SL_CASE_STR(kBufferTypeUIColorAndAlpha);
|
|
SL_CASE_STR(kBufferTypeShadowHint);
|
|
SL_CASE_STR(kBufferTypeReflectionHint);
|
|
SL_CASE_STR(kBufferTypeParticleHint);
|
|
SL_CASE_STR(kBufferTypeTransparencyHint);
|
|
SL_CASE_STR(kBufferTypeAnimatedTextureHint);
|
|
SL_CASE_STR(kBufferTypeBiasCurrentColorHint);
|
|
SL_CASE_STR(kBufferTypeRaytracingDistance);
|
|
SL_CASE_STR(kBufferTypeReflectionMotionVectors);
|
|
SL_CASE_STR(kBufferTypePosition);
|
|
SL_CASE_STR(kBufferTypeInvalidDepthMotionHint);
|
|
SL_CASE_STR(kBufferTypeAlpha);
|
|
SL_CASE_STR(kBufferTypeOpaqueColor);
|
|
SL_CASE_STR(kBufferTypeReactiveMaskHint);
|
|
SL_CASE_STR(kBufferTypeTransparencyAndCompositionMaskHint);
|
|
SL_CASE_STR(kBufferTypeReflectedAlbedo);
|
|
SL_CASE_STR(kBufferTypeColorBeforeParticles);
|
|
SL_CASE_STR(kBufferTypeColorBeforeTransparency);
|
|
SL_CASE_STR(kBufferTypeColorBeforeFog);
|
|
SL_CASE_STR(kBufferTypeSpecularHitDistance);
|
|
SL_CASE_STR(kBufferTypeSpecularRayDirectionHitDistance);
|
|
SL_CASE_STR(kBufferTypeSpecularRayDirection);
|
|
SL_CASE_STR(kBufferTypeDiffuseHitDistance);
|
|
SL_CASE_STR(kBufferTypeDiffuseRayDirectionHitDistance);
|
|
SL_CASE_STR(kBufferTypeDiffuseRayDirection);
|
|
SL_CASE_STR(kBufferTypeHiResDepth);
|
|
SL_CASE_STR(kBufferTypeLinearDepth);
|
|
SL_CASE_STR(kBufferTypeColorAfterParticles);
|
|
SL_CASE_STR(kBufferTypeColorAfterTransparency);
|
|
SL_CASE_STR(kBufferTypeColorAfterFog);
|
|
SL_CASE_STR(kBufferTypeScreenSpaceSubsurfaceScatteringGuide);
|
|
SL_CASE_STR(kBufferTypeColorBeforeScreenSpaceSubsurfaceScattering);
|
|
SL_CASE_STR(kBufferTypeColorAfterScreenSpaceSubsurfaceScattering);
|
|
SL_CASE_STR(kBufferTypeScreenSpaceRefractionGuide);
|
|
SL_CASE_STR(kBufferTypeColorBeforeScreenSpaceRefraction);
|
|
SL_CASE_STR(kBufferTypeColorAfterScreenSpaceRefraction);
|
|
SL_CASE_STR(kBufferTypeDepthOfFieldGuide);
|
|
SL_CASE_STR(kBufferTypeColorBeforeDepthOfField);
|
|
SL_CASE_STR(kBufferTypeColorAfterDepthOfField);
|
|
SL_CASE_STR(kBufferTypeScalingOutputAlpha);
|
|
SL_CASE_STR(kBufferTypeBidirectionalDistortionField);
|
|
SL_CASE_STR(kBufferTypeTransparencyLayer);
|
|
SL_CASE_STR(kBufferTypeTransparencyLayerOpacity);
|
|
SL_CASE_STR(kBufferTypeBackbuffer);
|
|
SL_CASE_STR(kBufferTypeNoWarpMask);
|
|
};
|
|
return "Unknown";
|
|
}
|
|
|
|
inline const char* getFeatureAsStr(Feature f)
|
|
{
|
|
switch (f)
|
|
{
|
|
SL_CASE_STR(kFeatureDLSS);
|
|
SL_CASE_STR(kFeatureNIS);
|
|
SL_CASE_STR(kFeatureReflex);
|
|
SL_CASE_STR(kFeaturePCL);
|
|
SL_CASE_STR(kFeatureDLSS_G);
|
|
SL_CASE_STR(kFeatureNvPerf);
|
|
SL_CASE_STR(kFeatureImGUI);
|
|
SL_CASE_STR(kFeatureCommon);
|
|
SL_CASE_STR(kFeatureDLSS_RR);
|
|
SL_CASE_STR(kFeatureDeepDVC);
|
|
SL_CASE_STR(kFeatureDirectSR);
|
|
SL_CASE_STR(kFeatureLatewarp);
|
|
// Removed features
|
|
case kFeatureNRD_INVALID: break;
|
|
}
|
|
return "Unknown";
|
|
}
|
|
|
|
// Get the feature file name as a string. For a given feature kFeatureDLSS with
|
|
// a plugin name sl.dlss.dll the value "dlss" will be returned
|
|
inline const char* getFeatureFilenameAsStrNoSL(Feature f)
|
|
{
|
|
switch (f)
|
|
{
|
|
case kFeatureDLSS: return "dlss";
|
|
case kFeatureNIS: return "nis";
|
|
case kFeatureReflex: return "reflex";
|
|
case kFeaturePCL: return "pcl";
|
|
case kFeatureDLSS_G: return "dlss_g";
|
|
case kFeatureNvPerf: return "nvperf";
|
|
case kFeatureDeepDVC: return "deepdvc";
|
|
case kFeatureImGUI: return "imgui";
|
|
case kFeatureCommon: return "common";
|
|
case kFeatureDLSS_RR: return "dlss_d";
|
|
case kFeatureDirectSR: return "directsr";
|
|
case kFeatureLatewarp: return "latewarp";
|
|
case kFeatureNRD_INVALID: break;
|
|
}
|
|
return "Unknown";
|
|
}
|
|
|
|
inline const char* getLogLevelAsStr(LogLevel v)
|
|
{
|
|
switch (v)
|
|
{
|
|
SL_CASE_STR(LogLevel::eOff);
|
|
SL_CASE_STR(LogLevel::eDefault);
|
|
SL_CASE_STR(LogLevel::eVerbose);
|
|
case LogLevel::eCount: break;
|
|
};
|
|
return "Unknown";
|
|
}
|
|
|
|
inline const char* getResourceTypeAsStr(ResourceType v)
|
|
{
|
|
switch (v)
|
|
{
|
|
SL_CASE_STR(ResourceType::eTex2d);
|
|
SL_CASE_STR(ResourceType::eBuffer);
|
|
SL_CASE_STR(ResourceType::eCommandQueue);
|
|
SL_CASE_STR(ResourceType::eCommandBuffer);
|
|
SL_CASE_STR(ResourceType::eCommandPool);
|
|
SL_CASE_STR(ResourceType::eFence);
|
|
SL_CASE_STR(ResourceType::eSwapchain);
|
|
SL_CASE_STR(ResourceType::eHostFence);
|
|
case ResourceType::eUnknown: break;
|
|
case ResourceType::eCount: break;
|
|
};
|
|
return "Unknown";
|
|
}
|
|
|
|
inline const char* getResourceLifecycleAsStr(ResourceLifecycle v)
|
|
{
|
|
switch (v)
|
|
{
|
|
SL_CASE_STR(ResourceLifecycle::eOnlyValidNow);
|
|
SL_CASE_STR(ResourceLifecycle::eValidUntilPresent);
|
|
SL_CASE_STR(ResourceLifecycle::eValidUntilEvaluate);
|
|
};
|
|
return "Unknown";
|
|
}
|
|
|
|
SL_DISABLE_DEPRECATED_WARNINGS
|
|
inline DLSSPreset resolveDLSSPreset(DLSSPreset preset)
|
|
{
|
|
switch (preset)
|
|
{
|
|
case DLSSPreset::ePresetF:
|
|
case DLSSPreset::ePresetJ:
|
|
case DLSSPreset::ePresetK:
|
|
return preset;
|
|
default:
|
|
return DLSSPreset::eDefault;
|
|
}
|
|
}
|
|
SL_RESTORE_DEPRECATED_WARNINGS
|
|
|
|
inline DLSSDPreset resolveDLSSDPreset(DLSSDPreset preset)
|
|
{
|
|
return static_cast<DLSSDPreset>(resolveDLSSPreset(static_cast<DLSSPreset>(preset)));
|
|
}
|
|
|
|
|
|
|
|
// Advanced/internal functions that are not useful or necessary in the vast majority of integrations
|
|
// and would just pollute the namespace and/or cause distractions.
|
|
// But, may be useful in e.g. intermediary game engine integrations, etc.
|
|
#ifndef __INTELLISENSE__
|
|
|
|
//! Find a struct of type T
|
|
template<typename T>
|
|
T* findStruct(const void* ptr)
|
|
{
|
|
auto base = static_cast<const BaseStructure*>(ptr);
|
|
while (base && base->structType != T::s_structType)
|
|
{
|
|
base = base->next;
|
|
}
|
|
return (T*)base;
|
|
}
|
|
|
|
//! Find a struct of type T, but stop the search if we find a struct of type S
|
|
template<typename T, typename S>
|
|
T* findStruct(const void* ptr)
|
|
{
|
|
auto base = static_cast<const BaseStructure*>(ptr);
|
|
while (base && base->structType != T::s_structType)
|
|
{
|
|
base = base->next;
|
|
|
|
// If we find a struct of type S, we know should stop the search
|
|
if (base->structType == S::s_structType)
|
|
{
|
|
return nullptr;
|
|
}
|
|
}
|
|
return (T*)base;
|
|
}
|
|
|
|
template<typename T>
|
|
T* findStruct(const void** ptr, uint32_t count)
|
|
{
|
|
const BaseStructure* base{};
|
|
for (uint32_t i = 0; base == nullptr && i < count; i++)
|
|
{
|
|
base = static_cast<const BaseStructure*>(ptr[i]);
|
|
while (base && base->structType != T::s_structType)
|
|
{
|
|
base = base->next;
|
|
}
|
|
}
|
|
return (T*)base;
|
|
}
|
|
|
|
template<typename T>
|
|
bool findStructs(const void** ptr, uint32_t count, std::vector<T*>& structs)
|
|
{
|
|
for (uint32_t i = 0; i < count; i++)
|
|
{
|
|
auto base = static_cast<const BaseStructure*>(ptr[i]);
|
|
while (base)
|
|
{
|
|
if (base->structType == T::s_structType)
|
|
{
|
|
structs.push_back((T*)base);
|
|
}
|
|
base = base->next;
|
|
}
|
|
}
|
|
return structs.size() > 0;
|
|
}
|
|
|
|
#endif // __INTELLISENSE__
|
|
|
|
} // namespace sl
|