mirror of
https://github.com/optiscaler/OptiScaler.git
synced 2026-05-04 08:41:43 +00:00
Michał Lewandowski
852ffc76b9
* Add support for dlssg-to-fsr3 mod * Add custom lock guard * Misc changes
905 lines
40 KiB
C++
905 lines
40 KiB
C++
/*
|
|
* Copyright (c) 2022-2023 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 <limits.h>
|
|
|
|
#include "sl_struct.h"
|
|
#include "sl_consts.h"
|
|
#include "sl_version.h"
|
|
#include "sl_result.h"
|
|
|
|
#define SL_API extern "C"
|
|
#define SL_CHECK(f) {auto _r = f; if(_r != sl::Result::eOk) return _r;}
|
|
#define SL_FAILED(r, f) sl::Result r = f; r != sl::Result::eOk
|
|
#define SL_SUCCEEDED(r, f) sl::Result r = f; r == sl::Result::eOk
|
|
#define SL_FUN_DECL(name) PFun_##name* name{}
|
|
//! IMPORTANT: Macros which use `slGetFeatureFunction` can only be used AFTER device is set by calling either slSetD3DDevice or slSetVulkanInfo.
|
|
#define SL_FEATURE_FUN_IMPORT(feature, func) slGetFeatureFunction(feature, #func, (void*&) ##func)
|
|
#define SL_FEATURE_FUN_IMPORT_STATIC(feature, func) \
|
|
static PFun_##func* s_ ##func{}; \
|
|
if(!s_ ##func) { \
|
|
sl::Result res = slGetFeatureFunction(feature, #func, (void*&) s_ ##func); \
|
|
if(res != sl::Result::eOk) return res; \
|
|
} \
|
|
|
|
typedef struct ID3D11Resource ID3D11Resource;
|
|
typedef struct ID3D11Buffer ID3D11Buffer;
|
|
typedef struct ID3D11Texture2D ID3D11Texture2D;
|
|
typedef struct ID3D12Resource ID3D12Resource;
|
|
|
|
namespace sl {
|
|
|
|
using CommandBuffer = void;
|
|
using Device = void;
|
|
|
|
//! Buffer types used for tagging
|
|
//!
|
|
//! IMPORTANT: Each tag must use the unique id
|
|
//!
|
|
using BufferType = uint32_t;
|
|
|
|
//! Depth buffer - IMPORTANT - Must be suitable to use with clipToPrevClip transformation (see Constants below)
|
|
constexpr BufferType kBufferTypeDepth = 0;
|
|
//! Object and optional camera motion vectors (see Constants below)
|
|
constexpr BufferType kBufferTypeMotionVectors = 1;
|
|
//! Color buffer with all post-processing effects applied but without any UI/HUD elements
|
|
constexpr BufferType kBufferTypeHUDLessColor = 2;
|
|
//! Color buffer containing jittered input data for the image scaling pass
|
|
constexpr BufferType kBufferTypeScalingInputColor = 3;
|
|
//! Color buffer containing results from the image scaling pass
|
|
constexpr BufferType kBufferTypeScalingOutputColor = 4;
|
|
//! Normals
|
|
constexpr BufferType kBufferTypeNormals = 5;
|
|
//! Roughness
|
|
constexpr BufferType kBufferTypeRoughness = 6;
|
|
//! Albedo
|
|
constexpr BufferType kBufferTypeAlbedo = 7;
|
|
//! Specular Albedo
|
|
constexpr BufferType kBufferTypeSpecularAlbedo = 8;
|
|
//! Indirect Albedo
|
|
constexpr BufferType kBufferTypeIndirectAlbedo = 9;
|
|
//! Specular Motion Vectors
|
|
constexpr BufferType kBufferTypeSpecularMotionVectors = 10;
|
|
//! Disocclusion Mask
|
|
constexpr BufferType kBufferTypeDisocclusionMask = 11;
|
|
//! Emissive
|
|
constexpr BufferType kBufferTypeEmissive = 12;
|
|
//! Exposure
|
|
constexpr BufferType kBufferTypeExposure = 13;
|
|
//! Buffer with normal and roughness in alpha channel
|
|
constexpr BufferType kBufferTypeNormalRoughness = 14;
|
|
//! Diffuse and camera ray length
|
|
constexpr BufferType kBufferTypeDiffuseHitNoisy = 15;
|
|
//! Diffuse denoised
|
|
constexpr BufferType kBufferTypeDiffuseHitDenoised = 16;
|
|
//! Specular and reflected ray length
|
|
constexpr BufferType kBufferTypeSpecularHitNoisy = 17;
|
|
//! Specular denoised
|
|
constexpr BufferType kBufferTypeSpecularHitDenoised = 18;
|
|
//! Shadow noisy
|
|
constexpr BufferType kBufferTypeShadowNoisy = 19;
|
|
//! Shadow denoised
|
|
constexpr BufferType kBufferTypeShadowDenoised = 20;
|
|
//! AO noisy
|
|
constexpr BufferType kBufferTypeAmbientOcclusionNoisy = 21;
|
|
//! AO denoised
|
|
constexpr BufferType kBufferTypeAmbientOcclusionDenoised = 22;
|
|
//! Optional - UI/HUD color and alpha
|
|
//! IMPORTANT: Please make sure that alpha channel has enough precision (for example do NOT use formats like R10G10B10A2)
|
|
constexpr BufferType kBufferTypeUIColorAndAlpha = 23;
|
|
//! Optional - Shadow pixels hint (set to 1 if a pixel belongs to the shadow area, 0 otherwise)
|
|
constexpr BufferType kBufferTypeShadowHint = 24;
|
|
//! Optional - Reflection pixels hint (set to 1 if a pixel belongs to the reflection area, 0 otherwise)
|
|
constexpr BufferType kBufferTypeReflectionHint = 25;
|
|
//! Optional - Particle pixels hint (set to 1 if a pixel represents a particle, 0 otherwise)
|
|
constexpr BufferType kBufferTypeParticleHint = 26;
|
|
//! Optional - Transparency pixels hint (set to 1 if a pixel belongs to the transparent area, 0 otherwise)
|
|
constexpr BufferType kBufferTypeTransparencyHint = 27;
|
|
//! Optional - Animated texture pixels hint (set to 1 if a pixel belongs to the animated texture area, 0 otherwise)
|
|
constexpr BufferType kBufferTypeAnimatedTextureHint = 28;
|
|
//! Optional - Bias for current color vs history hint - lerp(history, current, bias) (set to 1 to completely reject history)
|
|
constexpr BufferType kBufferTypeBiasCurrentColorHint = 29;
|
|
//! Optional - Ray-tracing distance (camera ray length)
|
|
constexpr BufferType kBufferTypeRaytracingDistance = 30;
|
|
//! Optional - Motion vectors for reflections
|
|
constexpr BufferType kBufferTypeReflectionMotionVectors = 31;
|
|
//! Optional - Position, in same space as eNormals
|
|
constexpr BufferType kBufferTypePosition = 32;
|
|
//! Optional - Indicates (via non-zero value) which pixels have motion/depth values that do not match the final color content at that pixel (e.g. overlaid, opaque Picture-in-Picture)
|
|
constexpr BufferType kBufferTypeInvalidDepthMotionHint = 33;
|
|
//! Alpha
|
|
constexpr BufferType kBufferTypeAlpha = 34;
|
|
//! Color buffer containing only opaque geometry
|
|
constexpr BufferType kBufferTypeOpaqueColor = 35;
|
|
//! Optional - Reduce reliance on history instead using current frame hint (0 if a pixel is not at all reactive and default composition should be used, 1 if fully reactive)
|
|
constexpr BufferType kBufferTypeReactiveMaskHint = 36;
|
|
//! Optional - Pixel lock adjustment hint (set to 1 if pixel lock should be completely removed, 0 otherwise)
|
|
constexpr BufferType kBufferTypeTransparencyAndCompositionMaskHint = 37;
|
|
//! Optional - Albedo of the reflection ray hit point. For multibounce reflections, this should be the albedo of the first non-specular bounce.
|
|
constexpr BufferType kBufferTypeReflectedAlbedo = 38;
|
|
//! Optional - Color buffer before particles are drawn.
|
|
constexpr BufferType kBufferTypeColorBeforeParticles = 39;
|
|
//! Optional - Color buffer before transparent objects are drawn.
|
|
constexpr BufferType kBufferTypeColorBeforeTransparency = 40;
|
|
//! Optional - Color buffer before fog is drawn.
|
|
constexpr BufferType kBufferTypeColorBeforeFog = 41;
|
|
//! Optional - Buffer containing the hit distance of a specular ray.
|
|
constexpr BufferType kBufferTypeSpecularHitDistance = 42;
|
|
//! Optional - Buffer that contains 3 components of a specular ray direction, and 1 component of specular hit distance.
|
|
constexpr BufferType kBufferTypeSpecularRayDirectionHitDistance = 43;
|
|
//! Optional - Buffer containing normalized direction of a specular ray.
|
|
constexpr BufferType kBufferTypeSpecularRayDirection = 44;
|
|
// !Optional - Buffer containing the hit distance of a diffuse ray.
|
|
constexpr BufferType kBufferTypeDiffuseHitDistance = 45;
|
|
//! Optional - Buffer that contains 3 components of a diffuse ray direction, and 1 component of diffuse hit distance.
|
|
constexpr BufferType kBufferTypeDiffuseRayDirectionHitDistance = 46;
|
|
//! Optional - Buffer containing normalized direction of a diffuse ray.
|
|
constexpr BufferType kBufferTypeDiffuseRayDirection = 47;
|
|
//! Optional - Buffer containing display resolution depth.
|
|
constexpr BufferType kBufferTypeHiResDepth = 48;
|
|
//! Required either this or kBufferTypeDepth - Buffer containing linear depth.
|
|
constexpr BufferType kBufferTypeLinearDepth = 49;
|
|
//! Optional - Bidirectional distortion field. 4 channels in normalized [0,1] pixel space. RG = distorted pixel to undistorted pixel displacement. BA = undistorted pixel to distorted pixel displacement.
|
|
constexpr BufferType kBufferTypeBidirectionalDistortionField = 50;
|
|
//!Optional - Buffer containing particles or other similar transparent effects rendered into it instead of passing it as part of the input color
|
|
constexpr BufferType kBufferTypeTransparencyLayer = 51;
|
|
//!Optional - Butffer to be used in addition to TransparencyLayer which allows 3-channels of Opacity versus 1-channel.
|
|
// In this case, TransparencyLayer represents Color (RcGcBc), TransparencyLayerOpacity represents alpha (RaGaBa)'
|
|
constexpr BufferType kBufferTypeTransparencyLayerOpacity = 52;
|
|
//! Optional - Swapchain buffer to be presented
|
|
constexpr BufferType kBufferTypeBackbuffer = 53;
|
|
|
|
//! Features supported with this SDK
|
|
//!
|
|
//! IMPORTANT: Each feature must use a unique id
|
|
//!
|
|
using Feature = uint32_t;
|
|
|
|
//! Deep Learning Super Sampling
|
|
constexpr Feature kFeatureDLSS = 0;
|
|
|
|
//! Real-Time Denoiser
|
|
constexpr Feature kFeatureNRD = 1;
|
|
|
|
//! NVIDIA Image Scaling
|
|
constexpr Feature kFeatureNIS = 2;
|
|
|
|
//! Reflex
|
|
constexpr Feature kFeatureReflex = 3;
|
|
|
|
//! PC Latency
|
|
constexpr Feature kFeaturePCL = 4;
|
|
|
|
//! DeepDVC
|
|
constexpr Feature kFeatureDeepDVC = 5;
|
|
|
|
|
|
//! DLSS Frame Generation
|
|
constexpr Feature kFeatureDLSS_G = 1000;
|
|
|
|
//! DLSS Ray Reconstruction
|
|
constexpr Feature kFeatureDLSS_RR = 1001;
|
|
|
|
constexpr Feature kFeatureNvPerf = 1002;
|
|
|
|
constexpr Feature kFeatureDirectSR = 1003;
|
|
|
|
// ImGUI
|
|
constexpr Feature kFeatureImGUI = 9999;
|
|
|
|
//! Common feature, NOT intended to be used directly
|
|
constexpr Feature kFeatureCommon = UINT_MAX;
|
|
|
|
//! Different levels for logging
|
|
enum class LogLevel : uint32_t
|
|
{
|
|
//! No logging
|
|
eOff,
|
|
//! Default logging
|
|
eDefault,
|
|
//! Verbose logging
|
|
eVerbose,
|
|
//! Total count
|
|
eCount
|
|
};
|
|
|
|
//! Resource types
|
|
enum class ResourceType : char
|
|
{
|
|
eTex2d,
|
|
eBuffer,
|
|
eCommandQueue,
|
|
eCommandBuffer,
|
|
eCommandPool,
|
|
eFence,
|
|
eSwapchain,
|
|
eHostFence,
|
|
eCount
|
|
};
|
|
|
|
//! Resource allocate information
|
|
//!
|
|
SL_STRUCT(ResourceAllocationDesc, StructType({ 0xbb57e5, 0x49a2, 0x4c23, { 0xa5, 0x19, 0xab, 0x92, 0x86, 0xe7, 0x40, 0x14 } }), kStructVersion1)
|
|
ResourceAllocationDesc(ResourceType _type, void* _desc, uint32_t _state, void* _heap) : BaseStructure(ResourceAllocationDesc::s_structType, kStructVersion1), type(_type),desc(_desc),state(_state),heap(_heap){};
|
|
//! Indicates the type of resource
|
|
ResourceType type = ResourceType::eTex2d;
|
|
//! D3D12_RESOURCE_DESC/VkImageCreateInfo/VkBufferCreateInfo
|
|
void* desc{};
|
|
//! Initial state as D3D12_RESOURCE_STATES or VkMemoryPropertyFlags
|
|
uint32_t state = 0;
|
|
//! CD3DX12_HEAP_PROPERTIES or nullptr
|
|
void* heap{};
|
|
|
|
//! IMPORTANT: New members go here or if optional can be chained in a new struct, see sl_struct.h for details
|
|
};
|
|
|
|
|
|
//! Subresource range information, for Vulkan resources
|
|
//!
|
|
//! {8D4C316C-D402-4524-89A7-14E79E638E3A}
|
|
SL_STRUCT(SubresourceRange, StructType({ 0x8d4c316c, 0xd402, 0x4524, { 0x89, 0xa7, 0x14, 0xe7, 0x9e, 0x63, 0x8e, 0x3a } }), kStructVersion1)
|
|
//! Vulkan subresource aspectMask
|
|
uint32_t aspectMask;
|
|
//! Vulkan subresource baseMipLevel
|
|
uint32_t baseMipLevel;
|
|
//! Vulkan subresource levelCount
|
|
uint32_t levelCount;
|
|
//! Vulkan subresource baseArrayLayer
|
|
uint32_t baseArrayLayer;
|
|
//! Vulkan subresource layerCount
|
|
uint32_t layerCount;
|
|
};
|
|
|
|
//! Native resource
|
|
//!
|
|
//! {3A9D70CF-2418-4B72-8391-13F8721C7261}
|
|
SL_STRUCT(Resource, StructType({ 0x3a9d70cf, 0x2418, 0x4b72, { 0x83, 0x91, 0x13, 0xf8, 0x72, 0x1c, 0x72, 0x61 } }), kStructVersion1)
|
|
//! Constructors
|
|
//!
|
|
//! Resource type, native pointer are MANDATORY always
|
|
//! Resource state is MANDATORY unless using D3D11
|
|
//! Resource view, description etc. are MANDATORY only when using Vulkan
|
|
//!
|
|
Resource(ResourceType _type, void* _native, void* _mem, void* _view, uint32_t _state = UINT_MAX) : BaseStructure(Resource::s_structType, kStructVersion1), type(_type), native(_native), memory(_mem), view(_view), state(_state){};
|
|
Resource(ResourceType _type, void* _native, uint32_t _state = UINT_MAX) : BaseStructure(Resource::s_structType, kStructVersion1), type(_type), native(_native), state(_state) {};
|
|
|
|
//! Conversion helpers for D3D
|
|
inline operator ID3D12Resource* () { return reinterpret_cast<ID3D12Resource*>(native); }
|
|
inline operator ID3D11Resource* () { return reinterpret_cast<ID3D11Resource*>(native); }
|
|
inline operator ID3D11Buffer* () { return reinterpret_cast<ID3D11Buffer*>(native); }
|
|
inline operator ID3D11Texture2D* () { return reinterpret_cast<ID3D11Texture2D*>(native); }
|
|
|
|
//! Indicates the type of resource
|
|
ResourceType type = ResourceType::eTex2d;
|
|
//! ID3D11Resource/ID3D12Resource/VkBuffer/VkImage
|
|
void* native{};
|
|
//! vkDeviceMemory or nullptr
|
|
void* memory{};
|
|
//! VkImageView/VkBufferView or nullptr
|
|
void* view{};
|
|
//! State as D3D12_RESOURCE_STATES or VkImageLayout
|
|
//!
|
|
//! IMPORTANT: State is MANDATORY and needs to be correct when tagged resources are actually used.
|
|
//!
|
|
uint32_t state = UINT_MAX;
|
|
//! Width in pixels
|
|
uint32_t width{};
|
|
//! Height in pixels
|
|
uint32_t height{};
|
|
//! Native format
|
|
uint32_t nativeFormat{};
|
|
//! Number of mip-map levels
|
|
uint32_t mipLevels{};
|
|
//! Number of arrays
|
|
uint32_t arrayLayers{};
|
|
//! Virtual address on GPU (if applicable)
|
|
uint64_t gpuVirtualAddress{};
|
|
//! VkImageCreateFlags
|
|
uint32_t flags;
|
|
//! VkImageUsageFlags
|
|
uint32_t usage{};
|
|
//! Reserved for internal use
|
|
uint32_t reserved{};
|
|
|
|
//! IMPORTANT: New members go here or if optional can be chained in a new struct, see sl_struct.h for details
|
|
};
|
|
|
|
//! Specifies life-cycle for the tagged resource
|
|
//!
|
|
//! IMPORTANT: Use 'eOnlyValidNow' and 'eValidUntilEvaluate' ONLY when really needed since it can result in wasting VRAM if SL ends up making unnecessary copies.
|
|
//!
|
|
//! If integrating features, like for example DLSS-G, which require tags to be 'eValidUntilPresent' please try to tag everything as 'eValidUntilPresent' first
|
|
//! and only make modifications if upon visual inspection you notice that tags are corrupted when used during the Present frame call.
|
|
enum ResourceLifecycle
|
|
{
|
|
//! Resource can change, get destroyed or reused for other purposes after it is provided to SL
|
|
eOnlyValidNow,
|
|
//! Resource does NOT change, gets destroyed or reused for other purposes from the moment it is provided to SL until the frame is presented
|
|
eValidUntilPresent,
|
|
//! Resource does NOT change, gets destroyed or reused for other purposes from the moment it is provided to SL until after the slEvaluateFeature call has returned.
|
|
eValidUntilEvaluate
|
|
};
|
|
|
|
//! Tagged resource
|
|
//!
|
|
//! {4C6A5AAD-B445-496C-87FF-1AF3845BE653}
|
|
//! Extensions as part of the `next` ptr:
|
|
//! PrecisionInfo
|
|
SL_STRUCT(ResourceTag, StructType({ 0x4c6a5aad, 0xb445, 0x496c, { 0x87, 0xff, 0x1a, 0xf3, 0x84, 0x5b, 0xe6, 0x53 } }), kStructVersion1)
|
|
ResourceTag(Resource* r, BufferType t, ResourceLifecycle l, const Extent* e = nullptr)
|
|
: BaseStructure(ResourceTag::s_structType, kStructVersion1), resource(r), type(t), lifecycle(l)
|
|
{
|
|
if (e) extent = *e;
|
|
};
|
|
|
|
//! Resource description
|
|
Resource* resource{};
|
|
//! Type of the tagged buffer
|
|
BufferType type{};
|
|
//! The life-cycle for the tag, if resource is volatile a valid command buffer must be specified
|
|
ResourceLifecycle lifecycle{};
|
|
//! The area of the tagged resource to use (if using the entire resource leave as null)
|
|
Extent extent{};
|
|
|
|
//! IMPORTANT: New members go here or if optional can be chained in a new struct, see sl_struct.h for details
|
|
};
|
|
|
|
//
|
|
//! Precision info, optional extension for ResourceTag.
|
|
//!
|
|
//! {98F6E9BA-8D16-4831-A802-4D3B52FF26BF}
|
|
//! Extensions as part of the `next` ptr:
|
|
//! ResourceTag
|
|
SL_STRUCT(PrecisionInfo, StructType({ 0x98f6e9ba, 0x8d16, 0x4831, { 0xa8, 0x2, 0x4d, 0x3b, 0x52, 0xff, 0x26, 0xbf } }), kStructVersion1)
|
|
// Formula used to convert the low-precision data to high-precision
|
|
enum PrecisionFormula : uint32_t
|
|
{
|
|
eNoTransform = 0, // hi = lo, essentially no conversion is done
|
|
eLinearTransform, // hi = lo * scale + bias
|
|
};
|
|
|
|
PrecisionInfo(PrecisionInfo::PrecisionFormula formula, float bias, float scale)
|
|
: BaseStructure(PrecisionInfo::structType, kStructVersion1), conversionFormula(formula), bias(bias), scale(scale) {};
|
|
|
|
static std::string getPrecisionFormulaAsStr(PrecisionFormula formula)
|
|
{
|
|
switch (formula)
|
|
{
|
|
case eNoTransform:
|
|
return "eNoTransform";
|
|
case eLinearTransform:
|
|
return "eLinearTransform";
|
|
default:
|
|
assert("Invalid PrecisionFormula" && false);
|
|
return "Unknown";
|
|
}
|
|
};
|
|
|
|
PrecisionFormula conversionFormula{ eNoTransform };
|
|
float bias{ 0.0f };
|
|
float scale{ 1.0f };
|
|
|
|
inline operator bool() const { return conversionFormula != eNoTransform; }
|
|
inline bool operator==(const PrecisionInfo& rhs) const
|
|
{
|
|
return conversionFormula == rhs.conversionFormula && bias == rhs.bias && scale == rhs.scale;
|
|
}
|
|
inline bool operator!=(const PrecisionInfo& rhs) const
|
|
{
|
|
return !operator==(rhs);
|
|
}
|
|
};
|
|
|
|
//! Resource allocation/deallocation callbacks
|
|
//!
|
|
//! Use these callbacks to gain full control over
|
|
//! resource life cycle and memory allocation tracking.
|
|
//!
|
|
//! @param device - Device to be used (vkDevice or ID3D11Device or ID3D12Device)
|
|
//!
|
|
//! IMPORTANT: Textures must have the pixel shader resource
|
|
//! and the unordered access view flags set
|
|
using PFun_ResourceAllocateCallback = Resource(const ResourceAllocationDesc* desc, void* device);
|
|
using PFun_ResourceReleaseCallback = void(Resource* resource, void* device);
|
|
|
|
//! Log type
|
|
enum class LogType : uint32_t
|
|
{
|
|
//! Controlled by LogLevel, SL can show more information in eLogLevelVerbose mode
|
|
eInfo,
|
|
//! Always shown regardless of LogLevel
|
|
eWarn,
|
|
eError,
|
|
//! Total count
|
|
eCount
|
|
};
|
|
|
|
//! Logging callback
|
|
//!
|
|
//! Use these callbacks to track messages posted in the log.
|
|
//! If any of the SL methods returns false use eLogTypeError
|
|
//! type to track down what went wrong and why.
|
|
using PFun_LogMessageCallback = void(LogType type, const char* msg);
|
|
|
|
//! Optional flags
|
|
enum class PreferenceFlags : uint64_t
|
|
{
|
|
//! Set by default - Disables command list state tracking - Host application is responsible for restoring CL state correctly after each 'slEvaluateFeature' call
|
|
eDisableCLStateTracking = 1 << 0,
|
|
//! Optional - Disables debug text on screen in development builds
|
|
eDisableDebugText = 1 << 1,
|
|
//! Optional - IMPORTANT: Only to be used in the advanced integration mode, see the 'manual hooking' programming guide for more details
|
|
eUseManualHooking = 1 << 2,
|
|
//! Optional - Enables downloading of Over The Air (OTA) updates for SL and NGX
|
|
//! This will invoke the OTA updater to look for new updates. A separate
|
|
//! flag below is used to control whether or not OTA-downloaded SL Plugins are
|
|
//! loaded.
|
|
eAllowOTA = 1 << 3,
|
|
//! Do not check OS version when deciding if feature is supported or not
|
|
//!
|
|
//! IMPORTANT: ONLY SET THIS FLAG IF YOU KNOW WHAT YOU ARE DOING.
|
|
//!
|
|
//! VARIOUS WIN APIs INCLUDING BUT NOT LIMITED TO `IsWindowsXXX`, `GetVersionX`, `rtlGetVersion` ARE KNOWN FOR RETURNING INCORRECT RESULTS.
|
|
eBypassOSVersionCheck = 1 << 4,
|
|
//! Optional - If specified SL will create DXGI factory proxy rather than modifying the v-table for the base interface.
|
|
//!
|
|
//! This can help with 3rd party overlays which are NOT integrated with the host application but rather operate via injection.
|
|
eUseDXGIFactoryProxy = 1 << 5,
|
|
//! Optional - Enables loading of plugins downloaded Over The Air (OTA), to
|
|
//! be used in conjunction with the eAllowOTA flag.
|
|
eLoadDownloadedPlugins = 1 << 6,
|
|
};
|
|
|
|
SL_ENUM_OPERATORS_64(PreferenceFlags)
|
|
|
|
//! Engine types
|
|
//!
|
|
enum class EngineType : uint32_t
|
|
{
|
|
eCustom,
|
|
eUnreal,
|
|
eUnity,
|
|
eCount
|
|
};
|
|
|
|
//! Rendering API
|
|
//!
|
|
enum class RenderAPI : uint32_t
|
|
{
|
|
eD3D11,
|
|
eD3D12,
|
|
eVulkan,
|
|
eCount
|
|
};
|
|
|
|
//! Application preferences
|
|
//!
|
|
//! {1CA10965-BF8E-432B-8DA1-6716D879FB14}
|
|
SL_STRUCT(Preferences, StructType({ 0x1ca10965, 0xbf8e, 0x432b, { 0x8d, 0xa1, 0x67, 0x16, 0xd8, 0x79, 0xfb, 0x14 } }), kStructVersion1)
|
|
//! Optional - In non-production builds it is useful to enable debugging console window
|
|
bool showConsole = false;
|
|
//! Optional - Various logging levels
|
|
LogLevel logLevel = LogLevel::eDefault;
|
|
//! Optional - Absolute paths to locations where to look for plugins, first path in the list has the highest priority
|
|
const wchar_t** pathsToPlugins{};
|
|
//! Optional - Number of paths to search
|
|
uint32_t numPathsToPlugins = 0;
|
|
//! Optional - Absolute path to location where logs and other data should be stored
|
|
//!
|
|
//! NOTE: Set this to nullptr in order to disable logging to a file
|
|
const wchar_t* pathToLogsAndData{};
|
|
//! Optional - Allows resource allocation tracking on the host side
|
|
PFun_ResourceAllocateCallback* allocateCallback{};
|
|
//! Optional - Allows resource deallocation tracking on the host side
|
|
PFun_ResourceReleaseCallback* releaseCallback{};
|
|
//! Optional - Allows log message tracking including critical errors if they occur
|
|
PFun_LogMessageCallback* logMessageCallback{};
|
|
//! Optional - Flags used to enable or disable advanced options
|
|
PreferenceFlags flags = PreferenceFlags::eDisableCLStateTracking | PreferenceFlags::eAllowOTA | PreferenceFlags::eLoadDownloadedPlugins;
|
|
//! Required - Features to load (assuming appropriate plugins are found), if not specified NO features will be loaded by default
|
|
const Feature* featuresToLoad{};
|
|
//! Required - Number of features to load, only used when list is not a null pointer
|
|
uint32_t numFeaturesToLoad{};
|
|
//! Optional - Id provided by NVIDIA, if not specified then engine type and version are required
|
|
uint32_t applicationId{};
|
|
//! Optional - Type of the rendering engine used, if not specified then applicationId is required
|
|
EngineType engine = EngineType::eCustom;
|
|
//! Optional - Version of the rendering engine used
|
|
const char* engineVersion{};
|
|
//! Optional - GUID (like for example 'a0f57b54-1daf-4934-90ae-c4035c19df04')
|
|
const char* projectId{};
|
|
//! Optional - Which rendering API host is planning to use
|
|
//!
|
|
//! NOTE: To ensure correct `slGetFeatureRequirements` behavior please specify if planning to use Vulkan.
|
|
RenderAPI renderAPI = RenderAPI::eD3D12;
|
|
|
|
//! IMPORTANT: New members go here or if optional can be chained in a new struct, see sl_struct.h for details
|
|
};
|
|
|
|
//! Frame tracking handle
|
|
//!
|
|
//! IMPORTANT: Use slGetNewFrameToken to obtain unique instance
|
|
//!
|
|
//! {830A0F35-DB84-4171-A804-59B206499B18}
|
|
SL_STRUCT_PROTECTED(FrameToken, StructType({ 0x830a0f35, 0xdb84, 0x4171, { 0xa8, 0x4, 0x59, 0xb2, 0x6, 0x49, 0x9b, 0x18 } }), kStructVersion1)
|
|
//! Helper operator to obtain current frame index
|
|
virtual operator uint32_t() const = 0;
|
|
};
|
|
|
|
//! Handle for the unique viewport
|
|
//!
|
|
//! {171B6435-9B3C-4FC8-9994-FBE52569AAA4}
|
|
SL_STRUCT(ViewportHandle, StructType({ 0x171b6435, 0x9b3c, 0x4fc8, { 0x99, 0x94, 0xfb, 0xe5, 0x25, 0x69, 0xaa, 0xa4 } }), kStructVersion1)
|
|
ViewportHandle(uint32_t v) : BaseStructure(ViewportHandle::s_structType, kStructVersion1), value(v) {}
|
|
ViewportHandle(int32_t v) : BaseStructure(ViewportHandle::s_structType, kStructVersion1), value(v) {}
|
|
operator uint32_t() const { return value; }
|
|
private:
|
|
uint32_t value = UINT_MAX;
|
|
};
|
|
|
|
//! Specifies feature requirement flags
|
|
//!
|
|
enum class FeatureRequirementFlags : uint32_t
|
|
{
|
|
//! Rendering APIs
|
|
eD3D11Supported = 1 << 0,
|
|
eD3D12Supported = 1 << 1,
|
|
eVulkanSupported = 1 << 2,
|
|
//! If set V-Sync must be disabled when feature is active
|
|
eVSyncOffRequired = 1 << 3,
|
|
//! If set GPU hardware scheduling OS feature must be turned on
|
|
eHardwareSchedulingRequired = 1 << 4
|
|
};
|
|
|
|
SL_ENUM_OPERATORS_32(FeatureRequirementFlags);
|
|
|
|
//! Specifies feature requirements
|
|
//!
|
|
//! {66714097-AC6D-4BC6-8915-1E0F55A6B61F}
|
|
SL_STRUCT(FeatureRequirements, StructType({ 0x66714097, 0xac6d, 0x4bc6, { 0x89, 0x15, 0x1e, 0xf, 0x55, 0xa6, 0xb6, 0x1f } }), kStructVersion2)
|
|
//! Various Flags
|
|
FeatureRequirementFlags flags {};
|
|
|
|
//! Feature will create this many CPU threads
|
|
uint32_t maxNumCPUThreads{};
|
|
|
|
//! Feature supports only this many viewports
|
|
uint32_t maxNumViewports{};
|
|
|
|
//! Required buffer tags
|
|
uint32_t numRequiredTags{};
|
|
const BufferType* requiredTags{};
|
|
|
|
//! OS and Driver versions
|
|
Version osVersionDetected{};
|
|
Version osVersionRequired{};
|
|
Version driverVersionDetected{};
|
|
Version driverVersionRequired{};
|
|
|
|
//! Vulkan specific bits
|
|
|
|
//! Command queues
|
|
uint32_t vkNumComputeQueuesRequired{};
|
|
uint32_t vkNumGraphicsQueuesRequired{};
|
|
|
|
//! Device extensions
|
|
uint32_t vkNumDeviceExtensions{};
|
|
const char** vkDeviceExtensions{};
|
|
//! Instance extensions
|
|
uint32_t vkNumInstanceExtensions{};
|
|
const char** vkInstanceExtensions{};
|
|
//! 1.2 features
|
|
//!
|
|
//! NOTE: Use getVkPhysicalDeviceVulkan12Features from sl_helpers_vk.h
|
|
uint32_t vkNumFeatures12{};
|
|
const char** vkFeatures12{};
|
|
//! 1.3 features
|
|
//!
|
|
//! NOTE: Use getVkPhysicalDeviceVulkan13Features from sl_helpers_vk.h
|
|
uint32_t vkNumFeatures13{};
|
|
const char** vkFeatures13{};
|
|
|
|
//! Vulkan optical flow feature
|
|
uint32_t vkNumOpticalFlowQueuesRequired{};
|
|
|
|
//! IMPORTANT: New members go here or if optional can be chained in a new struct, see sl_struct.h for details
|
|
};
|
|
|
|
//! Specifies feature's version
|
|
//!
|
|
//! {6D5B51F0-076B-486D-9995-5A561043F5C1}
|
|
SL_STRUCT(FeatureVersion, StructType({ 0x6d5b51f0, 0x76b, 0x486d, { 0x99, 0x95, 0x5a, 0x56, 0x10, 0x43, 0xf5, 0xc1 } }), kStructVersion1)
|
|
//! SL version
|
|
Version versionSL{};
|
|
//! NGX version (if feature is using NGX, null otherwise)
|
|
Version versionNGX{};
|
|
|
|
//! IMPORTANT: New members go here or if optional can be chained in a new struct, see sl_struct.h for details
|
|
};
|
|
|
|
//! Specifies either DXGI adapter or VK physical device
|
|
//!
|
|
//! {0677315F-A746-4492-9F42-CB6142C9C3D4}
|
|
SL_STRUCT(AdapterInfo, StructType({ 0x677315f, 0xa746, 0x4492, { 0x9f, 0x42, 0xcb, 0x61, 0x42, 0xc9, 0xc3, 0xd4 } }), kStructVersion1)
|
|
//! Locally unique identifier
|
|
uint8_t* deviceLUID {};
|
|
//! Size in bytes
|
|
uint32_t deviceLUIDSizeInBytes{};
|
|
//! Vulkan Specific, if specified LUID will be ignored
|
|
void* vkPhysicalDevice{};
|
|
|
|
//! IMPORTANT: New members go here or if optional can be chained in a new struct, see sl_struct.h for details
|
|
};
|
|
|
|
}
|
|
|
|
//! Streamline core API functions (check feature specific headers for additional APIs)
|
|
//!
|
|
using PFun_slInit = sl::Result(const sl::Preferences& pref, uint64_t sdkVersion);
|
|
using PFun_slShutdown = sl::Result();
|
|
using PFun_slIsFeatureSupported = sl::Result(sl::Feature feature, const sl::AdapterInfo& adapterInfo);
|
|
using PFun_slIsFeatureLoaded = sl::Result(sl::Feature feature, bool& loaded);
|
|
using PFun_slSetFeatureLoaded = sl::Result(sl::Feature feature, bool loaded);
|
|
using PFun_slEvaluateFeature = sl::Result(sl::Feature feature, const sl::FrameToken& frame, const sl::BaseStructure** inputs, uint32_t numInputs, sl::CommandBuffer* cmdBuffer);
|
|
using PFun_slAllocateResources = sl::Result(sl::CommandBuffer* cmdBuffer, sl::Feature feature, const sl::ViewportHandle& viewport);
|
|
using PFun_slFreeResources = sl::Result(sl::Feature feature, const sl::ViewportHandle& viewport);
|
|
using PFun_slSetTag = sl::Result(const sl::ViewportHandle& viewport, const sl::ResourceTag* tags, uint32_t numTags, sl::CommandBuffer* cmdBuffer);
|
|
using PFun_slGetFeatureRequirements = sl::Result(sl::Feature feature, sl::FeatureRequirements& requirements);
|
|
using PFun_slGetFeatureVersion = sl::Result(sl::Feature feature, sl::FeatureVersion& version);
|
|
using PFun_slUpgradeInterface = sl::Result(void** baseInterface);
|
|
using PFun_slSetConstants = sl::Result(const sl::Constants& values, const sl::FrameToken& frame, const sl::ViewportHandle& viewport);
|
|
using PFun_slGetNativeInterface = sl::Result(void* proxyInterface, void** baseInterface);
|
|
using PFun_slGetFeatureFunction = sl::Result(sl::Feature feature, const char* functionName, void*& function);
|
|
using PFun_slGetNewFrameToken = sl::Result(sl::FrameToken*& token, uint32_t* frameIndex);
|
|
using PFun_slSetD3DDevice = sl::Result(void* d3dDevice);
|
|
|
|
//! Initializes the SL module
|
|
//!
|
|
//! Call this method when the game is initializing.
|
|
//!
|
|
//! @param pref Specifies preferred behavior for the SL library (SL will keep a copy)
|
|
//! @param sdkVersion Current SDK version
|
|
//! @return sl::ResultCode::eOk if successful, error code otherwise (see sl_result.h for details)
|
|
//!
|
|
//! This method is NOT thread safe.
|
|
SL_API sl::Result slInit(const sl::Preferences &pref, uint64_t sdkVersion = sl::kSDKVersion);
|
|
|
|
//! Shuts down the SL module
|
|
//!
|
|
//! Call this method when the game is shutting down.
|
|
//!
|
|
//! @return sl::ResultCode::eOk if successful, error code otherwise (see sl_result.h for details)
|
|
//!
|
|
//! This method is NOT thread safe.
|
|
SL_API sl::Result slShutdown();
|
|
|
|
//! Checks if a specific feature is supported or not.
|
|
//!
|
|
//! Call this method to check if a certain e* (see above) is available.
|
|
//!
|
|
//! @param feature Specifies which feature to use
|
|
//! @param adapterInfo Adapter to check (optional)
|
|
//! @return sl::ResultCode::eOk if successful, error code otherwise (see sl_result.h for details)
|
|
//!
|
|
//! NOTE: If adapter info is null SL will return general feature compatibility with the OS,
|
|
//! installed drivers or any other requirements not directly related to the adapter.
|
|
//!
|
|
//! This method is NOT thread safe.
|
|
SL_API sl::Result slIsFeatureSupported(sl::Feature feature, const sl::AdapterInfo& adapterInfo);
|
|
|
|
//! Checks if specified feature is loaded or not.
|
|
//!
|
|
//! Call this method to check if feature is loaded.
|
|
//! All requested features are loaded by default and have to be unloaded explicitly if needed.
|
|
//!
|
|
//! @param feature Specifies which feature to check
|
|
//! @param loaded Value specifying if feature is loaded or unloaded.
|
|
//! @return sl::ResultCode::eOk if successful, error code otherwise (see sl_result.h for details)
|
|
//!
|
|
//! This method is NOT thread safe and requires DX/VK device to be created before calling it.
|
|
SL_API sl::Result slIsFeatureLoaded(sl::Feature feature, bool& loaded);
|
|
|
|
//! Sets the specified feature to either loaded or unloaded state.
|
|
//!
|
|
//! Call this method to load or unload certain e*.
|
|
//!
|
|
//! NOTE: All requested features are loaded by default and have to be unloaded explicitly if needed.
|
|
//!
|
|
//! @param feature Specifies which feature to check
|
|
//! @param loaded Value specifying if feature should be loaded or unloaded.
|
|
//! @return sl::ResultCode::eOk if successful, error code otherwise (see sl_result.h for details)
|
|
//!
|
|
//! NOTE: When this method is called no other DXGI/D3D/Vulkan APIs should be invoked in parallel so
|
|
//! make sure to flush your pipeline before calling this method.
|
|
//!
|
|
//! This method is NOT thread safe and requires DX/VK device to be created before calling it.
|
|
SL_API sl::Result slSetFeatureLoaded(sl::Feature feature, bool loaded);
|
|
|
|
//! Tags resource globally
|
|
//!
|
|
//! Call this method to tag the appropriate buffers in global scope.
|
|
//!
|
|
//! @param viewport Specifies viewport this tag applies to
|
|
//! @param tags Pointer to resources tags, set to null to remove the specified tag
|
|
//! @param numTags Number of resource tags in the provided list
|
|
//! @param cmdBuffer Command buffer to use (optional and can be null if ALL tags are null or have eValidUntilPresent life-cycle)
|
|
//! @return sl::ResultCode::eOk if successful, error code otherwise (see sl_result.h for details)
|
|
//!
|
|
//! IMPORTANT: GPU payload that generates content for the provided tag(s) MUST be either already submitted to the provided command buffer
|
|
//! or some other command buffer which is guaranteed, by the host application, to be executed BEFORE the provided command buffer.
|
|
//!
|
|
//! This method is thread safe and requires DX/VK device to be created before calling it.
|
|
SL_API sl::Result slSetTag(const sl::ViewportHandle& viewport, const sl::ResourceTag* tags, uint32_t numTags, sl::CommandBuffer* cmdBuffer);
|
|
|
|
//! Sets common constants.
|
|
//!
|
|
//! Call this method to provide the required data (SL will keep a copy).
|
|
//!
|
|
//! @param values Common constants required by SL plugins (SL will keep a copy)
|
|
//! @param frame Index of the current frame
|
|
//! @param viewport Unique id (can be viewport id | instance id etc.)
|
|
//! @return sl::ResultCode::eOk if successful, error code otherwise (see sl_result.h for details)
|
|
//!
|
|
//! This method is thread safe and requires DX/VK device to be created before calling it.
|
|
SL_API sl::Result slSetConstants(const sl::Constants& values, const sl::FrameToken& frame, const sl::ViewportHandle& viewport);
|
|
|
|
//! Returns feature's requirements
|
|
//!
|
|
//! Call this method to check what is required to run certain eFeature* (see above).
|
|
//! This method must be called after init otherwise it will always return an error.
|
|
//!
|
|
//! @param feature Specifies which feature to check
|
|
//! @param requirements Data structure with feature's requirements
|
|
//! @return sl::ResultCode::eOk if successful, error code otherwise (see sl_result.h for details)
|
|
//!
|
|
//! This method is NOT thread safe.
|
|
SL_API sl::Result slGetFeatureRequirements(sl::Feature feature, sl::FeatureRequirements& requirements);
|
|
|
|
//! Returns feature's version
|
|
//!
|
|
//! Call this method to check version for a certain eFeature* (see above).
|
|
//! This method must be called after init otherwise it will always return an error.
|
|
//!
|
|
//! @param feature Specifies which feature to check
|
|
//! @param version Data structure with feature's version
|
|
//! @return sl::ResultCode::eOk if successful, error code otherwise (see sl_result.h for details)
|
|
//!
|
|
//! This method is thread safe.
|
|
SL_API sl::Result slGetFeatureVersion(sl::Feature feature, sl::FeatureVersion& version);
|
|
|
|
//! Allocates resources for the specified feature.
|
|
//!
|
|
//! Call this method to explicitly allocate resources
|
|
//! for an instance of the specified feature.
|
|
//!
|
|
//! @param cmdBuffer Command buffer to use (must be created on device where feature is supported but can be null if not needed)
|
|
//! @param feature Feature we are working with
|
|
//! @param viewport Unique id (viewport handle)
|
|
//! @return sl::ResultCode::eOk if successful, error code otherwise (see sl_result.h for details)
|
|
//!
|
|
//! This method is NOT thread safe and requires DX/VK device to be created before calling it.
|
|
SL_API sl::Result slAllocateResources(sl::CommandBuffer* cmdBuffer, sl::Feature feature, const sl::ViewportHandle& viewport);
|
|
|
|
//! Frees resources for the specified feature.
|
|
//!
|
|
//! Call this method to explicitly free resources
|
|
//! for an instance of the specified feature.
|
|
//!
|
|
//! @param feature Feature we are working with
|
|
//! @param viewport Unique id (viewport handle)
|
|
//! @return sl::ResultCode::eOk if successful, error code otherwise (see sl_result.h for details)
|
|
//!
|
|
//! IMPORTANT: If slEvaluateFeature is pending on a command list, that command list must be flushed
|
|
//! before calling this method to prevent invalid resource access on the GPU.
|
|
//!
|
|
//! IMPORTANT: If slEvaluateFeature is pending on a command list, that command list must be flushed
|
|
//! before calling this method to prevent invalid resource access on the GPU.
|
|
//!
|
|
//! This method is NOT thread safe and requires DX/VK device to be created before calling it.
|
|
SL_API sl::Result slFreeResources(sl::Feature feature, const sl::ViewportHandle& viewport);
|
|
|
|
//! Evaluates feature
|
|
//!
|
|
//! Use this method to mark the section in your rendering pipeline
|
|
//! where specific feature should be injected.
|
|
//!
|
|
//! @param feature Feature we are working with
|
|
//! @param frame Current frame handle obtained from SL
|
|
//! @param inputs The chained structures providing the input data (viewport, tags, constants etc)
|
|
//! @param numInputs Number of inputs
|
|
//! @param cmdBuffer Command buffer to use (must be created on device where feature is supported)
|
|
//! @return sl::ResultCode::eOk if successful, error code otherwise (see sl_result.h for details)
|
|
//!
|
|
//! IMPORTANT: Frame and viewport must match whatever is used to set common and or feature options and constants (if any)
|
|
//!
|
|
//! NOTE: It is allowed to pass in buffer tags as inputs, they are considered to be a "local" tags and do NOT interact with
|
|
//! same tags sent in the global scope using slSetTag API.
|
|
//!
|
|
//! This method is NOT thread safe and requires DX/VK device to be created before calling it.
|
|
SL_API sl::Result slEvaluateFeature(sl::Feature feature, const sl::FrameToken& frame, const sl::BaseStructure** inputs, uint32_t numInputs, sl::CommandBuffer* cmdBuffer);
|
|
|
|
//! Upgrade interface
|
|
//!
|
|
//! Use this method to upgrade basic D3D or DXGI interface to an SL proxy.
|
|
//!
|
|
//! @param baseInterface Pointer to a pointer to the base interface (for example ID3D12Device etc.) to be replaced in place.
|
|
//! @return sl::ResultCode::eOk if successful, error code otherwise (see sl_result.h for details)
|
|
//!
|
|
//! IMPORTANT: This method should ONLY be used to support 3rd party SDKs like AMD AGS
|
|
//! which bypass SL or when using manual hooking.
|
|
//!
|
|
//! This method is NOT thread safe and should be called IMMEDIATELY after base interface is created.
|
|
SL_API sl::Result slUpgradeInterface(void** baseInterface);
|
|
|
|
//! Obtain native interface
|
|
//!
|
|
//! Use this method to obtain underlying D3D or DXGI interface from an SL proxy.
|
|
//!
|
|
//! IMPORTANT: When calling NVAPI or other 3rd party SDKs from your application
|
|
//! it is recommended to provide native interfaces instead of SL proxies.
|
|
//!
|
|
//! @param proxyInterface Pointer to the SL proxy (D3D device, swap-chain etc)
|
|
//! @param baseInterface Pointer to a pointer to the base interface be returned.
|
|
//! @return sl::ResultCode::eOk if successful, error code otherwise (see sl_result.h for details)
|
|
//!
|
|
//! This method is NOT thread safe
|
|
SL_API sl::Result slGetNativeInterface(void* proxyInterface, void** baseInterface);
|
|
|
|
//! Gets specific feature's function
|
|
//!
|
|
//! Call this method to obtain various functions for the specified feature. See sl_$feature.h for details.
|
|
//!
|
|
//! @param feature Feature we are working with
|
|
//! @param functionName The name of the API to obtain (declared in sl_[$feature].h
|
|
//! @param function Pointer to the function to return
|
|
//! @return sl::ResultCode::eOk if successful, error code otherwise (see sl_result.h for details)
|
|
//!
|
|
//! IMPORTANT: Must be called AFTER device is set by calling either slSetD3DDevice or slSetVulkanInfo.
|
|
//!
|
|
//! This method is thread safe.
|
|
SL_API sl::Result slGetFeatureFunction(sl::Feature feature, const char* functionName, void*& function);
|
|
|
|
//! Gets unique frame token
|
|
//!
|
|
//! Call this method to obtain token for the unique frame identification.
|
|
//!
|
|
//! @param handle Frame token to return
|
|
//! @param frameIndex Frame index (optional, if not provided SL internal frame counting is used)
|
|
//! @return sl::ResultCode::eOk if successful, error code otherwise (see sl_result.h for details)
|
|
//!
|
|
//! NOTE: Normally SL would not expect more that 3 frames in flight due to added latency.
|
|
//!
|
|
//! This method is thread safe.
|
|
SL_API sl::Result slGetNewFrameToken(sl::FrameToken*& token, const uint32_t* frameIndex = nullptr);
|
|
|
|
//! Set D3D device to use
|
|
//!
|
|
//! Use this method to specify which D3D device should be used.
|
|
//!
|
|
//! @param d3dDevice D3D device to use
|
|
//! @return sl::ResultCode::eOk if successful, error code otherwise (see sl_result.h for details)
|
|
//!
|
|
//! This method is NOT thread safe and should be called IMMEDIATELY after main device is created.
|
|
SL_API sl::Result slSetD3DDevice(void* d3dDevice);
|