From 2415f5df72265afb368d5189b91cbe6242da4e5f Mon Sep 17 00:00:00 2001 From: Grigoriy Date: Mon, 12 Mar 2018 00:30:49 +0300 Subject: First commit --- Documentation/Manual.html | Bin 0 -> 729676 bytes Documentation/Manual_files/colorschememapping.xml | 2 + Documentation/Manual_files/filelist.xml | 16 + Documentation/Manual_files/image001.png | Bin 0 -> 316 bytes Documentation/Manual_files/image002.png | Bin 0 -> 342 bytes Documentation/Manual_files/image003.jpg | Bin 0 -> 41938 bytes Documentation/Manual_files/image003.png | Bin 0 -> 325 bytes Documentation/Manual_files/image004.jpg | Bin 0 -> 25454 bytes Documentation/Manual_files/image004.png | Bin 0 -> 244 bytes Documentation/Manual_files/image005.jpg | Bin 0 -> 12832 bytes Documentation/Manual_files/image005.png | Bin 0 -> 551 bytes Documentation/Manual_files/image006.jpg | Bin 0 -> 62114 bytes Documentation/Manual_files/image006.png | Bin 0 -> 456 bytes Documentation/Manual_files/image007.jpg | Bin 0 -> 45718 bytes Documentation/Manual_files/image007.png | Bin 0 -> 350 bytes Documentation/Manual_files/image008.jpg | Bin 0 -> 25565 bytes Documentation/Manual_files/image008.png | Bin 0 -> 339 bytes Documentation/Manual_files/image009.jpg | Bin 0 -> 26454 bytes Documentation/Manual_files/image009.png | Bin 0 -> 568 bytes Documentation/Manual_files/image010.jpg | Bin 0 -> 63507 bytes Documentation/Manual_files/image010.png | Bin 0 -> 237 bytes Documentation/Manual_files/image011.jpg | Bin 0 -> 11184 bytes Documentation/Manual_files/image012.jpg | Bin 0 -> 16384 bytes Documentation/Manual_files/themedata.thmx | Bin 0 -> 3339 bytes NVIDIAGfeSDK.uplugin | 25 + README.md | 20 + Source/NVIDIAGfeSDK/NVIDIAGfeSDK.Build.cs | 102 +++ Source/NVIDIAGfeSDK/Private/FNVIDIAGfeSDK.cpp | 237 +++++++ Source/NVIDIAGfeSDK/Private/FNVIDIAGfeSDK.h | 46 ++ Source/NVIDIAGfeSDK/Private/GfeSDKCore.cpp | 65 ++ Source/NVIDIAGfeSDK/Private/GfeSDKHighlights.cpp | 245 ++++++++ Source/NVIDIAGfeSDK/Private/HighLightBlueprint.cpp | 697 +++++++++++++++++++++ .../NVIDIAGfeSDK/Private/NVIDIAGfeSDKPrivatePCH.h | 15 + Source/NVIDIAGfeSDK/Private/TypeTranslation.cpp | 66 ++ Source/NVIDIAGfeSDK/Private/TypeTranslation.h | 63 ++ Source/NVIDIAGfeSDK/Public/GfeSDKCore.h | 27 + Source/NVIDIAGfeSDK/Public/GfeSDKHighlights.h | 33 + Source/NVIDIAGfeSDK/Public/HighLightBlueprint.h | 321 ++++++++++ Source/NVIDIAGfeSDK/Public/INVIDIAGfeSDK.h | 49 ++ Source/NVIDIAGfeSDK/Public/NVIDIAGfeSDKPublicPCH.h | 11 + Source/NVIDIAGfeSDK/Public/NVIDIAGfeSDKTypes.h | 279 +++++++++ .../bindings/cpp/highlights/highlights_types_cpp.h | 112 ++++ .../bindings/cpp/highlights/ihighlights_cpp.h | 53 ++ .../bindings/cpp/highlights/ihighlights_cpp_impl.h | 196 ++++++ .../Include/gfesdk/bindings/cpp/isdk_cpp.h | 56 ++ .../Include/gfesdk/bindings/cpp/isdk_cpp_impl.h | 219 +++++++ .../Include/gfesdk/bindings/cpp/sdk_types_cpp.h | 95 +++ ThirdParty/NVIDIAGfeSDK/Include/gfesdk/config.h | 25 + .../Include/gfesdk/gfe3_product_version.h | 44 ++ .../Include/gfesdk/highlights/highlights_types.h | 132 ++++ .../Include/gfesdk/highlights/ihighlights.h | 157 +++++ ThirdParty/NVIDIAGfeSDK/Include/gfesdk/isdk.h | 158 +++++ .../NVIDIAGfeSDK/Include/gfesdk/os_defines.h | 34 + ThirdParty/NVIDIAGfeSDK/Include/gfesdk/sdk_types.h | 146 +++++ .../NVIDIAGfeSDK/Include/gfesdk/sdk_types_ipc.h | 224 +++++++ ThirdParty/NVIDIAGfeSDK/lib/win32/GfeSDK.lib | Bin 0 -> 6182 bytes ThirdParty/NVIDIAGfeSDK/lib/win32_uwp/GfeSDK.lib | Bin 0 -> 6182 bytes ThirdParty/NVIDIAGfeSDK/lib/win64/GfeSDK.lib | Bin 0 -> 6100 bytes ThirdParty/NVIDIAGfeSDK/lib/win64_uwp/GfeSDK.lib | Bin 0 -> 6100 bytes .../redist/assets/img/img_logo_experience_512.png | Bin 0 -> 25288 bytes ThirdParty/NVIDIAGfeSDK/redist/assets/img/menu.jpg | Bin 0 -> 41938 bytes ThirdParty/NVIDIAGfeSDK/redist/win32/GfeSDK.dll | Bin 0 -> 2926480 bytes .../NVIDIAGfeSDK/redist/win32_uwp/GfeSDK.dll | Bin 0 -> 880528 bytes ThirdParty/NVIDIAGfeSDK/redist/win64/GfeSDK.dll | Bin 0 -> 3753360 bytes .../NVIDIAGfeSDK/redist/win64_uwp/GfeSDK.dll | Bin 0 -> 1225104 bytes 65 files changed, 3970 insertions(+) create mode 100644 Documentation/Manual.html create mode 100644 Documentation/Manual_files/colorschememapping.xml create mode 100644 Documentation/Manual_files/filelist.xml create mode 100644 Documentation/Manual_files/image001.png create mode 100644 Documentation/Manual_files/image002.png create mode 100644 Documentation/Manual_files/image003.jpg create mode 100644 Documentation/Manual_files/image003.png create mode 100644 Documentation/Manual_files/image004.jpg create mode 100644 Documentation/Manual_files/image004.png create mode 100644 Documentation/Manual_files/image005.jpg create mode 100644 Documentation/Manual_files/image005.png create mode 100644 Documentation/Manual_files/image006.jpg create mode 100644 Documentation/Manual_files/image006.png create mode 100644 Documentation/Manual_files/image007.jpg create mode 100644 Documentation/Manual_files/image007.png create mode 100644 Documentation/Manual_files/image008.jpg create mode 100644 Documentation/Manual_files/image008.png create mode 100644 Documentation/Manual_files/image009.jpg create mode 100644 Documentation/Manual_files/image009.png create mode 100644 Documentation/Manual_files/image010.jpg create mode 100644 Documentation/Manual_files/image010.png create mode 100644 Documentation/Manual_files/image011.jpg create mode 100644 Documentation/Manual_files/image012.jpg create mode 100644 Documentation/Manual_files/themedata.thmx create mode 100644 NVIDIAGfeSDK.uplugin create mode 100644 README.md create mode 100644 Source/NVIDIAGfeSDK/NVIDIAGfeSDK.Build.cs create mode 100644 Source/NVIDIAGfeSDK/Private/FNVIDIAGfeSDK.cpp create mode 100644 Source/NVIDIAGfeSDK/Private/FNVIDIAGfeSDK.h create mode 100644 Source/NVIDIAGfeSDK/Private/GfeSDKCore.cpp create mode 100644 Source/NVIDIAGfeSDK/Private/GfeSDKHighlights.cpp create mode 100644 Source/NVIDIAGfeSDK/Private/HighLightBlueprint.cpp create mode 100644 Source/NVIDIAGfeSDK/Private/NVIDIAGfeSDKPrivatePCH.h create mode 100644 Source/NVIDIAGfeSDK/Private/TypeTranslation.cpp create mode 100644 Source/NVIDIAGfeSDK/Private/TypeTranslation.h create mode 100644 Source/NVIDIAGfeSDK/Public/GfeSDKCore.h create mode 100644 Source/NVIDIAGfeSDK/Public/GfeSDKHighlights.h create mode 100644 Source/NVIDIAGfeSDK/Public/HighLightBlueprint.h create mode 100644 Source/NVIDIAGfeSDK/Public/INVIDIAGfeSDK.h create mode 100644 Source/NVIDIAGfeSDK/Public/NVIDIAGfeSDKPublicPCH.h create mode 100644 Source/NVIDIAGfeSDK/Public/NVIDIAGfeSDKTypes.h create mode 100644 ThirdParty/NVIDIAGfeSDK/Include/gfesdk/bindings/cpp/highlights/highlights_types_cpp.h create mode 100644 ThirdParty/NVIDIAGfeSDK/Include/gfesdk/bindings/cpp/highlights/ihighlights_cpp.h create mode 100644 ThirdParty/NVIDIAGfeSDK/Include/gfesdk/bindings/cpp/highlights/ihighlights_cpp_impl.h create mode 100644 ThirdParty/NVIDIAGfeSDK/Include/gfesdk/bindings/cpp/isdk_cpp.h create mode 100644 ThirdParty/NVIDIAGfeSDK/Include/gfesdk/bindings/cpp/isdk_cpp_impl.h create mode 100644 ThirdParty/NVIDIAGfeSDK/Include/gfesdk/bindings/cpp/sdk_types_cpp.h create mode 100644 ThirdParty/NVIDIAGfeSDK/Include/gfesdk/config.h create mode 100644 ThirdParty/NVIDIAGfeSDK/Include/gfesdk/gfe3_product_version.h create mode 100644 ThirdParty/NVIDIAGfeSDK/Include/gfesdk/highlights/highlights_types.h create mode 100644 ThirdParty/NVIDIAGfeSDK/Include/gfesdk/highlights/ihighlights.h create mode 100644 ThirdParty/NVIDIAGfeSDK/Include/gfesdk/isdk.h create mode 100644 ThirdParty/NVIDIAGfeSDK/Include/gfesdk/os_defines.h create mode 100644 ThirdParty/NVIDIAGfeSDK/Include/gfesdk/sdk_types.h create mode 100644 ThirdParty/NVIDIAGfeSDK/Include/gfesdk/sdk_types_ipc.h create mode 100644 ThirdParty/NVIDIAGfeSDK/lib/win32/GfeSDK.lib create mode 100644 ThirdParty/NVIDIAGfeSDK/lib/win32_uwp/GfeSDK.lib create mode 100644 ThirdParty/NVIDIAGfeSDK/lib/win64/GfeSDK.lib create mode 100644 ThirdParty/NVIDIAGfeSDK/lib/win64_uwp/GfeSDK.lib create mode 100644 ThirdParty/NVIDIAGfeSDK/redist/assets/img/img_logo_experience_512.png create mode 100644 ThirdParty/NVIDIAGfeSDK/redist/assets/img/menu.jpg create mode 100644 ThirdParty/NVIDIAGfeSDK/redist/win32/GfeSDK.dll create mode 100644 ThirdParty/NVIDIAGfeSDK/redist/win32_uwp/GfeSDK.dll create mode 100644 ThirdParty/NVIDIAGfeSDK/redist/win64/GfeSDK.dll create mode 100644 ThirdParty/NVIDIAGfeSDK/redist/win64_uwp/GfeSDK.dll diff --git a/Documentation/Manual.html b/Documentation/Manual.html new file mode 100644 index 0000000..31b0491 Binary files /dev/null and b/Documentation/Manual.html differ diff --git a/Documentation/Manual_files/colorschememapping.xml b/Documentation/Manual_files/colorschememapping.xml new file mode 100644 index 0000000..b200daa --- /dev/null +++ b/Documentation/Manual_files/colorschememapping.xml @@ -0,0 +1,2 @@ + + \ No newline at end of file diff --git a/Documentation/Manual_files/filelist.xml b/Documentation/Manual_files/filelist.xml new file mode 100644 index 0000000..30c6316 --- /dev/null +++ b/Documentation/Manual_files/filelist.xml @@ -0,0 +1,16 @@ + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Documentation/Manual_files/image001.png b/Documentation/Manual_files/image001.png new file mode 100644 index 0000000..84b2923 Binary files /dev/null and b/Documentation/Manual_files/image001.png differ diff --git a/Documentation/Manual_files/image002.png b/Documentation/Manual_files/image002.png new file mode 100644 index 0000000..2e87e9b Binary files /dev/null and b/Documentation/Manual_files/image002.png differ diff --git a/Documentation/Manual_files/image003.jpg b/Documentation/Manual_files/image003.jpg new file mode 100644 index 0000000..c046ade Binary files /dev/null and b/Documentation/Manual_files/image003.jpg differ diff --git a/Documentation/Manual_files/image003.png b/Documentation/Manual_files/image003.png new file mode 100644 index 0000000..3f88cc2 Binary files /dev/null and b/Documentation/Manual_files/image003.png differ diff --git a/Documentation/Manual_files/image004.jpg b/Documentation/Manual_files/image004.jpg new file mode 100644 index 0000000..05a3e2f Binary files /dev/null and b/Documentation/Manual_files/image004.jpg differ diff --git a/Documentation/Manual_files/image004.png b/Documentation/Manual_files/image004.png new file mode 100644 index 0000000..b56affb Binary files /dev/null and b/Documentation/Manual_files/image004.png differ diff --git a/Documentation/Manual_files/image005.jpg b/Documentation/Manual_files/image005.jpg new file mode 100644 index 0000000..afbabbb Binary files /dev/null and b/Documentation/Manual_files/image005.jpg differ diff --git a/Documentation/Manual_files/image005.png b/Documentation/Manual_files/image005.png new file mode 100644 index 0000000..fb582e1 Binary files /dev/null and b/Documentation/Manual_files/image005.png differ diff --git a/Documentation/Manual_files/image006.jpg b/Documentation/Manual_files/image006.jpg new file mode 100644 index 0000000..0e2d9fd Binary files /dev/null and b/Documentation/Manual_files/image006.jpg differ diff --git a/Documentation/Manual_files/image006.png b/Documentation/Manual_files/image006.png new file mode 100644 index 0000000..d0a003d Binary files /dev/null and b/Documentation/Manual_files/image006.png differ diff --git a/Documentation/Manual_files/image007.jpg b/Documentation/Manual_files/image007.jpg new file mode 100644 index 0000000..930263c Binary files /dev/null and b/Documentation/Manual_files/image007.jpg differ diff --git a/Documentation/Manual_files/image007.png b/Documentation/Manual_files/image007.png new file mode 100644 index 0000000..9a15c48 Binary files /dev/null and b/Documentation/Manual_files/image007.png differ diff --git a/Documentation/Manual_files/image008.jpg b/Documentation/Manual_files/image008.jpg new file mode 100644 index 0000000..dad0ce1 Binary files /dev/null and b/Documentation/Manual_files/image008.jpg differ diff --git a/Documentation/Manual_files/image008.png b/Documentation/Manual_files/image008.png new file mode 100644 index 0000000..e7f7023 Binary files /dev/null and b/Documentation/Manual_files/image008.png differ diff --git a/Documentation/Manual_files/image009.jpg b/Documentation/Manual_files/image009.jpg new file mode 100644 index 0000000..0f66c06 Binary files /dev/null and b/Documentation/Manual_files/image009.jpg differ diff --git a/Documentation/Manual_files/image009.png b/Documentation/Manual_files/image009.png new file mode 100644 index 0000000..0684434 Binary files /dev/null and b/Documentation/Manual_files/image009.png differ diff --git a/Documentation/Manual_files/image010.jpg b/Documentation/Manual_files/image010.jpg new file mode 100644 index 0000000..c39d3fa Binary files /dev/null and b/Documentation/Manual_files/image010.jpg differ diff --git a/Documentation/Manual_files/image010.png b/Documentation/Manual_files/image010.png new file mode 100644 index 0000000..d1027bb Binary files /dev/null and b/Documentation/Manual_files/image010.png differ diff --git a/Documentation/Manual_files/image011.jpg b/Documentation/Manual_files/image011.jpg new file mode 100644 index 0000000..0cb85f4 Binary files /dev/null and b/Documentation/Manual_files/image011.jpg differ diff --git a/Documentation/Manual_files/image012.jpg b/Documentation/Manual_files/image012.jpg new file mode 100644 index 0000000..97175c9 Binary files /dev/null and b/Documentation/Manual_files/image012.jpg differ diff --git a/Documentation/Manual_files/themedata.thmx b/Documentation/Manual_files/themedata.thmx new file mode 100644 index 0000000..3d2a437 Binary files /dev/null and b/Documentation/Manual_files/themedata.thmx differ diff --git a/NVIDIAGfeSDK.uplugin b/NVIDIAGfeSDK.uplugin new file mode 100644 index 0000000..925e063 --- /dev/null +++ b/NVIDIAGfeSDK.uplugin @@ -0,0 +1,25 @@ +{ + "FileVersion": 3, + "FriendlyName": "NVIDIA Shadowplay Highlights SDK Plugin", + "Version": 1, + "VersionName": "0.3", + "CreatedBy": "NVIDIA", + "CreatedByURL": "https://developer.nvidia.com/shadowplay-highlights", + "DocsURL": "", + "Description": "NVIDIA GeForce SDK with Shadowplay Highlights", + "Category": "Other", + "EnabledByDefault": false, + "Modules": [ + { + "Name": "NVIDIAGfeSDK", + "Type": "Runtime", + "LoadingPhase": "PostConfigInit", + "WhitelistPlatforms" : + [ + "Win64", + "Win32" + ] + } + ], + "CanContainContent": false +} \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..5bffdf2 --- /dev/null +++ b/README.md @@ -0,0 +1,20 @@ +# NVIDIA Shadowplay Highlights plugin # + +* GFE SDK Version: 1.1.173.5d889305 +* GeForce Experience minimum version: 3.8 +* Plugin version: 0.2 + +## About + +The plugin implements the GFE Shadowplay Highlights functionality for blueprints and provides UE4-style interfaces for C++ code compatibility. + +![Shadowplay Highlights](./ThirdParty/NVIDIAGfeSDK/redist/assets/img/menu.jpg) + +## How to use + +1. Navigate to Engine\Plugins\Runtime\Nvidia + +2. Execute: git submodule add -b ShadowplayHighlights_4.18_pluginonly https://github.com/NvPhysX/UnrealEngine.git GfeSDK + + +See the documentation [here](./Documentation/Manual.html) \ No newline at end of file diff --git a/Source/NVIDIAGfeSDK/NVIDIAGfeSDK.Build.cs b/Source/NVIDIAGfeSDK/NVIDIAGfeSDK.Build.cs new file mode 100644 index 0000000..30e3125 --- /dev/null +++ b/Source/NVIDIAGfeSDK/NVIDIAGfeSDK.Build.cs @@ -0,0 +1,102 @@ +// Copyright 1998-2016 Epic Games, Inc. All Rights Reserved. + +using System.IO; + +namespace UnrealBuildTool.Rules +{ + public class NVIDIAGfeSDK : ModuleRules + { + private string ModulePath + { + get { return ModuleDirectory; } + } + + private string ThirdPartyPath + { + get { return Path.GetFullPath(Path.Combine(ModulePath, "../../ThirdParty/")); } + } + + private string BinariesPath + { + get { return Path.GetFullPath(Path.Combine(ThirdPartyPath, "NVIDIAGfeSDK", "redist")); } + } + + private string LibraryPath + { + get { return Path.GetFullPath(Path.Combine(ThirdPartyPath, "NVIDIAGfeSDK", "lib")); } + } + + public NVIDIAGfeSDK(ReadOnlyTargetRules Target) : base(Target) + { + PublicIncludePaths.AddRange( + new string[] { + "NVIDIAGfeSDK/Public", + ThirdPartyPath + "NVIDIAGfeSDK/Include", + ThirdPartyPath + "NVIDIAGfeSDK/Include/gfesdk", + // ... add public include paths required here ... + } + ); + + PrivateIncludePaths.AddRange( + new string[] { + "NVIDIAGfeSDK/Private", + //Path.Combine(ThirdPartyPath, "NVIDIAGfeSDK", "Include"), + ThirdPartyPath + "NVIDIAGfeSDK/Include", + ThirdPartyPath + "NVIDIAGfeSDK/Include/gfesdk", + // ... add other private include paths required here ... + } + ); + + PublicDependencyModuleNames.AddRange( + new string[] + { + "Engine", + "Core", + "CoreUObject" + } + ); + + PrivateDependencyModuleNames.AddRange( + new string[] + { + // ... add private dependencies that you statically link with here ... + } + ); + + DynamicallyLoadedModuleNames.AddRange( + new string[] + { + // ... add any modules that your module loads dynamically here ... + } + ); + + LoadNVIDIAGfeSDKLib(Target); + } + + public bool LoadNVIDIAGfeSDKLib(ReadOnlyTargetRules Target) + { + bool isLibrarySupported = false; + + if ((Target.Platform == UnrealTargetPlatform.Win64) || (Target.Platform == UnrealTargetPlatform.Win32)) + { + isLibrarySupported = true; + + string PlatformString = (Target.Platform == UnrealTargetPlatform.Win64) ? "Win64" : "Win32"; + + string DllPath = Path.Combine(BinariesPath, PlatformString); + string LibFullPath = Path.Combine(LibraryPath, PlatformString); + + string DllName = Path.Combine(DllPath, "GfeSDK.dll"); + string LibFilePath = Path.Combine(LibFullPath, "GfeSDK.lib"); + + PublicLibraryPaths.Add(LibFullPath); + PublicAdditionalLibraries.Add("GfeSDK.lib"); + + PublicDelayLoadDLLs.Add("GfeSDK.dll"); + RuntimeDependencies.Add(new RuntimeDependency(DllName)); + } + + return isLibrarySupported; + } + } +} diff --git a/Source/NVIDIAGfeSDK/Private/FNVIDIAGfeSDK.cpp b/Source/NVIDIAGfeSDK/Private/FNVIDIAGfeSDK.cpp new file mode 100644 index 0000000..315cf2d --- /dev/null +++ b/Source/NVIDIAGfeSDK/Private/FNVIDIAGfeSDK.cpp @@ -0,0 +1,237 @@ +/* Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved. + * + * NVIDIA CORPORATION and its licensors retain all intellectual property + * and proprietary rights in and to this software, related documentation + * and any modifications thereto. Any use, reproduction, disclosure or + * distribution of this software and related documentation without an express + * license agreement from NVIDIA CORPORATION is strictly prohibited. + */ +#include "FNVIDIAGfeSDK.h" +#include "NVIDIAGfeSDKPrivatePCH.h" +#include "Runtime/Core/Public/Misc/Paths.h" +#include "Runtime/Core/Public/Windows/WindowsPlatformProcess.h" +#include "gfesdk/sdk_types.h" + + +#define LOCTEXT_NAMESPACE "NVIDIAGfeSDKPlugin" +#define PLUGIN_VERSION "1.0.0" + +DEFINE_LOG_CATEGORY(LogGfeSDK); + +static void __stdcall LoggingCallback(GfeSDK::NVGSDK_LogLevel level, char const* text) +{ + switch (level) + { + case GfeSDK::NVGSDK_LOG_NONE: + break; + case GfeSDK::NVGSDK_LOG_ERROR: + UE_LOG(LogGfeSDK, Warning, TEXT("%s"), UTF8_TO_TCHAR(text)); + break; + case GfeSDK::NVGSDK_LOG_INFO: + case GfeSDK::NVGSDK_LOG_DEBUG: + case GfeSDK::NVGSDK_LOG_VERBOSE: + default: + UE_LOG(LogGfeSDK, Log, TEXT("%s"), UTF8_TO_TCHAR(text)); + break; + } +} + +void FNVIDIAGfeSDK::StartupModule() +{ +#if PLATFORM_WINDOWS +#if _WIN64 + FString WinDir = TEXT("Win64/"); +#else + FString WinDir = TEXT("Win32/"); +#endif +#else +#error Platform currently unsupported +#endif // PLATFORM_WINDOWS + + // Get the base directory of this plugin + const FString PluginPath = FString(FPaths::EnginePluginsDir()); + + FString RootDllPath = PluginPath / FString::Printf(TEXT("Runtime/NVIDIA/GfeSDK/ThirdParty/NVIDIAGfeSDK/redist/")) / WinDir; + + FPlatformProcess::PushDllDirectory(*RootDllPath); + LibHandle = FPlatformProcess::GetDllHandle(*(RootDllPath + "GfeSDK.dll")); + FPlatformProcess::PopDllDirectory(*RootDllPath); + + if (!LibHandle) + { + UE_LOG(LogTemp, Warning, TEXT("Failed to load GfeSDK library.")); + } + else + { + UE_LOG(LogTemp, Log, TEXT("Using NVIDIAGfeSDKPlugin version %s"), TEXT(PLUGIN_VERSION)); + GfeSDK::AttachLogListener(LoggingCallback); + } +} + +void FNVIDIAGfeSDK::ShutdownModule() +{ + + Release(); + if (LibHandle) + { + FPlatformProcess::FreeDllHandle(LibHandle); + LibHandle = nullptr; + } +} + +static GfeSDK::NVGSDK_LogLevel getLogLevel(ELogVerbosity::Type verbosity) +{ + switch (verbosity) + { + case ELogVerbosity::NoLogging: + return GfeSDK::NVGSDK_LOG_NONE; + case ELogVerbosity::Fatal: + case ELogVerbosity::Error: + case ELogVerbosity::Warning: + return GfeSDK::NVGSDK_LOG_ERROR; + case ELogVerbosity::Display: + return GfeSDK::NVGSDK_LOG_INFO; + case ELogVerbosity::Log: + return GfeSDK::NVGSDK_LOG_DEBUG; + case ELogVerbosity::Verbose: + case ELogVerbosity::VeryVerbose: + return GfeSDK::NVGSDK_LOG_VERBOSE; + default: + return GfeSDK::NVGSDK_LOG_DEBUG; + } +} + +// Controls the log level of GfeSDK's internal logfile +GfeSDK::NVGSDK_RetCode FNVIDIAGfeSDK::SetFileLogLevel(ELogVerbosity::Type Level) +{ + if (!LibHandle) return GfeSDK::NVGSDK_ERR_MODULE_NOT_LOADED; + return GfeSDK::SetFileLogLevel(getLogLevel(Level)); +} + +// Controls the log level of logs that GfeSDK sends to the unreal logfile +GfeSDK::NVGSDK_RetCode FNVIDIAGfeSDK::SetUnrealLogLevel(ELogVerbosity::Type Level) +{ + if (!LibHandle) return GfeSDK::NVGSDK_ERR_MODULE_NOT_LOADED; + return GfeSDK::SetListenerLogLevel(getLogLevel(Level)); +} + +static const EGfeSDKScope ScopeMap[(size_t)EGfeSDKScope::MAX] = { + EGfeSDKScope::Highlights, + EGfeSDKScope::HighlightsRecordVideo, + EGfeSDKScope::HighlightsRecordScreenshot +}; + +static const EGfeSDKPermission PermissionMap[] = { + EGfeSDKPermission::Granted, + EGfeSDKPermission::MustAsk, + EGfeSDKPermission::Denied, + EGfeSDKPermission::Unknown +}; + +void __stdcall OnNotificationCallback(GfeSDK::NVGSDK_NotificationType type, GfeSDK::NVGSDK_Notification const* response, void* context) +{ + FNVIDIAGfeSDK* SDKObject = static_cast(context); + switch (type) + { + case GfeSDK::NVGSDK_NOTIFICATION_PERMISSIONS_CHANGED: + { + FGfeSDKPermissionsChangedData PermissionsChangedData; + + for (size_t i = 0; i < response->permissionsChanged.scopePermissionTableSize; i++) + { + PermissionsChangedData.ScopePermissions.Add(ScopeMap[response->permissionsChanged.scopePermissionTable[i].scope], PermissionMap[response->permissionsChanged.scopePermissionTable[i].permission]); + } + if (SDKObject) + SDKObject->PermissionsChangedDelegate.ExecuteIfBound(PermissionsChangedData); + } + } +} + +EGfeSDKReturnCode FNVIDIAGfeSDK::Create(FGfeSDKCreateInputParams const& InputParams, FGfeSDKCreateResponse& Response) +{ + if (!GFEHandle) + { + GfeSDK::NVGSDK_HANDLE* Handle = nullptr; + + GfeSDK::NVGSDK_CreateInputParams InputParamsCreate; + GfeSDK::NVGSDK_CreateResponse OutputParamsCreate; + + std::string appNameUTF = TCHAR_TO_UTF8(*InputParams.AppName); + + InputParamsCreate.appName = appNameUTF.c_str(); + InputParamsCreate.pollForCallbacks = InputParams.PollForCallbacks; + + std::vector Scopes(InputParams.RequiredScopes.Num()); + + for (size_t i = 0; i cScopePermissionList(Scopes.size()); + OutputParamsCreate.scopePermissionTable = &cScopePermissionList[0]; + OutputParamsCreate.scopePermissionTableSize = Scopes.size(); + + GfeSDK::NVGSDK_RetCode Result = GfeSDK::NVGSDK_Create(&Handle, &InputParamsCreate, &OutputParamsCreate); + + if (GfeSDK::NVGSDK_SUCCEEDED(Result)) + { + GFEHandle = Handle; + Response.VersionMajor = OutputParamsCreate.versionMajor; + Response.VersionMinor = OutputParamsCreate.versionMinor; + Response.NVIDIAGfeVersion = FString(OutputParamsCreate.gfeVersionStr); + + SdkCore.Reset(new FGfeSDKCore(GFEHandle)); + SdkHighlights.Reset(new FGfeSDKHighlights(GFEHandle)); + + for (size_t i = 0; i < OutputParamsCreate.scopePermissionTableSize; i++) + { + Response.ScopePermissions.Add( + TranslateEnum(kScopeSdkToUnreal, OutputParamsCreate.scopePermissionTable[i].scope, EGfeSDKScope::MAX), + TranslateEnum(kPermissionSdkToUnreal, OutputParamsCreate.scopePermissionTable[i].permission, EGfeSDKPermission::MAX)); + } + } + else + { + // clear the response + Response = FGfeSDKCreateResponse(); + UE_LOG(LogGfeSDK, Error, TEXT("Failed to create GfeSDK: %d"), (int)Result); + } + + return TranslateReturnCodeToUnreal(Result); + } + else + { + return TranslateReturnCodeToUnreal(GfeSDK::NVGSDK_RetCode::NVGSDK_SUCCESS); + } + +} + +void FNVIDIAGfeSDK::Release() +{ + if (GFEHandle) + { + NVGSDK_Release(GFEHandle); + GFEHandle = nullptr; + } + SdkHighlights.Reset(); +} + +FGfeSDKCore* FNVIDIAGfeSDK::Core() +{ + return SdkCore.Get(); +} + +FGfeSDKHighlights* FNVIDIAGfeSDK::Highlights() +{ + return SdkHighlights.Get(); +} + +IMPLEMENT_MODULE(FNVIDIAGfeSDK, NVIDIAGfeSDK) + +#undef LOCTEXT_NAMESPACE diff --git a/Source/NVIDIAGfeSDK/Private/FNVIDIAGfeSDK.h b/Source/NVIDIAGfeSDK/Private/FNVIDIAGfeSDK.h new file mode 100644 index 0000000..f021576 --- /dev/null +++ b/Source/NVIDIAGfeSDK/Private/FNVIDIAGfeSDK.h @@ -0,0 +1,46 @@ +/* Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved. + * + * NVIDIA CORPORATION and its licensors retain all intellectual property + * and proprietary rights in and to this software, related documentation + * and any modifications thereto. Any use, reproduction, disclosure or + * distribution of this software and related documentation without an express + * license agreement from NVIDIA CORPORATION is strictly prohibited. + */ + +#pragma once + +#include "NVIDIAGfeSDKPrivatePCH.h" +#include "../Public/INVIDIAGfeSDK.h" + +namespace GfeSDK { + class Core; + class Highlights; +} + +DECLARE_LOG_CATEGORY_EXTERN(LogGfeSDK, Log, All); + +class FNVIDIAGfeSDK : public INVIDIAGfeSDK +{ +public: + FNVIDIAGfeSDK(): GFEHandle(nullptr) {} + virtual ~FNVIDIAGfeSDK() {} + + virtual void StartupModule() override; + virtual void ShutdownModule() override; + + virtual GfeSDK::NVGSDK_RetCode SetFileLogLevel(ELogVerbosity::Type Level); + virtual GfeSDK::NVGSDK_RetCode SetUnrealLogLevel(ELogVerbosity::Type Level); + + virtual EGfeSDKReturnCode Create(FGfeSDKCreateInputParams const& InputParams, FGfeSDKCreateResponse& Response); + virtual void Release(); + virtual FGfeSDKCore* Core(); + virtual FGfeSDKHighlights* Highlights(); + +private: + void* LibHandle = nullptr; + + TUniquePtr SdkHighlights; + TUniquePtr SdkCore; + // SDK handle for C interface + GfeSDK::NVGSDK_HANDLE* GFEHandle; +}; diff --git a/Source/NVIDIAGfeSDK/Private/GfeSDKCore.cpp b/Source/NVIDIAGfeSDK/Private/GfeSDKCore.cpp new file mode 100644 index 0000000..8abd970 --- /dev/null +++ b/Source/NVIDIAGfeSDK/Private/GfeSDKCore.cpp @@ -0,0 +1,65 @@ +/* Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved. +* +* NVIDIA CORPORATION and its licensors retain all intellectual property +* and proprietary rights in and to this software, related documentation +* and any modifications thereto. Any use, reproduction, disclosure or +* distribution of this software and related documentation without an express +* license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ +#include "GfeSDKCore.h" + +#include "NVIDIAGfeSDKPrivatePCH.h" + +#define VALIDATE_MODULE_CORE() \ + if (!GFEHandle && Callback) \ + { \ + Callback(GfeSDK::NVGSDK_ERR_MODULE_NOT_LOADED, Context); \ + return; \ + } + +#define VALIDATE_MODULE_CORE_SPECIALIZED() \ + if (!GFEHandle && Callback) \ + { \ + Callback(GfeSDK::NVGSDK_ERR_MODULE_NOT_LOADED, nullptr, Context); \ + return; \ + } + +FGfeSDKCore::FGfeSDKCore(GfeSDK::NVGSDK_HANDLE* GFEHandle_) + : GFEHandle(GFEHandle_) +{ +} + +FGfeSDKCore::~FGfeSDKCore() +{ +} + +void FGfeSDKCore::Poll() +{ + if (GFEHandle) + GfeSDK::NVGSDK_Poll(GFEHandle); +} + +void FGfeSDKCore::RequestPermissionsAsync(FGfeSDKRequestPermissionsParams const& Params, GfeSDK::NVGSDK_EmptyCallback Callback, void* Context) +{ + VALIDATE_MODULE_CORE(); + + std::vector Scopes(Params.Scopes.Num()); + + for (int32 i = 0; i < Params.Scopes.Num(); i++) + { + Scopes[i] = TranslateEnum(kScopeUnrealToSdk, Params.Scopes[i], GfeSDK::NVGSDK_SCOPE_MAX); + } + + GfeSDK::NVGSDK_RequestPermissionsParams cParams; + cParams.scopeTable = const_cast(Scopes.data()); + cParams.scopeTableSize = Scopes.size(); + + GfeSDK::NVGSDK_RequestPermissionsAsync(GFEHandle, &cParams, Callback, Context); +} + +void FGfeSDKCore::GetUILanguageAsync(GfeSDK::NVGSDK_GetUILanguageCallback Callback, void* Context) +{ + VALIDATE_MODULE_CORE_SPECIALIZED(); + + GfeSDK::NVGSDK_GetUILanguageAsync(GFEHandle, Callback, Context); +} diff --git a/Source/NVIDIAGfeSDK/Private/GfeSDKHighlights.cpp b/Source/NVIDIAGfeSDK/Private/GfeSDKHighlights.cpp new file mode 100644 index 0000000..bf24347 --- /dev/null +++ b/Source/NVIDIAGfeSDK/Private/GfeSDKHighlights.cpp @@ -0,0 +1,245 @@ +/* Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved. +* +* NVIDIA CORPORATION and its licensors retain all intellectual property +* and proprietary rights in and to this software, related documentation +* and any modifications thereto. Any use, reproduction, disclosure or +* distribution of this software and related documentation without an express +* license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ +#include "GfeSDKHighlights.h" +#include "NVIDIAGfeSDKPrivatePCH.h" +#include "Platform.h" + +#define VALIDATE_MODULE_HIGHLIGHTS() \ + if (!GFEHandle && Callback) \ + { \ + Callback(GfeSDK::NVGSDK_ERR_MODULE_NOT_LOADED, Context); \ + return; \ + } + +#define VALIDATE_MODULE_HIGHLIGHTS_SPECIALIZED() \ + if (!GFEHandle && Callback) \ + { \ + Callback(GfeSDK::NVGSDK_ERR_MODULE_NOT_LOADED, nullptr, Context); \ + return; \ + } + +struct LocaleStringPair +{ + std::string localeCode; + std::string localizedString; +}; + +struct LocaleHighlightsList +{ + std::vector Strings; + std::vector Pairs; +}; + +FGfeSDKHighlights::FGfeSDKHighlights(GfeSDK::NVGSDK_HANDLE* Handle) : + GFEHandle(Handle) +{} + +FGfeSDKHighlights::~FGfeSDKHighlights() +{} + +void FGfeSDKHighlights::ConfigureAsync(FGfeSDKHighlightConfigParams const& Params, GfeSDK::NVGSDK_EmptyCallback Callback, void* Context) +{ + VALIDATE_MODULE_HIGHLIGHTS(); + + std::string UTF8DefaultLocale = TCHAR_TO_UTF8(*Params.DefaultLocale); + GfeSDK::NVGSDK_HighlightConfigParams cParams; + cParams.defaultLocale = UTF8DefaultLocale.c_str(); + + // Temporary storages for structure elements required by ConfigureAsync function + std::vector Highlights(Params.HighlightDefinitions.Num()); + // TCHAR_TO_UTF8 shares internal buffer, so its results need to be assigned by copy, not pointer. + std::vector id(Params.HighlightDefinitions.Num()); // Workaround for usage of TCHAR_TO_UTF8. + std::vector LocaleStringPairs(Params.HighlightDefinitions.Num()); + + for (int32 i=0; i cGroupViews(Params.GroupViews.Num()); + std::vector StringCache(Params.GroupViews.Num()); + + for (size_t i = 0; i < cGroupViews.size(); i++) + { + StringCache[i] = TCHAR_TO_UTF8(*Params.GroupViews[i].GroupId); + cGroupViews[i].groupId = StringCache[i].c_str(); + cGroupViews[i].tagsFilter = TranslateBitfieldEnum(kHighlightTypeUnrealToSdk, Params.GroupViews[i].TagsFilter); + cGroupViews[i].significanceFilter = TranslateBitfieldEnum(kHighlightSignificanceUnrealToSdk, Params.GroupViews[i].SignificanceFilter); + } + cParams.groupSummaryTable = cGroupViews.data(); + cParams.groupSummaryTableSize = cGroupViews.size(); + + GfeSDK::NVGSDK_Highlights_OpenSummaryAsync(GFEHandle, &cParams, Callback, Context); +} + +void FGfeSDKHighlights::GetNumberOfHighlightsAsync(FGfeSDKHighlightGroupView const& GroupView, GfeSDK::NVGSDK_Highlights_GetNumberOfHighlightsCallback Callback, void* Context) +{ + VALIDATE_MODULE_HIGHLIGHTS_SPECIALIZED(); + GfeSDK::NVGSDK_GroupView groupView; + std::string gID = TCHAR_TO_UTF8(*GroupView.GroupId); + groupView.groupId = gID.c_str(); + groupView.tagsFilter = TranslateBitfieldEnum(kHighlightTypeUnrealToSdk, GroupView.TagsFilter); + groupView.significanceFilter = TranslateBitfieldEnum(kHighlightSignificanceUnrealToSdk, GroupView.SignificanceFilter); + + GfeSDK::NVGSDK_Highlights_GetNumberOfHighlightsAsync(GFEHandle, &groupView, Callback, Context); +} + +struct SNumHighlightsInfo +{ + volatile bool Ready; + int32 NumberOfHighlights; + + SNumHighlightsInfo(): + Ready(false), + NumberOfHighlights(0) + {} +}; + +void __stdcall OnGetNumberOfHighlightsCallbackBlocking(GfeSDK::NVGSDK_RetCode rt, GfeSDK::NVGSDK_Highlights_NumberOfHighlights const* NumberOfHighlights, void* context) +{ + SNumHighlightsInfo* NCB = static_cast(context); + if (NCB) + { + NCB->NumberOfHighlights = NumberOfHighlights->numberOfHighlights; + NCB->Ready = true; + } +} + +int32 FGfeSDKHighlights::GetNumberOfHighlights(FGfeSDKHighlightGroupView const& GroupView) +{ + SNumHighlightsInfo NCB; + GetNumberOfHighlightsAsync(GroupView, &OnGetNumberOfHighlightsCallbackBlocking, &NCB); + int32 IterationCounter = 0; + // Polling cycle (not sure if this is correct for UE4, if we need a blocking function) + // Wait for 10 seconds and return 0 if time is up + while (!NCB.Ready && (IterationCounter < 1000)) + { + Poll(); + FPlatformProcess::Sleep(0.001f); + IterationCounter++; + } + return NCB.NumberOfHighlights; +} + +void FGfeSDKHighlights::Poll() +{ + if (GFEHandle) + GfeSDK::NVGSDK_Poll(GFEHandle); +} \ No newline at end of file diff --git a/Source/NVIDIAGfeSDK/Private/HighLightBlueprint.cpp b/Source/NVIDIAGfeSDK/Private/HighLightBlueprint.cpp new file mode 100644 index 0000000..c6de5a7 --- /dev/null +++ b/Source/NVIDIAGfeSDK/Private/HighLightBlueprint.cpp @@ -0,0 +1,697 @@ +// Fill out your copyright notice in the Description page of Project Settings. + +#include "HighLightBlueprint.h" +#include "NVIDIAGfeSDKPrivatePCH.h" +#include "FNVIDIAGfeSDK.h" +#include "NVIDIAGfeSDKTypes.h" +#include "CoreMinimal.h" +#include "Runtime/CoreUObject/Public/UObject/Package.h" +#include "Platform.h" + +#include +#include + +template +static FORCEINLINE FString EnumToString(const FString& Name, TEnum Value) +{ + const UEnum* enumPtr = FindObject(ANY_PACKAGE, *Name, true); + if (!enumPtr) + { + return FString("Invalid"); + } + return enumPtr->GetNameByValue((int64)Value).ToString(); +} + +class CGFEHighlights +{ +public: + + + CGFEHighlights(FString AppName) + { + static const EGfeSDKScope kRequiredScopes[] = { + EGfeSDKScope::Highlights, + EGfeSDKScope::HighlightsRecordScreenshot, + EGfeSDKScope::HighlightsRecordVideo + }; + + INVIDIAGfeSDK::Get().SetFileLogLevel(ELogVerbosity::Verbose); + INVIDIAGfeSDK::Get().SetUnrealLogLevel(ELogVerbosity::Display); + + INVIDIAGfeSDK::Get().PermissionsChangedDelegate.BindRaw(this, &CGFEHighlights::OnPermissionsChanged); + + FGfeSDKCreateInputParams InParams; + InParams.AppName = *AppName; + InParams.RequiredScopes.Append(kRequiredScopes, sizeof(kRequiredScopes) / sizeof(EGfeSDKScope)); + InParams.PollForCallbacks = true; + + FGfeSDKCreateResponse OutParams; + EGfeSDKReturnCode ret = INVIDIAGfeSDK::Get().Create(InParams, OutParams); + if (ret == EGfeSDKReturnCode::Success) + { + // We have successfully initialized the SDK and passed the version check + } + else if (ret == EGfeSDKReturnCode::SuccessIpcOldSdk) + { + // We have successfully initialized the SDK. We are running an older version of the GFESDK + // as compared to the installed GFE, but are still ok + UE_LOG(LogTemp, Log, TEXT("We are running an older version of the GFESDK. Backend Version %d.%d GFE version %s"), + OutParams.VersionMajor, OutParams.VersionMinor, *OutParams.NVIDIAGfeVersion); + } + else if (ret == EGfeSDKReturnCode::SuccessIpcOldGfe) + { + // We have successfully initialized the SDK, but the installed version of GFE is older. + // Older functionality will still work, but game should check the returned Version to + // see if the required functionality is present in the older version. + UE_LOG(LogTemp, Log, TEXT("We have successfully initialized the SDK, but the installed version of GFE is older. Backend Version %d.%d GFE version %s"), + OutParams.VersionMajor, OutParams.VersionMinor, *OutParams.NVIDIAGfeVersion); + } + else if (ret == EGfeSDKReturnCode::ErrorGfeVersion) + { + // The installed GFE is too old to continue. User must download newer GFE. + UE_LOG(LogTemp, Warning, TEXT("The installed GFE is too old to continue. User must download newer GFE.")); + } + else if (ret == EGfeSDKReturnCode::ErrorSdkVersion) + { + // This version of the GfeSDK is too old to continue. Game needs to distribute newer version. + // This is UNLIKELY + UE_LOG(LogTemp, Warning, TEXT("This version of the GfeSDK is too old to continue. Game needs to distribute newer version.")); + } + else if (ret == EGfeSDKReturnCode::Error) + { + UE_LOG(LogTemp, Warning, TEXT("Failed to connect to GfeSDK backend")); + return; + } + + if (ret >= EGfeSDKReturnCode::Error) + { + UE_LOG(LogTemp, Log, TEXT("FAILED to connect with GfeSDK. Backend Version %d.%d GFE version %s"), + OutParams.VersionMajor, OutParams.VersionMinor, *OutParams.NVIDIAGfeVersion); + } + else + { + UE_LOG(LogTemp, Log, TEXT("Connected with GfeSDK. Backend Version %d.%d GFE version %s"), + OutParams.VersionMajor, OutParams.VersionMinor, *OutParams.NVIDIAGfeVersion); + } + + mPermissionsNeeded.Empty(); + for (auto& ScopePermission : OutParams.ScopePermissions) + { + UE_LOG(LogTemp, Log, TEXT("Required Scope %s has permission %s"), + *EnumToString("EGfeSDKScope", ScopePermission.Key), *EnumToString("EGfeSDKPermission", ScopePermission.Value)); + if (ScopePermission.Value == EGfeSDKPermission::MustAsk) + { + mPermissionsNeeded.Add(ScopePermission.Key); + } + } + } + ~CGFEHighlights() + { + INVIDIAGfeSDK::Get().Release(); + } +protected: + TMap mLastScopePermissions; + TArray mPermissionsNeeded; + + void OnPermissionsChanged(FGfeSDKPermissionsChangedData const& PermissionsChangedData) + { + UE_LOG(LogTemp, Log, TEXT("Permissions Changed notification")); + for (auto& ScopePermission : PermissionsChangedData.ScopePermissions) + { + UE_LOG(LogTemp, Log, TEXT("Scope %s now has permission %s"), + *EnumToString("EGfeSDKScope", ScopePermission.Key), *EnumToString("EGfeSDKPermission", ScopePermission.Value)); + if (ScopePermission.Value == EGfeSDKPermission::MustAsk) + { + mPermissionsNeeded.Add(ScopePermission.Key); + } + } + mLastScopePermissions = PermissionsChangedData.ScopePermissions; + } +}; + + + +//--------------------------------------------------------------------------- + +inline EGfeSDKReturnCode ConvertRetCode(GfeSDK::NVGSDK_RetCode rt) +{ + switch (rt) + { + case GfeSDK::NVGSDK_SUCCESS: return EGfeSDKReturnCode::Success; + case GfeSDK::NVGSDK_SUCCESS_VERSION_OLD_SDK: return EGfeSDKReturnCode::SuccessIpcOldSdk; + case GfeSDK::NVGSDK_SUCCESS_VERSION_OLD_GFE: return EGfeSDKReturnCode::SuccessIpcOldGfe; + case GfeSDK::NVGSDK_ERR_GFE_VERSION: return EGfeSDKReturnCode::ErrorGfeVersion; + case GfeSDK::NVGSDK_ERR_SDK_VERSION: return EGfeSDKReturnCode::ErrorSdkVersion; + case GfeSDK::NVGSDK_ERR_MODULE_NOT_LOADED: return EGfeSDKReturnCode::ErrorModuleNotLoaded; + default: return EGfeSDKReturnCode::Error; + } +} + +//--------------------------------------------------------------------------- +//--------- Polling from function library ----------------------------------- +//--------------------------------------------------------------------------- + +UHighlightsFunctionLibrary::UHighlightsFunctionLibrary(const FObjectInitializer& ObjectInitializer) + : Super(ObjectInitializer) +{ +} + +//--------------------------------------------------------------------------- + +void UHighlightsFunctionLibrary::Poll() +{ + FGfeSDKHighlights* HiL = INVIDIAGfeSDK::Get().Highlights(); + if (HiL) + { + HiL->Poll(); + } +} + +void UHighlightsFunctionLibrary::ChekIfHighlightsAvailable(const FGfeSDKCreateResponse& InitProperties, bool &VideoGranted, bool &ScreenshotsGranted, EGfeSDKPermission &Video, EGfeSDKPermission &Screenshots) +{ + const EGfeSDKPermission* H = InitProperties.ScopePermissions.Find(EGfeSDKScope::Highlights); + + VideoGranted = false; + ScreenshotsGranted = false; + Video = EGfeSDKPermission::Denied; + Screenshots = EGfeSDKPermission::Denied; + + if (H && (*H) == EGfeSDKPermission::Granted) + { + const EGfeSDKPermission* V = InitProperties.ScopePermissions.Find(EGfeSDKScope::HighlightsRecordVideo); + if (V) + { + Video = (*V); + if (Video == EGfeSDKPermission::Granted) + VideoGranted = true; + } + const EGfeSDKPermission* S = InitProperties.ScopePermissions.Find(EGfeSDKScope::HighlightsRecordScreenshot); + if (S) + { + Screenshots = (*S); + if (Screenshots == EGfeSDKPermission::Granted) + ScreenshotsGranted = true; + } + } +} + +//--------------------------------------------------------------------------- +//----------- Initialization class event ------------------------------------ +//--------------------------------------------------------------------------- + +UInitHighlights* UInitHighlights::InitHighlights(UObject* WorldContextObject, const FString InGameName, const bool Video, const bool Screenshots) +{ + UInitHighlights* Proxy = NewObject(); + Proxy->GameName = InGameName; + Proxy->RequestedPermissions.Empty(); + Proxy->RequestedPermissions.Add(EGfeSDKScope::Highlights); + if (Video) + Proxy->RequestedPermissions.Add(EGfeSDKScope::HighlightsRecordVideo); + if (Screenshots) + Proxy->RequestedPermissions.Add(EGfeSDKScope::HighlightsRecordScreenshot); + + Proxy->WorldContextObject = WorldContextObject; + return Proxy; +} + +//--------------------------------------------------------------------------- + +void UInitHighlights::Activate() +{ + INVIDIAGfeSDK::Get().SetFileLogLevel(ELogVerbosity::Verbose); + INVIDIAGfeSDK::Get().SetUnrealLogLevel(ELogVerbosity::Display); + + INVIDIAGfeSDK::Get().PermissionsChangedDelegate.BindUObject(this, &UInitHighlights::OnPermissionsChanged); + + FGfeSDKCreateInputParams InParams; + InParams.AppName = *GameName; + InParams.RequiredScopes = RequestedPermissions; + InParams.PollForCallbacks = true; + + FGfeSDKCreateResponse OutParams; + EGfeSDKReturnCode ret = INVIDIAGfeSDK::Get().Create(InParams, OutParams); + if (ret == EGfeSDKReturnCode::Success) + { + // We have successfully initialized the SDK and passed the version check + } + else if (ret == EGfeSDKReturnCode::SuccessIpcOldSdk) + { + // We have successfully initialized the SDK. We are running an older version of the GFESDK + // as compared to the installed GFE, but are still ok + /*FFrame::KismetExecutionMessage(*FString::Printf(TEXT("We are running an older version of the GFESDK. Backend Version %d.%d GFE version %s"), + OutParams.VersionMajor, OutParams.VersionMinor, *OutParams.NVIDIAGfeVersion), ELogVerbosity::Warning);*/ + } + else if (ret == EGfeSDKReturnCode::SuccessIpcOldGfe) + { + // We have successfully initialized the SDK, but the installed version of GFE is older. + // Older functionality will still work, but game should check the returned Version to + // see if the required functionality is present in the older version. + /*UE_LOG(LogTemp, Log, TEXT("We have successfully initialized the SDK, but the installed version of GFE is older. Backend Version %d.%d GFE version %s"), + OutParams.VersionMajor, OutParams.VersionMinor, *OutParams.NVIDIAGfeVersion);*/ + } + else if (ret == EGfeSDKReturnCode::ErrorGfeVersion) + { + // The installed GFE is too old to continue. User must download newer GFE. + //UE_LOG(LogTemp, Warning, TEXT("The installed GFE is too old to continue. User must download newer GFE.")); + FFrame::KismetExecutionMessage(*FString::Printf(TEXT("The installed GFE is too old to continue. User must download newer GFE.")), ELogVerbosity::Error); + } + else if (ret == EGfeSDKReturnCode::ErrorSdkVersion) + { + // This version of the GfeSDK is too old to continue. Game needs to distribute newer version. + // This is UNLIKELY + FFrame::KismetExecutionMessage(*FString::Printf(TEXT("This version of the GfeSDK is too old to continue. Game needs to distribute newer version.")), ELogVerbosity::Error); + } + else if (ret == EGfeSDKReturnCode::Error) + { + //UE_LOG(LogTemp, Warning, TEXT("Failed to connect to GfeSDK backend")); + return; + } + + mPermissionsNeeded.Empty(); + for (auto& ScopePermission : OutParams.ScopePermissions) + { + /*UE_LOG(LogTemp, Log, TEXT("Required Scope %s has permission %s"), + *EnumToString("EGfeSDKScope", ScopePermission.Key), *EnumToString("EGfeSDKPermission", ScopePermission.Value));*/ + if (ScopePermission.Value == EGfeSDKPermission::MustAsk) + { + mPermissionsNeeded.Add(ScopePermission.Key); + } + } + + if (ret >= EGfeSDKReturnCode::Error) + { + OnFailure.Broadcast(ret); + UE_LOG(LogTemp, Log, TEXT("FAILED to connect with GfeSDK. Backend Version %d.%d GFE version %s"), + OutParams.VersionMajor, OutParams.VersionMinor, *OutParams.NVIDIAGfeVersion); + } + else + { + OnSuccess.Broadcast(ret, OutParams); + UE_LOG(LogTemp, Log, TEXT("Connected with GfeSDK. Backend Version %d.%d GFE version %s"), + OutParams.VersionMajor, OutParams.VersionMinor, *OutParams.NVIDIAGfeVersion); + } +} + +//--------------------------------------------------------------------------- + +void UInitHighlights::Callback() +{ + +} + +//--------------------------------------------------------------------------- + +void UInitHighlights::OnPermissionsChanged(FGfeSDKPermissionsChangedData const& PermissionsChangedData) +{ + UE_LOG(LogTemp, Log, TEXT("Permissions Changed notification")); + for (auto& ScopePermission : PermissionsChangedData.ScopePermissions) + { + UE_LOG(LogTemp, Log, TEXT("Scope %s now has permission %s"), + *EnumToString("EGfeSDKScope", ScopePermission.Key), *EnumToString("EGfeSDKPermission", ScopePermission.Value)); + if (ScopePermission.Value == EGfeSDKPermission::MustAsk) + { + mPermissionsNeeded.Add(ScopePermission.Key); + } + } + mLastScopePermissions = PermissionsChangedData.ScopePermissions; +} + +//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- + + +UHighlightsConfigureAsync* UHighlightsConfigureAsync::HighlightsConfigure(UObject* WorldContextObject, const FGfeSDKHighlightConfigParams& ConfigParams) +{ + UHighlightsConfigureAsync* Proxy = NewObject(); + Proxy->WorldContextObject = WorldContextObject; + Proxy->ConfigParams = ConfigParams; + return Proxy; +} + +//--------------------------------------------------------------------------- + +void __stdcall UHighlightsConfigureAsync::OnConfigureCallback(GfeSDK::NVGSDK_RetCode rt, void* context) +{ + UHighlightsConfigureAsync* Th = static_cast(context); + if (Th) + { + if (NVGSDK_SUCCEEDED(rt)) + { + Th->OnSuccess.Broadcast(ConvertRetCode(rt)); + } + else + { + Th->OnFailure.Broadcast(ConvertRetCode(rt)); + } + + } + +} +void UHighlightsConfigureAsync::Activate() +{ + FGfeSDKHighlights* HiL = INVIDIAGfeSDK::Get().Highlights(); + if (HiL) + { + HiL->ConfigureAsync(ConfigParams, &OnConfigureCallback, this); + } + else + { + OnFailure.Broadcast(EGfeSDKReturnCode::ErrorModuleNotLoaded); + } +} + +//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- + + +UHighlightsOpenGroupAsync* UHighlightsOpenGroupAsync::HighlightsOpenGroup(UObject* WorldContextObject, const FGfeSDKHighlightOpenGroupParams& Params) +{ + UHighlightsOpenGroupAsync* Proxy = NewObject(); + Proxy->WorldContextObject = WorldContextObject; + Proxy->Params = Params; + return Proxy; +} + +//--------------------------------------------------------------------------- + +void __stdcall UHighlightsOpenGroupAsync::OnOpenGroupCallback(GfeSDK::NVGSDK_RetCode rt, void* context) +{ + UHighlightsOpenGroupAsync* Th = static_cast(context); + if (Th) + { + if (NVGSDK_SUCCEEDED(rt)) + { + Th->OnSuccess.Broadcast(ConvertRetCode(rt)); + } + else + { + Th->OnFailure.Broadcast(ConvertRetCode(rt)); + } + + } + +} +void UHighlightsOpenGroupAsync::Activate() +{ + FGfeSDKHighlights* HiL = INVIDIAGfeSDK::Get().Highlights(); + if (HiL) + { + HiL->OpenGroupAsync(Params, &OnOpenGroupCallback, this); + } + else + { + OnFailure.Broadcast(EGfeSDKReturnCode::ErrorModuleNotLoaded); + } +} + +//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- + + +UHighlightsCloseGroupAsync* UHighlightsCloseGroupAsync::HighlightsCloseGroup(UObject* WorldContextObject, const FString& GroupId, const bool& DestroyHighlights) +{ + UHighlightsCloseGroupAsync* Proxy = NewObject(); + Proxy->WorldContextObject = WorldContextObject; + Proxy->Params.GroupId = GroupId; + Proxy->Params.DestroyHighlights = DestroyHighlights; + return Proxy; +} + +//--------------------------------------------------------------------------- + +void __stdcall UHighlightsCloseGroupAsync::OnCloseGroupCallback(GfeSDK::NVGSDK_RetCode rt, void* context) +{ + UHighlightsCloseGroupAsync* Th = static_cast(context); + if (Th) + { + if (NVGSDK_SUCCEEDED(rt)) + { + Th->OnSuccess.Broadcast(ConvertRetCode(rt)); + } + else + { + Th->OnFailure.Broadcast(ConvertRetCode(rt)); + } + + } + +} +void UHighlightsCloseGroupAsync::Activate() +{ + FGfeSDKHighlights* HiL = INVIDIAGfeSDK::Get().Highlights(); + if (HiL) + { + HiL->CloseGroupAsync(Params, &OnCloseGroupCallback, this); + } + else + { + OnFailure.Broadcast(EGfeSDKReturnCode::ErrorModuleNotLoaded); + } +} + +//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- + + +UHighlightsSetScreenshotAsync* UHighlightsSetScreenshotAsync::HighlightsSetScreenshot(UObject* WorldContextObject, const FString& GroupId, const FString& HighlightId) +{ + UHighlightsSetScreenshotAsync* Proxy = NewObject(); + Proxy->WorldContextObject = WorldContextObject; + Proxy->Params.GroupId = GroupId; + Proxy->Params.HighlightId = HighlightId; + return Proxy; +} + +//--------------------------------------------------------------------------- + +void __stdcall UHighlightsSetScreenshotAsync::OnSetScreenshotCallback(GfeSDK::NVGSDK_RetCode rt, void* context) +{ + UHighlightsSetScreenshotAsync* Th = static_cast(context); + if (Th) + { + if (NVGSDK_SUCCEEDED(rt)) + { + Th->OnSuccess.Broadcast(ConvertRetCode(rt)); + } + else + { + Th->OnFailure.Broadcast(ConvertRetCode(rt)); + } + + } + +} +void UHighlightsSetScreenshotAsync::Activate() +{ + FGfeSDKHighlights* HiL = INVIDIAGfeSDK::Get().Highlights(); + if (HiL) + { + HiL->SetScreenshotHighlightAsync(Params, &OnSetScreenshotCallback, this); + } + else + { + OnFailure.Broadcast(EGfeSDKReturnCode::ErrorModuleNotLoaded); + } +} + +//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- + + +UHighlightsSetVideoAsync* UHighlightsSetVideoAsync::HighlightsSetVideo(UObject* WorldContextObject, const FString& GroupId, const FString& HighlightId, const int32& StartDelta, const int32& EndDelta) +{ + UHighlightsSetVideoAsync* Proxy = NewObject(); + Proxy->WorldContextObject = WorldContextObject; + Proxy->Params.GroupId = GroupId; + Proxy->Params.HighlightId = HighlightId; + Proxy->Params.StartDelta = StartDelta; + Proxy->Params.EndDelta = EndDelta; + return Proxy; +} + +//--------------------------------------------------------------------------- + +void __stdcall UHighlightsSetVideoAsync::OnSetVideoCallback(GfeSDK::NVGSDK_RetCode rt, void* context) +{ + UHighlightsSetVideoAsync* Th = static_cast(context); + if (Th) + { + if (NVGSDK_SUCCEEDED(rt)) + { + Th->OnSuccess.Broadcast(ConvertRetCode(rt)); + } + else + { + Th->OnFailure.Broadcast(ConvertRetCode(rt)); + } + + } + +} +void UHighlightsSetVideoAsync::Activate() +{ + FGfeSDKHighlights* HiL = INVIDIAGfeSDK::Get().Highlights(); + if (HiL) + { + if (Params.EndDelta <= Params.StartDelta) + { + OnFailure.Broadcast(EGfeSDKReturnCode::ErrorWrongTimeRangeSet); + } + else + { + HiL->SetVideoHighlightAsync(Params, &OnSetVideoCallback, this); + } + } + else + { + OnFailure.Broadcast(EGfeSDKReturnCode::ErrorModuleNotLoaded); + } +} + +//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- + + +UHighlightsSummaryAsync* UHighlightsSummaryAsync::HighlightsOpenSummary(UObject* WorldContextObject, const FGfeSDKHighlightSummaryParams& Params) +{ + UHighlightsSummaryAsync* Proxy = NewObject(); + Proxy->WorldContextObject = WorldContextObject; + Proxy->Params = Params; + return Proxy; +} + +//--------------------------------------------------------------------------- + +void __stdcall UHighlightsSummaryAsync::OnOpenSummaryCallback(GfeSDK::NVGSDK_RetCode rt, void* context) +{ + UHighlightsSummaryAsync* Th = static_cast(context); + if (Th) + { + if (NVGSDK_SUCCEEDED(rt)) + { + Th->OnSuccess.Broadcast(ConvertRetCode(rt)); + } + else + { + Th->OnFailure.Broadcast(ConvertRetCode(rt)); + } + + } + +} +void UHighlightsSummaryAsync::Activate() +{ + FGfeSDKHighlights* HiL = INVIDIAGfeSDK::Get().Highlights(); + if (HiL) + { + HiL->OpenSummaryAsync(Params, &OnOpenSummaryCallback, this); + } + else + { + OnFailure.Broadcast(EGfeSDKReturnCode::ErrorModuleNotLoaded); + } +} + +//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- + + +UHighlightsGetNumberAsync* UHighlightsGetNumberAsync::HighlightsGetNumberOfHighlights(UObject* WorldContextObject, const FString& GroupID, const EGfeSDKHighlightType& TagFilter, const EGfeSDKHighlightSignificance& SignificanceFilter) +{ + UHighlightsGetNumberAsync* Proxy = NewObject(); + Proxy->WorldContextObject = WorldContextObject; + Proxy->Params.GroupId = GroupID; + Proxy->Params.TagsFilter = TagFilter; + Proxy->Params.SignificanceFilter = SignificanceFilter; + return Proxy; +} + +//--------------------------------------------------------------------------- + +void __stdcall UHighlightsGetNumberAsync::OnGetNumberCallback(GfeSDK::NVGSDK_RetCode rt, GfeSDK::NVGSDK_Highlights_NumberOfHighlights const* NumberOfHighlights, void* context) +{ + UHighlightsGetNumberAsync* Th = static_cast(context); + if (Th) + { + if (NVGSDK_SUCCEEDED(rt)) + { + Th->OnSuccess.Broadcast(ConvertRetCode(rt), NumberOfHighlights->numberOfHighlights); + } + else + { + Th->OnFailure.Broadcast(ConvertRetCode(rt)); + } + + } + +} +void UHighlightsGetNumberAsync::Activate() +{ + FGfeSDKHighlights* HiL = INVIDIAGfeSDK::Get().Highlights(); + if (HiL) + { + HiL->GetNumberOfHighlightsAsync(Params, &OnGetNumberCallback, this); + } + else + { + OnFailure.Broadcast(EGfeSDKReturnCode::ErrorModuleNotLoaded); + } +} + +//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- +//--------------------------------------------------------------------------- + + +URequestPermissionsAsync* URequestPermissionsAsync::GFERequestPermissions(UObject* WorldContextObject, const bool Video, const bool Screenshots) +{ + URequestPermissionsAsync* Proxy = NewObject(); + Proxy->WorldContextObject = WorldContextObject; + + Proxy->Params.Scopes.Empty(); + Proxy->Params.Scopes.Add(EGfeSDKScope::Highlights); + if (Video) + Proxy->Params.Scopes.Add(EGfeSDKScope::HighlightsRecordVideo); + if (Screenshots) + Proxy->Params.Scopes.Add(EGfeSDKScope::HighlightsRecordScreenshot); + return Proxy; +} + +//--------------------------------------------------------------------------- + +void __stdcall URequestPermissionsAsync::OnGetNumberCallback(GfeSDK::NVGSDK_RetCode rt, void* context) +{ + URequestPermissionsAsync* Th = static_cast(context); + if (Th) + { + if (NVGSDK_SUCCEEDED(rt)) + { + Th->OnSuccess.Broadcast(ConvertRetCode(rt)); + } + else + { + Th->OnFailure.Broadcast(ConvertRetCode(rt)); + } + + } + +} +void URequestPermissionsAsync::Activate() +{ + FGfeSDKCore* Core = INVIDIAGfeSDK::Get().Core(); + if (Core) + { + Core->RequestPermissionsAsync(Params, &OnGetNumberCallback, this); + } + else + { + OnFailure.Broadcast(EGfeSDKReturnCode::ErrorModuleNotLoaded); + } +} diff --git a/Source/NVIDIAGfeSDK/Private/NVIDIAGfeSDKPrivatePCH.h b/Source/NVIDIAGfeSDK/Private/NVIDIAGfeSDKPrivatePCH.h new file mode 100644 index 0000000..7c5bfa8 --- /dev/null +++ b/Source/NVIDIAGfeSDK/Private/NVIDIAGfeSDKPrivatePCH.h @@ -0,0 +1,15 @@ +/* Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved. + * + * NVIDIA CORPORATION and its licensors retain all intellectual property + * and proprietary rights in and to this software, related documentation + * and any modifications thereto. Any use, reproduction, disclosure or + * distribution of this software and related documentation without an express + * license agreement from NVIDIA CORPORATION is strictly prohibited. + */ + +#include "NVIDIAGfeSDKPublicPCH.h" +#include "ModuleManager.h" +#include "FNVIDIAGfeSDK.h" +#include "TypeTranslation.h" +#include +#include diff --git a/Source/NVIDIAGfeSDK/Private/TypeTranslation.cpp b/Source/NVIDIAGfeSDK/Private/TypeTranslation.cpp new file mode 100644 index 0000000..bbd53c4 --- /dev/null +++ b/Source/NVIDIAGfeSDK/Private/TypeTranslation.cpp @@ -0,0 +1,66 @@ +/* Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved. +* +* NVIDIA CORPORATION and its licensors retain all intellectual property +* and proprietary rights in and to this software, related documentation +* and any modifications thereto. Any use, reproduction, disclosure or +* distribution of this software and related documentation without an express +* license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ +#include "TypeTranslation.h" +#include "NVIDIAGfeSDKPrivatePCH.h" + + + +using namespace GfeSDK; + +std::map kScopeSdkToUnreal = { + { NVGSDK_SCOPE_HIGHLIGHTS, EGfeSDKScope::Highlights }, + { NVGSDK_SCOPE_HIGHLIGHTS_VIDEO, EGfeSDKScope::HighlightsRecordVideo }, + { NVGSDK_SCOPE_HIGHLIGHTS_SCREENSHOT, EGfeSDKScope::HighlightsRecordScreenshot }, + { NVGSDK_SCOPE_MAX, EGfeSDKScope::MAX }, +}; +std::map kScopeUnrealToSdk = InvertMap(kScopeSdkToUnreal); + +std::map kPermissionSdkToUnreal = { + { NVGSDK_PERMISSION_GRANTED, EGfeSDKPermission::Granted }, + { NVGSDK_PERMISSION_DENIED, EGfeSDKPermission::Denied }, + { NVGSDK_PERMISSION_MUST_ASK, EGfeSDKPermission::MustAsk }, + { NVGSDK_PERMISSION_UNKNOWN, EGfeSDKPermission::Unknown }, + { NVGSDK_PERMISSION_MAX, EGfeSDKPermission::MAX } +}; +std::map kPermissionUnrealToSdk = InvertMap(kPermissionSdkToUnreal); + +std::map kHighlightTypeSdkToUnreal = { + { NVGSDK_HIGHLIGHT_TYPE_MILESTONE, EGfeSDKHighlightType::Milestone }, + { NVGSDK_HIGHLIGHT_TYPE_ACHIEVEMENT, EGfeSDKHighlightType::Achievement }, + { NVGSDK_HIGHLIGHT_TYPE_INCIDENT, EGfeSDKHighlightType::Incident }, + { NVGSDK_HIGHLIGHT_TYPE_STATE_CHANGE, EGfeSDKHighlightType::StateChange }, + { NVGSDK_HIGHLIGHT_TYPE_MAX, EGfeSDKHighlightType::MAX } +}; +std::map kHighlightTypeUnrealToSdk = InvertMap(kHighlightTypeSdkToUnreal); + +std::map kHighlightSignificanceSdkToUnreal = { + { NVGSDK_HIGHLIGHT_SIGNIFICANCE_EXTREMELY_BAD, EGfeSDKHighlightSignificance::ExtremelyBad }, + { NVGSDK_HIGHLIGHT_SIGNIFICANCE_VERY_BAD, EGfeSDKHighlightSignificance::VeryBad }, + { NVGSDK_HIGHLIGHT_SIGNIFICANCE_BAD, EGfeSDKHighlightSignificance::Bad }, + { NVGSDK_HIGHLIGHT_SIGNIFICANCE_NEUTRAL, EGfeSDKHighlightSignificance::Neutral }, + { NVGSDK_HIGHLIGHT_SIGNIFICANCE_GOOD, EGfeSDKHighlightSignificance::Good }, + { NVGSDK_HIGHLIGHT_SIGNIFICANCE_VERY_GOOD, EGfeSDKHighlightSignificance::VeryGood }, + { NVGSDK_HIGHLIGHT_SIGNIFICANCE_EXTREMELY_GOOD, EGfeSDKHighlightSignificance::ExtremelyGood }, + { NVGSDK_HIGHLIGHT_SIGNIFICANCE_MAX, EGfeSDKHighlightSignificance::MAX } +}; +std::map kHighlightSignificanceUnrealToSdk = InvertMap(kHighlightSignificanceSdkToUnreal); + +EGfeSDKReturnCode TranslateReturnCodeToUnreal(NVGSDK_RetCode code) +{ + switch (code) + { + case NVGSDK_SUCCESS: return EGfeSDKReturnCode::Success; + case NVGSDK_SUCCESS_VERSION_OLD_SDK: return EGfeSDKReturnCode::SuccessIpcOldSdk; + case NVGSDK_SUCCESS_VERSION_OLD_GFE: return EGfeSDKReturnCode::SuccessIpcOldGfe; + case NVGSDK_ERR_GFE_VERSION: return EGfeSDKReturnCode::ErrorGfeVersion; + case NVGSDK_ERR_SDK_VERSION: return EGfeSDKReturnCode::ErrorSdkVersion; + } + + return (NVGSDK_SUCCEEDED(code) ? EGfeSDKReturnCode::Success : EGfeSDKReturnCode::Error); +} diff --git a/Source/NVIDIAGfeSDK/Private/TypeTranslation.h b/Source/NVIDIAGfeSDK/Private/TypeTranslation.h new file mode 100644 index 0000000..2097c44 --- /dev/null +++ b/Source/NVIDIAGfeSDK/Private/TypeTranslation.h @@ -0,0 +1,63 @@ +/* Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved. +* +* NVIDIA CORPORATION and its licensors retain all intellectual property +* and proprietary rights in and to this software, related documentation +* and any modifications thereto. Any use, reproduction, disclosure or +* distribution of this software and related documentation without an express +* license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +#pragma once + +#include "NVIDIAGfeSDKPrivatePCH.h" + +#include + +extern std::map kScopeSdkToUnreal; +extern std::map kScopeUnrealToSdk; +extern std::map kPermissionSdkToUnreal; +extern std::map kPermissionUnrealToSdk; +extern std::map kHighlightTypeSdkToUnreal; +extern std::map kHighlightTypeUnrealToSdk; +extern std::map kHighlightSignificanceSdkToUnreal; +extern std::map kHighlightSignificanceUnrealToSdk; + +extern EGfeSDKReturnCode TranslateReturnCodeToUnreal(GfeSDK::NVGSDK_RetCode code); + +template +std::map InvertMap(std::map const& map) +{ + std::map result; + for (auto it = map.begin(); it != map.end(); ++it) + { + result[it->second] = it->first; + } + return result; +} + +template +U TranslateEnum(std::map const& map, T const& value, U const& defaultValue) +{ + auto foundIt = map.find(value); + return (foundIt != map.end()) ? foundIt->second : defaultValue; +} + +template +U TranslateBitfieldEnum(std::map const& map, T const& value) +{ + uint32 result = 0x0; + for (size_t i = 0; i < sizeof(T)*8; ++i) + { + uint32 v = (1 << i); + if ((static_cast(value) & v) > 0) + { + auto foundIt = map.find(static_cast(v)); + if (foundIt != map.end()) + { + result |= static_cast(foundIt->second); + } + } + } + + return static_cast(result); +} diff --git a/Source/NVIDIAGfeSDK/Public/GfeSDKCore.h b/Source/NVIDIAGfeSDK/Public/GfeSDKCore.h new file mode 100644 index 0000000..c2100c1 --- /dev/null +++ b/Source/NVIDIAGfeSDK/Public/GfeSDKCore.h @@ -0,0 +1,27 @@ +/* Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved. +* +* NVIDIA CORPORATION and its licensors retain all intellectual property +* and proprietary rights in and to this software, related documentation +* and any modifications thereto. Any use, reproduction, disclosure or +* distribution of this software and related documentation without an express +* license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +#pragma once + +#include "NVIDIAGfeSDKPublicPCH.h" + +class NVIDIAGFESDK_API FGfeSDKCore +{ +public: + FGfeSDKCore(GfeSDK::NVGSDK_HANDLE* GFEHandle_); // Takes ownership + ~FGfeSDKCore(); + + void Poll(); + void RequestPermissionsAsync(FGfeSDKRequestPermissionsParams const& Params, GfeSDK::NVGSDK_EmptyCallback Callback, void* Context); + void GetUILanguageAsync(GfeSDK::NVGSDK_GetUILanguageCallback Callback, void* Context); + + friend class FNVIDIAGfeSDK; +private: + GfeSDK::NVGSDK_HANDLE* GFEHandle; +}; diff --git a/Source/NVIDIAGfeSDK/Public/GfeSDKHighlights.h b/Source/NVIDIAGfeSDK/Public/GfeSDKHighlights.h new file mode 100644 index 0000000..e1e3842 --- /dev/null +++ b/Source/NVIDIAGfeSDK/Public/GfeSDKHighlights.h @@ -0,0 +1,33 @@ +/* Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved. +* +* NVIDIA CORPORATION and its licensors retain all intellectual property +* and proprietary rights in and to this software, related documentation +* and any modifications thereto. Any use, reproduction, disclosure or +* distribution of this software and related documentation without an express +* license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +#pragma once + +#include "NVIDIAGfeSDKPublicPCH.h" +#include "gfesdk/sdk_types.h" + +class NVIDIAGFESDK_API FGfeSDKHighlights +{ +public: + FGfeSDKHighlights(GfeSDK::NVGSDK_HANDLE* Handle); + virtual ~FGfeSDKHighlights(); + + virtual void ConfigureAsync(FGfeSDKHighlightConfigParams const& Params, GfeSDK::NVGSDK_EmptyCallback callback, void* Context); + virtual void GetUserSettingsAsync(GfeSDK::NVGSDK_Highlights_GetUserSettingsCallback Callback, void* Context) const; + virtual void OpenGroupAsync(FGfeSDKHighlightOpenGroupParams const& Params, GfeSDK::NVGSDK_EmptyCallback Callback, void* Context); + virtual void CloseGroupAsync(FGfeSDKHighlightCloseGroupParams const& Params, GfeSDK::NVGSDK_EmptyCallback Callback, void* Context); + virtual void SetScreenshotHighlightAsync(FGfeSDKHighlightScreenshotParams const& Params, GfeSDK::NVGSDK_EmptyCallback Callback, void* Context); + virtual void SetVideoHighlightAsync(FGfeSDKHighlightVideoParams const& Params, GfeSDK::NVGSDK_EmptyCallback Callback, void* Context); + virtual void OpenSummaryAsync(FGfeSDKHighlightSummaryParams const& Params, GfeSDK::NVGSDK_EmptyCallback Callback, void* Context); + virtual void GetNumberOfHighlightsAsync(FGfeSDKHighlightGroupView const& GroupView, GfeSDK::NVGSDK_Highlights_GetNumberOfHighlightsCallback Callback, void* Context); + virtual int32 GetNumberOfHighlights(FGfeSDKHighlightGroupView const& GroupView); + virtual void Poll(); +private: + GfeSDK::NVGSDK_HANDLE* GFEHandle; +}; diff --git a/Source/NVIDIAGfeSDK/Public/HighLightBlueprint.h b/Source/NVIDIAGfeSDK/Public/HighLightBlueprint.h new file mode 100644 index 0000000..46cd053 --- /dev/null +++ b/Source/NVIDIAGfeSDK/Public/HighLightBlueprint.h @@ -0,0 +1,321 @@ +// Fill out your copyright notice in the Description page of Project Settings. + +#pragma once +#include "NVIDIAGfeSDKPrivatePCH.h" +#include "CoreMinimal.h" +#include "Kismet/BlueprintFunctionLibrary.h" +#include "Kismet/BlueprintAsyncActionBase.h" +#include +#include "NVIDIAGfeSDKTypes.h" +#include "HighLightBlueprint.generated.h" + +//--------------------------------------------------------------------------- + +UCLASS() +class UHighlightsFunctionLibrary : public UBlueprintFunctionLibrary +{ + GENERATED_UCLASS_BODY() +public: + // This function should be called periodically. + // It is used to receive callbacks. + // Can be called in Tick event + UFUNCTION(BlueprintCallable, Category = "Shadowplay Highlights") + static void Poll(); + // This function is for convenience + // It chesks if the permissions to use Video or Screenshots functions are granted + // It returns the actual enumeration values for each function + UFUNCTION(BlueprintCallable, Category = "Shadowplay Highlights") + static void ChekIfHighlightsAvailable(const FGfeSDKCreateResponse& InitProperties, bool &VideoGranted, bool &ScreenshotsGranted, EGfeSDKPermission &Video, EGfeSDKPermission &Screenshots); +}; + + +//--------------------------------------------------------------------------- + +DECLARE_DYNAMIC_MULTICAST_DELEGATE(FOnHighlightsCallback); +DECLARE_DYNAMIC_MULTICAST_DELEGATE_OneParam(FOnHighlightsOperationResultCallback, EGfeSDKReturnCode, GfeSdkReturnCode); +DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FOnHighlightsInitCallback, EGfeSDKReturnCode, GfeSdkReturnCode, FGfeSDKCreateResponse, GfeSdkProperties); +DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FOnGetNumberOfHighlightsCallback, EGfeSDKReturnCode, GfeSdkReturnCode, int32, NumberOfHighlights); + +UCLASS() +class UInitHighlights : public UBlueprintAsyncActionBase +{ + GENERATED_BODY() +public: + // Called when there is a successful init + UPROPERTY(BlueprintAssignable) + FOnHighlightsInitCallback OnSuccess; + + // Called when there is an unsuccessful init + UPROPERTY(BlueprintAssignable) + FOnHighlightsOperationResultCallback OnFailure; + + // Initializes the Highlights client. Should be called first, all other functions will fail otherwise. Takes the game name and desired Highlights options as an input. + // Requests Highlights permissions to recorde Video or Screenshots according to the input checkboxes + // Use the GFE Request Permissions function if desired permissions are not granted to you. + UFUNCTION(BlueprintCallable, meta = (BlueprintInternalUseOnly = "true", WorldContext = "WorldContextObject"), Category = "Shadowplay Highlights") + static UInitHighlights* InitHighlights(UObject* WorldContextObject, const FString InGameName, const bool Video, const bool Screenshots); + + // UBlueprintAsyncActionBase interface + virtual void Activate() override; + // End of UBlueprintAsyncActionBase interface + +private: + FCriticalSection CS; + UObject* WorldContextObject; + FString GameName; + TArray RequestedPermissions; + + // Permissions for Highlights + TMap mLastScopePermissions; + TArray mPermissionsNeeded; + + void Callback(); + void OnPermissionsChanged(FGfeSDKPermissionsChangedData const& PermissionsChangedData); +}; + +//--------------------------------------------------------------------------- + +UCLASS() +class UHighlightsConfigureAsync : public UBlueprintAsyncActionBase +{ + GENERATED_BODY() +public: + // Called when there is a successful query + UPROPERTY(BlueprintAssignable) + FOnHighlightsOperationResultCallback OnSuccess; + + // Called when there is an unsuccessful query + UPROPERTY(BlueprintAssignable) + FOnHighlightsOperationResultCallback OnFailure; + + // Configures the highlights system and defines the highlight types. + // Should be called once in game (or can be called if the highlight type list changed, for example for another game type). + // Should be called after init and before the OpenGroup functions + // Uses Poll function to receive callbacks + UFUNCTION(BlueprintCallable, meta = (BlueprintInternalUseOnly = "true", WorldContext = "WorldContextObject"), Category = "Shadowplay Highlights") + static UHighlightsConfigureAsync* HighlightsConfigure(UObject* WorldContextObject, const FGfeSDKHighlightConfigParams& ConfigParams); + + // UBlueprintAsyncActionBase interface + virtual void Activate() override; + // End of UBlueprintAsyncActionBase interface + +private: + UObject* WorldContextObject; + FGfeSDKHighlightConfigParams ConfigParams; + static void __stdcall OnConfigureCallback(GfeSDK::NVGSDK_RetCode rt, void* context); +}; + +//--------------------------------------------------------------------------- + +UCLASS() +class UHighlightsOpenGroupAsync : public UBlueprintAsyncActionBase +{ + GENERATED_BODY() +public: + // Called when there is a successful query + UPROPERTY(BlueprintAssignable) + FOnHighlightsOperationResultCallback OnSuccess; + + // Called when there is an unsuccessful query + UPROPERTY(BlueprintAssignable) + FOnHighlightsOperationResultCallback OnFailure; + + // Opens the group of highlights + // Uses Poll function to receive callbacks + UFUNCTION(BlueprintCallable, meta = (BlueprintInternalUseOnly = "true", WorldContext = "WorldContextObject"), Category = "Shadowplay Highlights") + static UHighlightsOpenGroupAsync* HighlightsOpenGroup(UObject* WorldContextObject, const FGfeSDKHighlightOpenGroupParams& Params); + + // UBlueprintAsyncActionBase interface + virtual void Activate() override; + // End of UBlueprintAsyncActionBase interface + +private: + UObject* WorldContextObject; + FGfeSDKHighlightOpenGroupParams Params; + static void __stdcall OnOpenGroupCallback(GfeSDK::NVGSDK_RetCode rt, void* context); +}; + +//--------------------------------------------------------------------------- + +UCLASS() +class UHighlightsCloseGroupAsync : public UBlueprintAsyncActionBase +{ + GENERATED_BODY() +public: + // Called when there is a successful query + UPROPERTY(BlueprintAssignable) + FOnHighlightsOperationResultCallback OnSuccess; + + // Called when there is an unsuccessful query + UPROPERTY(BlueprintAssignable) + FOnHighlightsOperationResultCallback OnFailure; + + // Closes the group of highlights + // Uses Poll function to receive callbacks + UFUNCTION(BlueprintCallable, meta = (BlueprintInternalUseOnly = "true", WorldContext = "WorldContextObject"), Category = "Shadowplay Highlights") + static UHighlightsCloseGroupAsync* HighlightsCloseGroup(UObject* WorldContextObject, const FString& GroupId, const bool& DestroyHighlights); + + // UBlueprintAsyncActionBase interface + virtual void Activate() override; + // End of UBlueprintAsyncActionBase interface + +private: + UObject* WorldContextObject; + FGfeSDKHighlightCloseGroupParams Params; + static void __stdcall OnCloseGroupCallback(GfeSDK::NVGSDK_RetCode rt, void* context); +}; + +//--------------------------------------------------------------------------- + +UCLASS() +class UHighlightsSetScreenshotAsync : public UBlueprintAsyncActionBase +{ + GENERATED_BODY() +public: + // Called when there is a successful query + UPROPERTY(BlueprintAssignable) + FOnHighlightsOperationResultCallback OnSuccess; + + // Called when there is an unsuccessful query + UPROPERTY(BlueprintAssignable) + FOnHighlightsOperationResultCallback OnFailure; + + // Takes screenshot of the game + // Uses Poll function to receive callbacks + UFUNCTION(BlueprintCallable, meta = (BlueprintInternalUseOnly = "true", WorldContext = "WorldContextObject"), Category = "Shadowplay Highlights") + static UHighlightsSetScreenshotAsync* HighlightsSetScreenshot(UObject* WorldContextObject, const FString& GroupId, const FString& HighlightId); + + // UBlueprintAsyncActionBase interface + virtual void Activate() override; + // End of UBlueprintAsyncActionBase interface + +private: + UObject* WorldContextObject; + FGfeSDKHighlightScreenshotParams Params; + static void __stdcall OnSetScreenshotCallback(GfeSDK::NVGSDK_RetCode rt, void* context); +}; + +//--------------------------------------------------------------------------- + +UCLASS() +class UHighlightsSetVideoAsync : public UBlueprintAsyncActionBase +{ + GENERATED_BODY() +public: + // Called when there is a successful query + UPROPERTY(BlueprintAssignable) + FOnHighlightsOperationResultCallback OnSuccess; + + // Called when there is an unsuccessful query + UPROPERTY(BlueprintAssignable) + FOnHighlightsOperationResultCallback OnFailure; + + // Records the video of the gameplay + // GroupID is the name of the group this highlight is related to + // HighlightID is the name of the Highlight + // StartDelta and EndDelta are the time range in miliseconds from the current moment. + // For example StartDelta can be set to -2000 and EndDelta to 3000 - that corresponds to {get the video of two seconds before this moment and record 3 seconds more from this moment} + // Uses Poll function to receive callbacks + UFUNCTION(BlueprintCallable, meta = (BlueprintInternalUseOnly = "true", WorldContext = "WorldContextObject"), Category = "Shadowplay Highlights") + static UHighlightsSetVideoAsync* HighlightsSetVideo(UObject* WorldContextObject, const FString& GroupId, const FString& HighlightId, const int32& StartDelta, const int32& EndDelta); + + // UBlueprintAsyncActionBase interface + virtual void Activate() override; + // End of UBlueprintAsyncActionBase interface + +private: + UObject* WorldContextObject; + FGfeSDKHighlightVideoParams Params; + static void __stdcall OnSetVideoCallback(GfeSDK::NVGSDK_RetCode rt, void* context); +}; + +//--------------------------------------------------------------------------- + +UCLASS() +class UHighlightsSummaryAsync : public UBlueprintAsyncActionBase +{ + GENERATED_BODY() +public: + // Called when there is a successful query + UPROPERTY(BlueprintAssignable) + FOnHighlightsOperationResultCallback OnSuccess; + + // Called when there is an unsuccessful query + UPROPERTY(BlueprintAssignable) + FOnHighlightsOperationResultCallback OnFailure; + + // Shows the Shadowplay Highlights Summary interface + // Uses Poll function to receive callbacks + UFUNCTION(BlueprintCallable, meta = (BlueprintInternalUseOnly = "true", WorldContext = "WorldContextObject"), Category = "Shadowplay Highlights") + static UHighlightsSummaryAsync* HighlightsOpenSummary(UObject* WorldContextObject, const FGfeSDKHighlightSummaryParams& Params); + + // UBlueprintAsyncActionBase interface + virtual void Activate() override; + // End of UBlueprintAsyncActionBase interface + +private: + UObject* WorldContextObject; + FGfeSDKHighlightSummaryParams Params; + static void __stdcall OnOpenSummaryCallback(GfeSDK::NVGSDK_RetCode rt, void* context); +}; + +//--------------------------------------------------------------------------- + +UCLASS() +class UHighlightsGetNumberAsync : public UBlueprintAsyncActionBase +{ + GENERATED_BODY() +public: + // Called when there is a successful query + UPROPERTY(BlueprintAssignable) + FOnGetNumberOfHighlightsCallback OnSuccess; + + // Called when there is an unsuccessful query + UPROPERTY(BlueprintAssignable) + FOnHighlightsOperationResultCallback OnFailure; + + // Gets number of highlights recorded according to the specified input filtering values + // Uses Poll function to receive callbacks + UFUNCTION(BlueprintCallable, meta = (BlueprintInternalUseOnly = "true", WorldContext = "WorldContextObject"), Category = "Shadowplay Highlights") + static UHighlightsGetNumberAsync* HighlightsGetNumberOfHighlights(UObject* WorldContextObject, const FString& GroupID, const EGfeSDKHighlightType& TagFilter, const EGfeSDKHighlightSignificance& SignificanceFilter); + + // UBlueprintAsyncActionBase interface + virtual void Activate() override; + // End of UBlueprintAsyncActionBase interface + +private: + UObject* WorldContextObject; + FGfeSDKHighlightGroupView Params; + static void __stdcall OnGetNumberCallback(GfeSDK::NVGSDK_RetCode rt, GfeSDK::NVGSDK_Highlights_NumberOfHighlights const* NumberOfHighlights, void* context); +}; + +//--------------------------------------------------------------------------- + +UCLASS() +class URequestPermissionsAsync : public UBlueprintAsyncActionBase +{ + GENERATED_BODY() +public: + // Called when there is a successful query + UPROPERTY(BlueprintAssignable) + FOnHighlightsOperationResultCallback OnSuccess; + + // Called when there is an unsuccessful query + UPROPERTY(BlueprintAssignable) + FOnHighlightsOperationResultCallback OnFailure; + + // Requests permissions to use the specified Shadowplay Highlights features + // Use this function to request the permission if the InitHighlights function failed to grant the desired permissions + // Uses Poll function to receive callbacks + UFUNCTION(BlueprintCallable, meta = (BlueprintInternalUseOnly = "true", WorldContext = "WorldContextObject"), Category = "Shadowplay Highlights") + static URequestPermissionsAsync* GFERequestPermissions(UObject* WorldContextObject, const bool Video, const bool Screenshots); + + // UBlueprintAsyncActionBase interface + virtual void Activate() override; + // End of UBlueprintAsyncActionBase interface + +private: + UObject* WorldContextObject; + FGfeSDKRequestPermissionsParams Params; + static void __stdcall OnGetNumberCallback(GfeSDK::NVGSDK_RetCode rt, void* context); +}; \ No newline at end of file diff --git a/Source/NVIDIAGfeSDK/Public/INVIDIAGfeSDK.h b/Source/NVIDIAGfeSDK/Public/INVIDIAGfeSDK.h new file mode 100644 index 0000000..73378ea --- /dev/null +++ b/Source/NVIDIAGfeSDK/Public/INVIDIAGfeSDK.h @@ -0,0 +1,49 @@ +/* Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved. +* +* NVIDIA CORPORATION and its licensors retain all intellectual property +* and proprietary rights in and to this software, related documentation +* and any modifications thereto. Any use, reproduction, disclosure or +* distribution of this software and related documentation without an express +* license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +#pragma once + +#include "NVIDIAGfeSDKPublicPCH.h" + +class INVIDIAGfeSDK : public IModuleInterface +{ +public: + /** + * Singleton-like access to this module's interface. This is just for convenience! + * Beware of calling this during the shutdown phase, though. Your module might have been unloaded already. + * + * @return Returns singleton instance, loading the module on demand if needed + */ + static inline INVIDIAGfeSDK& Get() + { + return FModuleManager::LoadModuleChecked("NVIDIAGfeSDK"); + } + + /** + * Checks to see if this module is loaded and ready. It is only valid to call Get() if IsAvailable() returns true. + * + * @return True if the module is loaded and ready to use + */ + static inline bool IsAvailable() + { + return FModuleManager::Get().IsModuleLoaded("NVIDIAGfeSDK"); + } + + // Controls the log level of GfeSDK's internal logfile + virtual GfeSDK::NVGSDK_RetCode SetFileLogLevel(ELogVerbosity::Type Level) = 0; + // Controls the log level of logs that GfeSDK sends to the unreal logfile + virtual GfeSDK::NVGSDK_RetCode SetUnrealLogLevel(ELogVerbosity::Type Level) = 0; + + virtual EGfeSDKReturnCode Create(FGfeSDKCreateInputParams const& InputParams, FGfeSDKCreateResponse& Response) = 0; + virtual void Release() = 0; + virtual FGfeSDKCore* Core() = 0; + virtual FGfeSDKHighlights* Highlights() = 0; + + FGfeSDKOnPermissionsChanged PermissionsChangedDelegate; +}; diff --git a/Source/NVIDIAGfeSDK/Public/NVIDIAGfeSDKPublicPCH.h b/Source/NVIDIAGfeSDK/Public/NVIDIAGfeSDKPublicPCH.h new file mode 100644 index 0000000..8b446f7 --- /dev/null +++ b/Source/NVIDIAGfeSDK/Public/NVIDIAGfeSDKPublicPCH.h @@ -0,0 +1,11 @@ +#include "ModuleManager.h" +#include "CoreMinimal.h" +//#include "Engine.h" +#include "UniquePtr.h" + +#include "NVIDIAGfeSDKTypes.h" +#include "GfeSDKCore.h" +#include "GfeSDKHighlights.h" +#include "gfesdk/bindings/cpp/sdk_types_cpp.h" +#include "gfesdk/bindings/cpp/isdk_cpp.h" +#include "gfesdk/bindings/cpp/highlights/ihighlights_cpp.h" diff --git a/Source/NVIDIAGfeSDK/Public/NVIDIAGfeSDKTypes.h b/Source/NVIDIAGfeSDK/Public/NVIDIAGfeSDKTypes.h new file mode 100644 index 0000000..02e3b79 --- /dev/null +++ b/Source/NVIDIAGfeSDK/Public/NVIDIAGfeSDKTypes.h @@ -0,0 +1,279 @@ +#pragma once + +#include "NVIDIAGfeSDKTypes.generated.h" + +UENUM(BlueprintType) +enum class EGfeSDKReturnCode : uint8 +{ + Success = 0, + SuccessIpcOldSdk = 1, + SuccessIpcOldGfe = 2, + Error = 3, + ErrorGfeVersion = 4, + ErrorSdkVersion = 5, + ErrorModuleNotLoaded = 6, + ErrorWrongTimeRangeSet = 7 +}; + +UENUM(BlueprintType) +enum class EGfeSDKScope : uint8 +{ + Highlights = 0, + HighlightsRecordVideo = 1, + HighlightsRecordScreenshot = 2, + MAX = 3 +}; + +UENUM(BlueprintType) +enum class EGfeSDKPermission : uint8 +{ + Granted = 0, + Denied = 1, + MustAsk = 2, + Unknown = 3, + MAX= 4 +}; + +UENUM(BlueprintType) +enum class EGfeSDKHighlightType : uint8 +{ + NONE = 0x00, + Milestone = 0x01, + Achievement = 0x02, + Incident = 0x04, + StateChange = 0x08, + MAX = 0x10 +}; + +// This different from the version in sdk_types.h because +// UE4 only supports 8 bit enums. It must be translated +UENUM(BlueprintType) +enum class EGfeSDKHighlightSignificance : uint8 +{ + NONE = 0x00, + ExtremelyBad = 0x01, + VeryBad = 0x02, + Bad = 0x04, + Neutral = 0x08, + Good = 0x10, + VeryGood = 0x20, + ExtremelyGood = 0x40, + MAX = 0x80 +}; + +USTRUCT(BlueprintType) +struct FGfeSDKCreateInputParams +{ + GENERATED_BODY() + + FGfeSDKCreateInputParams() + { + AppName = TEXT("Undefined"); + PollForCallbacks = false; + } + + UPROPERTY() + FString AppName; + + UPROPERTY() + TArray RequiredScopes; + + UPROPERTY() + bool PollForCallbacks; +}; + +USTRUCT(BlueprintType) +struct FGfeSDKCreateResponse +{ + GENERATED_USTRUCT_BODY() + + FGfeSDKCreateResponse() + { + VersionMajor = -1; + VersionMinor = -1; + NVIDIAGfeVersion = TEXT("Undefined"); + } + + UPROPERTY() + uint16 VersionMajor; + + UPROPERTY() + uint16 VersionMinor; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Shadowplay Highlights") + FString NVIDIAGfeVersion; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Shadowplay Highlights") + TMap ScopePermissions; +}; + +USTRUCT(BlueprintType) +struct FGfeSDKHighlightDefinition +{ + GENERATED_USTRUCT_BODY() + + FGfeSDKHighlightDefinition() + { + UserDefaultInterest = true; + HighlightTags = static_cast(0x0); + Significance = static_cast(0x0); + } + + FGfeSDKHighlightDefinition(FString const& Id_, bool UserDefaultInterest_, EGfeSDKHighlightType Tags_, EGfeSDKHighlightSignificance Sig_, TMap Table_) : + Id(Id_), UserDefaultInterest(UserDefaultInterest_), HighlightTags(Tags_), Significance(Sig_), NameTranslationTable(Table_) {} + // Defines the highlight type name + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Shadowplay Highlights") + FString Id; + // If set to true, the highlight will be recorded, otherwise the Shadowplay will lookup the GFE database and user's options. + // If it's not found there or user switched of the highlihts for this game, it will be treated as irrelevant. + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Shadowplay Highlights") + bool UserDefaultInterest; + // Tag that defines the type of the highlight + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Shadowplay Highlights") + EGfeSDKHighlightType HighlightTags; + // This property defines how good or bad the recorded event is in terms of the gameplay + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Shadowplay Highlights") + EGfeSDKHighlightSignificance Significance; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Shadowplay Highlights") + TMap NameTranslationTable; +}; + +USTRUCT(BlueprintType) +struct FGfeSDKHighlightConfigParams +{ + GENERATED_USTRUCT_BODY() + + FGfeSDKHighlightConfigParams() {} + + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Shadowplay Highlights") + TArray HighlightDefinitions; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Shadowplay Highlights") + FString DefaultLocale; +}; + +USTRUCT(BlueprintType) +struct FGfeSDKRequestPermissionsParams +{ + GENERATED_USTRUCT_BODY() + + FGfeSDKRequestPermissionsParams() {} + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Shadowplay Highlights") + TArray Scopes; +}; + +USTRUCT(BlueprintType) +struct FGfeSDKPermissionsChangedData +{ + GENERATED_USTRUCT_BODY() + + FGfeSDKPermissionsChangedData() {} + + UPROPERTY() + TMap ScopePermissions; +}; + +USTRUCT(BlueprintType) +struct FGfeSDKHighlightOpenGroupParams +{ + GENERATED_USTRUCT_BODY() + + FGfeSDKHighlightOpenGroupParams() {} + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Shadowplay Highlights") + FString GroupId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Shadowplay Highlights") + TMap GroupDescriptionTranslationTable; +}; + +USTRUCT(BlueprintType) +struct FGfeSDKHighlightCloseGroupParams +{ + GENERATED_USTRUCT_BODY() + + FGfeSDKHighlightCloseGroupParams(): + DestroyHighlights(false) + {} + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Shadowplay Highlights") + FString GroupId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Shadowplay Highlights") + bool DestroyHighlights; +}; + +USTRUCT(BlueprintType) +struct FGfeSDKHighlightScreenshotParams +{ + GENERATED_USTRUCT_BODY() + + FGfeSDKHighlightScreenshotParams() {} + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Shadowplay Highlights") + FString GroupId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Shadowplay Highlights") + FString HighlightId; +}; + +USTRUCT(BlueprintType) +struct FGfeSDKHighlightVideoParams +{ + GENERATED_USTRUCT_BODY() + + FGfeSDKHighlightVideoParams() + { + StartDelta = 0; + EndDelta = 0; + } + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Shadowplay Highlights") + FString GroupId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Shadowplay Highlights") + FString HighlightId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Shadowplay Highlights") + int32 StartDelta; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Shadowplay Highlights") + int32 EndDelta; +}; + +USTRUCT(BlueprintType) +struct FGfeSDKHighlightGroupView +{ + GENERATED_USTRUCT_BODY() + + FGfeSDKHighlightGroupView() : + TagsFilter(EGfeSDKHighlightType::NONE), + SignificanceFilter(EGfeSDKHighlightSignificance::NONE) + {} + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Shadowplay Highlights") + FString GroupId; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Shadowplay Highlights") + EGfeSDKHighlightType TagsFilter; + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Shadowplay Highlights") + EGfeSDKHighlightSignificance SignificanceFilter; +}; + +USTRUCT(BlueprintType) +struct FGfeSDKHighlightSummaryParams +{ + GENERATED_USTRUCT_BODY() + + FGfeSDKHighlightSummaryParams() {} + + UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Shadowplay Highlights") + TArray GroupViews; +}; + + +DECLARE_DELEGATE_OneParam(FGfeSDKOnPermissionsChanged, FGfeSDKPermissionsChangedData const&); diff --git a/ThirdParty/NVIDIAGfeSDK/Include/gfesdk/bindings/cpp/highlights/highlights_types_cpp.h b/ThirdParty/NVIDIAGfeSDK/Include/gfesdk/bindings/cpp/highlights/highlights_types_cpp.h new file mode 100644 index 0000000..69dbb88 --- /dev/null +++ b/ThirdParty/NVIDIAGfeSDK/Include/gfesdk/bindings/cpp/highlights/highlights_types_cpp.h @@ -0,0 +1,112 @@ +/* Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved. +* +* NVIDIA CORPORATION and its licensors retain all intellectual property +* and proprietary rights in and to this software, related documentation +* and any modifications thereto. Any use, reproduction, disclosure or +* distribution of this software and related documentation without an express +* license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +#ifndef HIGHLIGHTS_TYPES_CPP_H +#define HIGHLIGHTS_TYPES_CPP_H + +#include + +// Avoid polluting global namespace with C api +namespace GfeSDK +{ +#include +} + +namespace GfeSDK +{ + +//! C++ binding for @ref NVGSDK_Highlight +struct HighlightDefinition +{ + std::string id; + bool userDefaultInterest; + NVGSDK_HighlightType highlightTags; + NVGSDK_HighlightSignificance significance; + TTranslationTable nameLocaleTable; //!< Locale/translation pairs + HighlightDefinition() : highlightTags(static_cast(0)), significance(static_cast(0)), userDefaultInterest(true) {} +}; + +//! C++ binding for @ref NVGSDK_HighlightConfigParams +struct HighlightConfigParams +{ + std::vector highlightDefinitions; + std::string defaultLocale; +}; + +//! C++ binding for @ref NVGSDK_HighlightOpenGroupParams +struct HighlightOpenGroupParams +{ + std::string groupId; + TTranslationTable groupDescriptionLocaleTable; +}; + +//! C++ binding for @ref NVGSDK_HighlightCloseGroupParams +struct HighlightCloseGroupParams +{ + std::string groupId; + bool destroyHighlights; +}; + +//! C++ binding for @ref NVGSDK_ScreenshotHighlightParams +struct ScreenshotHighlightParams +{ + std::string groupId; + std::string highlightId; +}; + +//! C++ binding for @ref NVGSDK_VideoHighlightParams +struct VideoHighlightParams +{ + std::string groupId; + std::string highlightId; + int32_t startDelta; + int32_t endDelta; +}; + +//! C++ binding for @ref NVGSDK_GroupView +struct GroupView +{ + std::string groupId; + NVGSDK_HighlightType tagsFilter; + NVGSDK_HighlightSignificance significanceFilter; + GroupView() : tagsFilter(NVGSDK_HighlightType(0)), significanceFilter(NVGSDK_HighlightSignificance(0)) {} +}; + +//! C++ binding for @ref NVGSDK_SummaryParams +struct SummaryParams +{ + std::vector groupViews; +}; + +//! C++ binding for @ref NVGSDK_HighlightUserSetting +struct HighlightUserSetting +{ + std::string highlightId; //!< Unique id for game event. + bool enabled; //!< Boolean for whether the user wants to record this type of highlight +}; + +/////////////// Responses from API calls + +//! C++ binding for @ref NVGSDK_GetNumberOfHighlightsResponse +struct GetNumberOfHighlightsResponse +{ + uint16_t numHighlights; +}; +typedef std::function TGetNumberOfHighlightsCallback; + +//! C++ binding for @ref NVGSDK_Highlights_GetUserSettingsResponse +struct GetUserSettingsResponse +{ + std::vector highlightSettings; +}; +typedef std::function TGetUserSettingsCallback; + +} + +#endif //HIGHLIGHTS_TYPES_CPP_H diff --git a/ThirdParty/NVIDIAGfeSDK/Include/gfesdk/bindings/cpp/highlights/ihighlights_cpp.h b/ThirdParty/NVIDIAGfeSDK/Include/gfesdk/bindings/cpp/highlights/ihighlights_cpp.h new file mode 100644 index 0000000..f15d12a --- /dev/null +++ b/ThirdParty/NVIDIAGfeSDK/Include/gfesdk/bindings/cpp/highlights/ihighlights_cpp.h @@ -0,0 +1,53 @@ +/* Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved. +* +* NVIDIA CORPORATION and its licensors retain all intellectual property +* and proprietary rights in and to this software, related documentation +* and any modifications thereto. Any use, reproduction, disclosure or +* distribution of this software and related documentation without an express +* license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +/*! +* \file +* C++ bindings for GfeSDK. +* Implemented in the header to avoid ABI incompatibilities +*/ + +#ifndef GFESDK_IHIGHLIGHTS_CPP_H +#define GFESDK_IHIGHLIGHTS_CPP_H + +#include +#include + +namespace GfeSDK +{ +// Avoid polluting global namespace with C api, so put it inside namespace +#include + +/*! C++ Highlights interface */ +class Highlights +{ +public: + static Highlights* Create(Core* core); + virtual ~Highlights() {} + + /*! C++ binding for \ref NVGSDK_Highlights_ConfigureAsync */ + virtual void ConfigureAsync(HighlightConfigParams const& params, TCallback cb = nullptr, void* cbContext = nullptr) = 0; + /*! C++ binding for \ref NVGSDK_Highlights_GetUserSettingsAsync */ + virtual void GetUserSettingsAsync(TGetUserSettingsCallback cb = nullptr, void* cbContext = nullptr) const = 0; + /*! C++ binding for \ref NVGSDK_Highlights_OpenGroupAsync */ + virtual void OpenGroupAsync(HighlightOpenGroupParams const& params, TCallback cb = nullptr, void* cbContext = nullptr) = 0; + /*! C++ binding for \ref NVGSDK_Highlights_CloseGroupAsync */ + virtual void CloseGroupAsync(HighlightCloseGroupParams const& params, TCallback cb = nullptr, void* cbContext = nullptr) = 0; + /*! C++ binding for \ref NVGSDK_Highlights_SetScreenshotHighlightAsync */ + virtual void SetScreenshotHighlightAsync(ScreenshotHighlightParams const& params, TCallback cb = nullptr, void* cbContext = nullptr) = 0; + /*! C++ binding for \ref NVGSDK_Highlights_SetVideoHighlightAsync */ + virtual void SetVideoHighlightAsync(VideoHighlightParams const& params, TCallback cb = nullptr, void* cbContext = nullptr) = 0; + /*! C++ binding for \ref NVGSDK_Highlights_OpenSummaryAsync */ + virtual void OpenSummaryAsync(SummaryParams const& params, TCallback cb = nullptr, void* cbContext = nullptr) = 0; + /*! C++ binding for \ref NVGSDK_Highlights_GetNumberOfHighlightsAsync */ + virtual void GetNumberOfHighlightsAsync(GroupView const& params, TGetNumberOfHighlightsCallback cb = nullptr, void* cbContext = nullptr) = 0; +}; +} + +#endif //GFESDK_IHIGHLIGHTS_CPP_H diff --git a/ThirdParty/NVIDIAGfeSDK/Include/gfesdk/bindings/cpp/highlights/ihighlights_cpp_impl.h b/ThirdParty/NVIDIAGfeSDK/Include/gfesdk/bindings/cpp/highlights/ihighlights_cpp_impl.h new file mode 100644 index 0000000..6af42c1 --- /dev/null +++ b/ThirdParty/NVIDIAGfeSDK/Include/gfesdk/bindings/cpp/highlights/ihighlights_cpp_impl.h @@ -0,0 +1,196 @@ +/* Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved. +* +* NVIDIA CORPORATION and its licensors retain all intellectual property +* and proprietary rights in and to this software, related documentation +* and any modifications thereto. Any use, reproduction, disclosure or +* distribution of this software and related documentation without an express +* license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +/*! +* \file +* C++ bindings for GfeSDK Highlights. +* Implemented in the header to avoid ABI incompatibilities +*/ + +#ifndef GFESDK_IHIGHLIGHTS_CPP_IMPL_H +#define GFESDK_IHIGHLIGHTS_CPP_IMPL_H + +#include "ihighlights_cpp.h" +#include + +#include + +namespace GfeSDK +{ +class HighlightsImpl : public Highlights +{ +public: + /*! C++ binding for \ref NVGSDK_Highlights_ConfigureAsync */ + virtual void ConfigureAsync(HighlightConfigParams const& params, TCallback cb = nullptr, void* cbContext = nullptr); + /*! C++ binding for \ref NVGSDK_Highlights_GetUserSettingsAsync */ + virtual void GetUserSettingsAsync(TGetUserSettingsCallback cb = nullptr, void* cbContext = nullptr) const; + /*! C++ binding for \ref NVGSDK_Highlights_OpenGroupAsync */ + virtual void OpenGroupAsync(HighlightOpenGroupParams const& params, TCallback cb = nullptr, void* cbContext = nullptr); + /*! C++ binding for \ref NVGSDK_Highlights_CloseGroupAsync */ + virtual void CloseGroupAsync(HighlightCloseGroupParams const& params, TCallback cb = nullptr, void* cbContext = nullptr); + /*! C++ binding for \ref NVGSDK_Highlights_SetScreenshotHighlightAsync */ + virtual void SetScreenshotHighlightAsync(ScreenshotHighlightParams const& params, TCallback cb = nullptr, void* cbContext = nullptr); + /*! C++ binding for \ref NVGSDK_Highlights_SetVideoHighlightAsync */ + virtual void SetVideoHighlightAsync(VideoHighlightParams const& params, TCallback cb = nullptr, void* cbContext = nullptr); + /*! C++ binding for \ref NVGSDK_Highlights_OpenSummaryAsync */ + virtual void OpenSummaryAsync(SummaryParams const& params, TCallback cb = nullptr, void* cbContext = nullptr); + /*! C++ binding for \ref NVGSDK_Highlights_GetNumberOfHighlightsAsync */ + virtual void GetNumberOfHighlightsAsync(GroupView const& params, TGetNumberOfHighlightsCallback cb = nullptr, void* cbContext = nullptr); + + friend class Highlights; +private: + // Remove default construct, copy and assignment operators + HighlightsImpl(Core* core) : m_handle(core ? core->GetHandle() : nullptr) {} + HighlightsImpl(const HighlightsImpl& other) {} + HighlightsImpl& operator=(const HighlightsImpl& other) {} + +private: + NVGSDK_HANDLE* m_handle; +}; + +inline Highlights* Highlights::Create(Core* core) +{ + return new HighlightsImpl(core); +} + +inline void HighlightsImpl::ConfigureAsync(HighlightConfigParams const& params, TCallback callback, void* context) +{ + NVGSDK_HighlightConfigParams cParams; + std::vector cHighlights; + std::vector> cLocaleMaps; + for (auto it = params.highlightDefinitions.begin(); it != params.highlightDefinitions.end(); ++it) + { + cLocaleMaps.push_back(std::vector()); + for (auto localeIt = it->nameLocaleTable.begin(); localeIt != it->nameLocaleTable.end(); ++localeIt) + { + cLocaleMaps.back().push_back({ + localeIt->first.c_str(), + localeIt->second.c_str() + }); + } + cHighlights.push_back({ + it->id.c_str(), + it->userDefaultInterest, + it->highlightTags, + it->significance, + &cLocaleMaps.back()[0], + it->nameLocaleTable.size() + }); + } + cParams.highlightDefinitionTable = &cHighlights[0]; + cParams.highlightTableSize = cHighlights.size(); + cParams.defaultLocale = params.defaultLocale.c_str(); + NVGSDK_Highlights_ConfigureAsync(m_handle, &cParams, CoreImpl::callbackWrapper, new CoreImpl::CallbackContext({ callback, context })); +} + +inline void HighlightsImpl::GetUserSettingsAsync(TGetUserSettingsCallback callback, void* context) const +{ + NVGSDK_Highlights_GetUserSettingsAsync(m_handle, [](NVGSDK_RetCode rc, NVGSDK_Highlights_UserSettings const* data, void* context) { + std::unique_ptr> callbackContext(reinterpret_cast*>(context)); + if (!callbackContext->callback) return; + + if (NVGSDK_FAILED(rc)) + { + return callbackContext->callback(rc, nullptr, callbackContext->appContext); + } + + GetUserSettingsResponse r; + for (size_t i = 0; i < data->highlightSettingTableSize; ++i) + { + r.highlightSettings.push_back({ + data->highlightSettingTable[i].id, + data->highlightSettingTable[i].enabled + }); + } + callbackContext->callback(rc, &r, callbackContext->appContext); + }, new CoreImpl::CallbackContext({ callback, context })); +} + +inline void HighlightsImpl::OpenGroupAsync(HighlightOpenGroupParams const& params, TCallback callback, void* context) +{ + NVGSDK_HighlightOpenGroupParams cParams; + + std::vector localePairs; + CoreImpl::translateLocaleTable(params.groupDescriptionLocaleTable, localePairs); + cParams.groupId = params.groupId.c_str(); + cParams.groupDescriptionTable = &localePairs[0]; + cParams.groupDescriptionTableSize = localePairs.size(); + + NVGSDK_Highlights_OpenGroupAsync(m_handle, &cParams, CoreImpl::callbackWrapper, new CoreImpl::CallbackContext({ callback, context })); +} + +inline void HighlightsImpl::CloseGroupAsync(HighlightCloseGroupParams const& params, TCallback callback, void* context) +{ + NVGSDK_HighlightCloseGroupParams cParams; + cParams.groupId = params.groupId.c_str(); + cParams.destroyHighlights = params.destroyHighlights; + + NVGSDK_Highlights_CloseGroupAsync(m_handle, &cParams, CoreImpl::callbackWrapper, new CoreImpl::CallbackContext({ callback, context })); +} + +inline void HighlightsImpl::SetScreenshotHighlightAsync(ScreenshotHighlightParams const& params, TCallback callback, void* context) +{ + NVGSDK_ScreenshotHighlightParams cParams; + cParams.groupId = params.groupId.c_str(); + cParams.highlightId = params.highlightId.c_str(); + NVGSDK_Highlights_SetScreenshotHighlightAsync(m_handle, &cParams, CoreImpl::callbackWrapper, new CoreImpl::CallbackContext({ callback, context })); +} + +inline void HighlightsImpl::SetVideoHighlightAsync(VideoHighlightParams const& params, TCallback callback, void* context) +{ + NVGSDK_VideoHighlightParams cParams; + cParams.groupId = params.groupId.c_str(); + cParams.highlightId = params.highlightId.c_str(); + cParams.startDelta = params.startDelta; + cParams.endDelta = params.endDelta; + NVGSDK_Highlights_SetVideoHighlightAsync(m_handle, &cParams, CoreImpl::callbackWrapper, new CoreImpl::CallbackContext({ callback, context })); +} + +inline void HighlightsImpl::OpenSummaryAsync(SummaryParams const& params, TCallback callback, void* context) +{ + std::vector cGroupViews; + for (auto it = params.groupViews.begin(); it != params.groupViews.end(); ++it) + { + cGroupViews.push_back({ + it->groupId.c_str(), + it->tagsFilter, + it->significanceFilter + }); + } + + NVGSDK_SummaryParams cParams; + cParams.groupSummaryTable = &cGroupViews[0]; + cParams.groupSummaryTableSize = cGroupViews.size(); + NVGSDK_Highlights_OpenSummaryAsync(m_handle, &cParams, CoreImpl::callbackWrapper, new CoreImpl::CallbackContext({ callback, context })); +} + +inline void HighlightsImpl::GetNumberOfHighlightsAsync(GroupView const& params, TGetNumberOfHighlightsCallback callback, void* context) +{ + NVGSDK_GroupView cParams; + cParams.groupId = params.groupId.c_str(); + cParams.tagsFilter = params.tagsFilter; + cParams.significanceFilter = params.significanceFilter; + NVGSDK_Highlights_GetNumberOfHighlightsAsync(m_handle, &cParams, [](NVGSDK_RetCode rc, NVGSDK_Highlights_NumberOfHighlights const* data, void* context) { + std::unique_ptr> callbackContext(reinterpret_cast*>(context)); + if (!callbackContext->callback) return; + + if (NVGSDK_FAILED(rc)) + { + return callbackContext->callback(rc, nullptr, callbackContext->appContext); + } + + GetNumberOfHighlightsResponse num; + num.numHighlights = data->numberOfHighlights; + callbackContext->callback(rc, &num, callbackContext->appContext); + }, new CoreImpl::CallbackContext({ callback, context })); +} + +} + +#endif //GFESDK_IHIGHLIGHTS_CPP_IMPL_H diff --git a/ThirdParty/NVIDIAGfeSDK/Include/gfesdk/bindings/cpp/isdk_cpp.h b/ThirdParty/NVIDIAGfeSDK/Include/gfesdk/bindings/cpp/isdk_cpp.h new file mode 100644 index 0000000..f2c0d03 --- /dev/null +++ b/ThirdParty/NVIDIAGfeSDK/Include/gfesdk/bindings/cpp/isdk_cpp.h @@ -0,0 +1,56 @@ +/* Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved. +* +* NVIDIA CORPORATION and its licensors retain all intellectual property +* and proprietary rights in and to this software, related documentation +* and any modifications thereto. Any use, reproduction, disclosure or +* distribution of this software and related documentation without an express +* license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +/*! + * \file + * C++ bindings for GfeSDK. + */ + +#ifndef GFESDK_ISDK_CPP_H +#define GFESDK_ISDK_CPP_H + +#include "sdk_types_cpp.h" + +namespace GfeSDK +{ +// Avoid polluting global namespace with C api, so put it inside namespace +#include + +// Static functions that don't depend on an instance of the SDK +// Giving an alias to these to remove the NVGSDK_ prefix in lieu of the namespace +/*! C++ binding for \ref NVGSDK_SetLogLevel */ +inline NVGSDK_RetCode SetFileLogLevel(NVGSDK_LogLevel level) { return NVGSDK_SetLogLevel(level); } +/*! C++ binding for \ref NVGSDK_AttachLogListener */ +inline NVGSDK_RetCode AttachLogListener(NVGSDK_LoggingCallback callback) { return NVGSDK_AttachLogListener(callback); } +/*! C++ binding for \ref NVGSDK_SetListenerLogLevel */ +inline NVGSDK_RetCode SetListenerLogLevel(NVGSDK_LogLevel level) { return NVGSDK_SetListenerLogLevel(level); } +/*! C++ binding for NVGSDK_RetCodeToString */ +inline const char* RetCodeToString(NVGSDK_RetCode rc) { return NVGSDK_RetCodeToString(rc); } + +/*! C++ Core interface */ +class Core +{ +public: + /*! C++ binding for \ref NVGSDK_Create */ + static Core* Create(CreateInputParams const&, CreateResponse&); + virtual ~Core() {} + + /*! C++ binding for \ref NVGSDK_Poll */ + virtual NVGSDK_RetCode Poll(void) = 0; + /*! C++ binding for \ref NVGSDK_RequestPermissionsAsync */ + virtual void RequestPermissionsAsync(RequestPermissionsParams const&, TCallback cb = nullptr, void* cbContext = nullptr) = 0; + /*! C++ binding for \ref NVGSDK_GetUILanguageAsync */ + virtual void GetUILanguageAsync(TGetUILanguageCallback cb = nullptr, void* cbContext = nullptr) = 0; + + // Return the C API handle; + virtual NVGSDK_HANDLE* GetHandle() = 0; +}; +} + +#endif //GFESDK_ISDK_CPP_H diff --git a/ThirdParty/NVIDIAGfeSDK/Include/gfesdk/bindings/cpp/isdk_cpp_impl.h b/ThirdParty/NVIDIAGfeSDK/Include/gfesdk/bindings/cpp/isdk_cpp_impl.h new file mode 100644 index 0000000..f5eb3a9 --- /dev/null +++ b/ThirdParty/NVIDIAGfeSDK/Include/gfesdk/bindings/cpp/isdk_cpp_impl.h @@ -0,0 +1,219 @@ +/* Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved. +* +* NVIDIA CORPORATION and its licensors retain all intellectual property +* and proprietary rights in and to this software, related documentation +* and any modifications thereto. Any use, reproduction, disclosure or +* distribution of this software and related documentation without an express +* license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +/*! +* \file +* C++ bindings for GfeSDK. +* Implemented in the header to avoid ABI incompatibilities +*/ + +#ifndef GFESDK_ISDK_CPP_IMPL_H +#define GFESDK_ISDK_CPP_IMPL_H + +#include "isdk_cpp.h" + +#include + +namespace GfeSDK +{ +class CoreImpl : public Core +{ +public: + ~CoreImpl(); + + virtual NVGSDK_RetCode Poll(void); + virtual void RequestPermissionsAsync(RequestPermissionsParams const&, TCallback cb = nullptr, void* cbContext = nullptr); + virtual void GetUILanguageAsync(TGetUILanguageCallback cb = nullptr, void* cbContext = nullptr); + + NVGSDK_HANDLE* GetHandle(); + + friend class Core; + friend class HighlightsImpl; +private: + // Remove default construct, copy and assignment operators + CoreImpl() {} + CoreImpl(const CoreImpl& other) {} + CoreImpl& operator=(const CoreImpl& other) {} + +private: + template + struct CallbackContext + { + T callback; + void* appContext; + }; + struct CallbackNotificationContext + { + TNotificationCallback callback; + void* appContext; + }; + static void __stdcall callbackWrapper(NVGSDK_RetCode rc, void* appContext); + static void __stdcall callbackNotificationWrapper(NVGSDK_NotificationType type, NVGSDK_Notification const* data, void* context); + static inline void translateLocaleTable(std::map const& localeMap, std::vector& pairs); + + NVGSDK_HANDLE* m_handle; + std::unique_ptr m_notificationCallbackContext; +}; + +inline Core* Core::Create(CreateInputParams const& inParams, CreateResponse& outParams) +{ + CoreImpl* core = new CoreImpl(); + + NVGSDK_CreateInputParams cInputParams; + memset(&cInputParams, 0, sizeof(cInputParams)); + cInputParams.appName = inParams.appName.c_str(); + cInputParams.pollForCallbacks = inParams.pollForCallbacks; + if (!inParams.requiredScopes.empty()) + { + cInputParams.scopeTable = const_cast(&inParams.requiredScopes[0]); + cInputParams.scopeTableSize = inParams.requiredScopes.size(); + } + if (inParams.notificationCallback) + { + cInputParams.notificationCallback = &CoreImpl::callbackNotificationWrapper; + core->m_notificationCallbackContext.reset(new CoreImpl::CallbackNotificationContext({ inParams.notificationCallback, inParams.notificationCallbackContext })); + cInputParams.notificationCallbackContext = core->m_notificationCallbackContext.get(); + } + cInputParams.targetPid = inParams.targetPid; + if (!inParams.targetPath.empty()) + { + cInputParams.targetPath = inParams.targetPath.c_str(); + } + + NVGSDK_CreateResponse cOutputParams = { 0 }; + std::vector cScopePermissionList; + cScopePermissionList.resize(inParams.requiredScopes.size()); + + if (!inParams.requiredScopes.empty()) + { + cOutputParams.scopePermissionTable = &cScopePermissionList[0]; + cOutputParams.scopePermissionTableSize = cScopePermissionList.size(); + } + + outParams.returnCode = NVGSDK_Create(&core->m_handle, &cInputParams, &cOutputParams); + outParams.versionMajor = cOutputParams.versionMajor; + outParams.versionMinor = cOutputParams.versionMinor; + outParams.nvidiaGfeVersion = cOutputParams.gfeVersionStr; + + if (NVGSDK_FAILED(outParams.returnCode)) + { + delete core; + return nullptr; + } + + if (cOutputParams.scopePermissionTable) + { + for (size_t i = 0; i < cOutputParams.scopePermissionTableSize; ++i) + { + NVGSDK_ScopePermission const& scopePermission = cOutputParams.scopePermissionTable[i]; + outParams.scopePermissions[scopePermission.scope] = scopePermission.permission; + } + } + + return core; +} + +inline CoreImpl::~CoreImpl() +{ + if (!m_handle) + { + return; + } + + NVGSDK_Release(m_handle); +} + +inline NVGSDK_RetCode CoreImpl::Poll(void) +{ + return NVGSDK_Poll(m_handle); +} + +inline void CoreImpl::RequestPermissionsAsync(RequestPermissionsParams const& params, TCallback callback, void* context) +{ + NVGSDK_RequestPermissionsParams cParams; + cParams.scopeTable = const_cast(¶ms.scopes[0]); + cParams.scopeTableSize = params.scopes.size(); + return NVGSDK_RequestPermissionsAsync(m_handle, &cParams, callbackWrapper, new CallbackContext({ callback, context })); +} + +inline void CoreImpl::GetUILanguageAsync(TGetUILanguageCallback callback, void* context) +{ + NVGSDK_GetUILanguageAsync(m_handle, [](NVGSDK_RetCode rc, NVGSDK_Language const* data, void* context) { + std::unique_ptr> callbackContext(reinterpret_cast*>(context)); + if (!callbackContext->callback) return; + + if (NVGSDK_FAILED(rc)) + { + return callbackContext->callback(rc, nullptr, callbackContext->appContext); + } + + GetUILanguageResponse language; + language.cultureCode = data->cultureCode; + callbackContext->callback(rc, &language, callbackContext->appContext); + }, new CallbackContext({ callback, context })); +} + +inline NVGSDK_HANDLE* CoreImpl::GetHandle() +{ + return m_handle; +} + +inline void CoreImpl::callbackWrapper(NVGSDK_RetCode rc, void* context) +{ + std::unique_ptr> callbackContext(reinterpret_cast*>(context)); + if (!callbackContext->callback) return; + + callbackContext->callback(rc, callbackContext->appContext); +} + +inline void CoreImpl::callbackNotificationWrapper(NVGSDK_NotificationType type, NVGSDK_Notification const* data, void* context) +{ + CallbackNotificationContext* callbackContext(reinterpret_cast(context)); + if (!callbackContext->callback) return; + + switch (type) + { + case NVGSDK_NOTIFICATION_PERMISSIONS_CHANGED: + { + PermissionsChangedNotification notification; + notification.context = callbackContext->appContext; + for (size_t i = 0; i < data->permissionsChanged.scopePermissionTableSize; ++i) + { + notification.scopePermissions[data->permissionsChanged.scopePermissionTable[i].scope] = data->permissionsChanged.scopePermissionTable[i].permission; + } + callbackContext->callback(type, notification); + break; + } + case NVGSDK_NOTIFICATION_OVERLAY_STATE_CHANGED: + { + OverlayStateChangedNotification notification; + notification.context = callbackContext->appContext; + notification.open = data->overlayStateChanged.open; + notification.state = data->overlayStateChanged.state; + callbackContext->callback(type, notification); + break; + } + default: + break; + } +} + +inline void CoreImpl::translateLocaleTable(std::map const& localeMap, std::vector& pairs) +{ + for (auto it = localeMap.begin(); it != localeMap.end(); ++it) + { + pairs.push_back({ + it->first.c_str(), + it->second.c_str() + }); + } +} +} + +#endif //GFESDK_ISDK_CPP_H diff --git a/ThirdParty/NVIDIAGfeSDK/Include/gfesdk/bindings/cpp/sdk_types_cpp.h b/ThirdParty/NVIDIAGfeSDK/Include/gfesdk/bindings/cpp/sdk_types_cpp.h new file mode 100644 index 0000000..fe04f0a --- /dev/null +++ b/ThirdParty/NVIDIAGfeSDK/Include/gfesdk/bindings/cpp/sdk_types_cpp.h @@ -0,0 +1,95 @@ +/* Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved. +* +* NVIDIA CORPORATION and its licensors retain all intellectual property +* and proprietary rights in and to this software, related documentation +* and any modifications thereto. Any use, reproduction, disclosure or +* distribution of this software and related documentation without an express +* license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +#ifndef GFESDK_SDK_TYPES_CPP_H +#define GFESDK_SDK_TYPES_CPP_H + +// Include these first, so they don't get stuck in the GfeSDK namespace below +#include +#include + +// Avoid polluting global namespace with C api +namespace GfeSDK +{ +#include +} + +#include +#include +#include +#include + +namespace GfeSDK +{ + +struct NotificationBase; +typedef std::vector TScopes; +typedef std::map TScopePermissions; +typedef std::map TTranslationTable; +typedef std::function TNotificationCallback; + +struct CreateInputParams +{ + std::string appName; + TScopes requiredScopes; + bool pollForCallbacks; + TNotificationCallback notificationCallback; + void* notificationCallbackContext; + + uint32_t targetPid; //!< Advanced usage + std::string targetPath; //!< Advanced usage + + CreateInputParams() : pollForCallbacks(false), notificationCallback(nullptr), notificationCallbackContext(nullptr), targetPid(0) {} +}; + +struct RequestPermissionsParams +{ + TScopes scopes; +}; + +/////////////// Responses from API calls +typedef std::function TCallback; + +//! C++ binding for @ref NVGSDK_CreateResponse +struct CreateResponse +{ + NVGSDK_RetCode returnCode; + uint16_t versionMajor; + uint16_t versionMinor; + std::string nvidiaGfeVersion; + TScopePermissions scopePermissions; +}; + +//! C++ binding for @ref NVGSDK_GetUILanguageResponse +struct GetUILanguageResponse +{ + std::string cultureCode; +}; +typedef std::function TGetUILanguageCallback; + +/////////////// Notifications +struct NotificationBase +{ + void* context; +}; + +struct PermissionsChangedNotification : public NotificationBase +{ + TScopePermissions scopePermissions; +}; + +struct OverlayStateChangedNotification : public NotificationBase +{ + bool open; + NVGSDK_OverlayState state; +}; + +} + +#endif //GFESDK_SDK_TYPES_CPP_H diff --git a/ThirdParty/NVIDIAGfeSDK/Include/gfesdk/config.h b/ThirdParty/NVIDIAGfeSDK/Include/gfesdk/config.h new file mode 100644 index 0000000..3ae765a --- /dev/null +++ b/ThirdParty/NVIDIAGfeSDK/Include/gfesdk/config.h @@ -0,0 +1,25 @@ +/* Copyright (c) 2016, NVIDIA CORPORATION. All rights reserved. + * + * NVIDIA CORPORATION and its licensors retain all intellectual property + * and proprietary rights in and to this software, related documentation + * and any modifications thereto. Any use, reproduction, disclosure or + * distribution of this software and related documentation without an express + * license agreement from NVIDIA CORPORATION is strictly prohibited. + */ + +// Warning: This file is generated. Do not edit + +#ifndef _NVGSDK_CONFIG_H_ +#define _NVGSDK_CONFIG_H_ + +#include "gfe3_product_version.h" + +#define NVGSDK_PROJECT_NAME "GfeSDK" + +#define NVGSDK_VERSION_MAJOR 1 +#define NVGSDK_VERSION_MINOR 1 +#define NVGSDK_BUILD_NUMBER 173 +#define NVGSDK_BUILD_HASH 5d889305 +#define NVGSDK_BUILD_HASH_STR "5d889305" + +#endif // _NVGSDK_CONFIG_H_ diff --git a/ThirdParty/NVIDIAGfeSDK/Include/gfesdk/gfe3_product_version.h b/ThirdParty/NVIDIAGfeSDK/Include/gfesdk/gfe3_product_version.h new file mode 100644 index 0000000..64a2a63 --- /dev/null +++ b/ThirdParty/NVIDIAGfeSDK/Include/gfesdk/gfe3_product_version.h @@ -0,0 +1,44 @@ +// +// GFE3 product version: +// - A.B.XY.N, if X > 0 +// - A.B.Y.N, otherwise +// +// A - Major release version. +// B - Minor release version. +// X - _dev to _rel_next rebase counter. +// Y - _rel_next to _rel rebase counter. +// N - Build counter. +// +#define NVIDIA_GFE3_VERSION_MAJOR 3 +#define NVIDIA_GFE3_VERSION_MINOR 13 +#define NVIDIA_GFE3_VERSION_DEV_REBASE 0 +#define NVIDIA_GFE3_VERSION_RNEXT_REBASE 0 +#define NVIDIA_GFE3_VERSION_BUILD 47 + +// +// Composite version values. We don't concatenate them here automatically because +// (a) one can't use L-based wchar_t conversion with preprocessor-concatenated terminals; and +// (b) some build scripts rely upon the explicit value for NVIDIA_GFE3_VERSION / NVIDIA_GFE3_VERSION_STRING_DOT +// + +// Format: A,B,XY,N +#define NVIDIA_GFE3_VERSION 3,13,0,47 +// Format: A.B.XY.N +#define NVIDIA_GFE3_VERSION_DOT 3.13.0.47 +// Format: "A.B.XY.N" +#define NVIDIA_GFE3_VERSION_STRING "3.13.0.47" + +// +// Some common strings +// +#define NVIDIA_GFE3_PRODUCT_NAME "NVIDIA GeForce Experience" + +// +// These values are taken from nvVer.h +// +#define NV_COMPANY_NAME_STRING_SHORT "NVIDIA" +#define NV_COMPANY_NAME_STRING_FULL "NVIDIA Corporation" +#define NV_COMPANY_NAME_STRING NV_COMPANY_NAME_STRING_FULL +#define NV_COPYRIGHT_YEAR "2017" +#define NV_COPYRIGHT "(C) " NV_COPYRIGHT_YEAR " " NV_COMPANY_NAME_STRING_FULL ". All rights reserved." // Please do not use the non-ascii copyright symbol for (C). + diff --git a/ThirdParty/NVIDIAGfeSDK/Include/gfesdk/highlights/highlights_types.h b/ThirdParty/NVIDIAGfeSDK/Include/gfesdk/highlights/highlights_types.h new file mode 100644 index 0000000..3ae751c --- /dev/null +++ b/ThirdParty/NVIDIAGfeSDK/Include/gfesdk/highlights/highlights_types.h @@ -0,0 +1,132 @@ +/* Copyright (c) 2016-2017, NVIDIA CORPORATION. All rights reserved. +* +* NVIDIA CORPORATION and its licensors retain all intellectual property +* and proprietary rights in and to this software, related documentation +* and any modifications thereto. Any use, reproduction, disclosure or +* distribution of this software and related documentation without an express +* license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +/*! +* \file +* Highlights types +*/ + +#ifndef HIGHLIGHTS_TYPES_H +#define HIGHLIGHTS_TYPES_H + +#include +#include +#include + +/*! Possible significance values */ +typedef enum +{ + NVGSDK_HIGHLIGHT_SIGNIFICANCE_EXTREMELY_BAD = 0x00000001, + NVGSDK_HIGHLIGHT_SIGNIFICANCE_VERY_BAD = 0x00000002, + NVGSDK_HIGHLIGHT_SIGNIFICANCE_BAD = 0x00000004, + NVGSDK_HIGHLIGHT_SIGNIFICANCE_NEUTRAL = 0x00000010, + NVGSDK_HIGHLIGHT_SIGNIFICANCE_GOOD = 0x00000100, + NVGSDK_HIGHLIGHT_SIGNIFICANCE_VERY_GOOD = 0x00000200, + NVGSDK_HIGHLIGHT_SIGNIFICANCE_EXTREMELY_GOOD = 0x00000400, + NVGSDK_HIGHLIGHT_SIGNIFICANCE_MAX = 0x00000800 +} NVGSDK_HighlightSignificance; + +/*! Possible highlights that can occur during gameplay */ +typedef struct +{ + char const* id; //!< Unique id for game event. Max length @ref NVGSDK_MAX_LENGTH - 1 + bool userInterest; /*!< Boolean, whether the player is interested in this event. + * User can change this setting. This value provides the default. */ + NVGSDK_HighlightType highlightTags; //!< Tags for this highlight + NVGSDK_HighlightSignificance significance; //!< How significant the highlight is + NVGSDK_LocalizedPair* nameTable; /*!< An array of locale-highlightName pairs for the user-facing highlight name. + * If no names are given, the highlight id will be used as the "name" */ + size_t nameTableSize; //!< Number of entries in the localeNameTable */ +} NVGSDK_Highlight; + +/*! Highlight configuration parameters */ +typedef struct +{ + NVGSDK_Highlight* highlightDefinitionTable; + size_t highlightTableSize; + char const* defaultLocale; //!< Default locality, used for hinting GFE which translation to use. Defaults to en-us +} NVGSDK_HighlightConfigParams; + +/*! Informs the app of the user's highlight choices */ +typedef struct +{ + char const* id; //!< Unique id for game event. + bool enabled; //!< Boolean for whether the user wants to record this type of highlight +} NVGSDK_HighlightUserSetting; + +/*! Parameters passed into OpenGroup calls */ +typedef struct +{ + char const* groupId; /*!< Unique group ID used to refer back to the group for adding Highlights, + * or for opening the group Summary later. Max length @ref NVGSDK_MAX_LENGTH - 1 */ + NVGSDK_LocalizedPair* groupDescriptionTable; /*!< An array of locale-groupDesc pairs for the user-facing group description. + * If no names are given, the groupId will be used as the "name" */ + size_t groupDescriptionTableSize; //!< Number of entries in the groupDescriptionTable */ +} NVGSDK_HighlightOpenGroupParams; + +/*! Parameters passed into CloseGroup calls */ +typedef struct +{ + char const* groupId; //!< Unique group ID that was used to Open a group previously + bool destroyHighlights; /*!< If set to true, deletes the persisted highlights from disk. + * Highlights that have been moved to gallery are not removed */ +} NVGSDK_HighlightCloseGroupParams; + +/*! Passed into NVGSDK_Highlights_SetScreenshotHighlightAsync */ +typedef struct +{ + char const* groupId; //!< Required ID of the group this highlight is attached to. + char const* highlightId; //!< Refers to unique highlight id in highlight table +} NVGSDK_ScreenshotHighlightParams; + +/*! Passed into NVGSDK_Highlights_SetVideoHighlightAsync */ +typedef struct +{ + char const* groupId; //!< Required ID of the group this highlight is attached to. + char const* highlightId; //!< Refers to unique highlight id in highlight table + int32_t startDelta; //!< Milliseconds between the time of request, and the start of desired video clip + int32_t endDelta; //!< Milliseconds between the time of request, and end of desired video clip +} NVGSDK_VideoHighlightParams; + +/*! Represents a filtered highlight group */ +typedef struct +{ + char const* groupId; //!< Unique ID of the group to open + NVGSDK_HighlightType tagsFilter; //!< If not zero, represents a bitfield of tags to include + NVGSDK_HighlightSignificance significanceFilter; //!< If not zero, represents a bitfield of significance values to include +} NVGSDK_GroupView; + +/*! Choose the highlights to display in the group summary */ +typedef struct +{ + NVGSDK_GroupView* groupSummaryTable; //!< Pass in all the groups to display on screen + size_t groupSummaryTableSize; //!< Number of groups contained in the table pointer +} NVGSDK_SummaryParams; + + +/////////////// Responses from API calls + +/*! Returned data from NVGSDK_Highlights_GetUserSettings */ +typedef struct +{ + NVGSDK_HighlightUserSetting* highlightSettingTable; + size_t highlightSettingTableSize; +} NVGSDK_Highlights_UserSettings; +/*! Type of callback to provide to NVGSDK_Highlights_GetUserSettings */ +typedef void(__stdcall* NVGSDK_Highlights_GetUserSettingsCallback)(NVGSDK_RetCode, NVGSDK_Highlights_UserSettings const*, void*); + +/*! Returned data from NVGSDK_Highlights_GetNumberOfHighlightsAsync */ +typedef struct +{ + uint16_t numberOfHighlights; +} NVGSDK_Highlights_NumberOfHighlights; +/*! Type of callback to provide to NVGSDK_Highlights_GetNumberOfHighlightsAsync */ +typedef void(__stdcall* NVGSDK_Highlights_GetNumberOfHighlightsCallback)(NVGSDK_RetCode, NVGSDK_Highlights_NumberOfHighlights const*, void*); + +#endif // HIGHLIGHTS_TYPES_H diff --git a/ThirdParty/NVIDIAGfeSDK/Include/gfesdk/highlights/ihighlights.h b/ThirdParty/NVIDIAGfeSDK/Include/gfesdk/highlights/ihighlights.h new file mode 100644 index 0000000..2439945 --- /dev/null +++ b/ThirdParty/NVIDIAGfeSDK/Include/gfesdk/highlights/ihighlights.h @@ -0,0 +1,157 @@ +/* Copyright (c) 2016-2017, NVIDIA CORPORATION. All rights reserved. +* +* NVIDIA CORPORATION and its licensors retain all intellectual property +* and proprietary rights in and to this software, related documentation +* and any modifications thereto. Any use, reproduction, disclosure or +* distribution of this software and related documentation without an express +* license agreement from NVIDIA CORPORATION is strictly prohibited. +*/ + +/*! +* \file +* C GfeSDK Highlights API +*/ + +#ifndef GFESDK_IHIGHLIGHTS_H +#define GFESDK_IHIGHLIGHTS_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include + +/*! +* Gives a list of possible Highlights to GFE. The user will be able to see this list and determine which of them +* she cares about. Future calls to \ref NVGSDK_SetVideoHighlight and \ref NVGSDK_SetScreenshotHighlight will refer to an +* entry in this list by name. +* +* \param handle[in] - Valid SDK handle returned by NVGSDK_Create +* \param config[in] - Table of possible Highlights +* +* \param callback[in] - Callback return function as described by \ref section_async +* \param context[in] - Opaque context pointer as described by \ref section_async +* +* \retval NVGSDK_SUCCESS - Call was successful +* \retval NVGSDK_ERR_INVALID_PARAMETER - Invalid handle or other pointer provided +*/ +NVGSDK_EXPORT void NVGSDKApi +NVGSDK_Highlights_ConfigureAsync(NVGSDK_HANDLE* handle, NVGSDK_HighlightConfigParams const* config, NVGSDK_EmptyCallback callback, void* context); + +/*! +* The user is able to enable/disable Highlights. This gives the game that information. +* +* \param handle[in] - Valid SDK handle returned by NVGSDK_Create +* \param userSettings[out] - On NVGSDK_SUCCESS, will be populated with the user settings. +* +* \param callback[in] - Callback return function as described by \ref section_async +* \param context[in] - Opaque context pointer as described by \ref section_async +* +* \retval NVGSDK_SUCCESS - Call was successful +* \retval NVGSDK_ERR_INVALID_PARAMETER - Invalid handle or other pointer provided +*/ +NVGSDK_EXPORT void NVGSDKApi +NVGSDK_Highlights_GetUserSettingsAsync(NVGSDK_HANDLE* handle, NVGSDK_Highlights_GetUserSettingsCallback cb, void* cbContext); + +/*! +* Begins a "group" which groups several Highlights together. As an example, an online game will commonly consist +* of a round of action, followed by a down period sitting in the lobby. The game can choose to define a Group as +* the time between starting and finishing this round of action. At the end, all of the highlights recorded +* during that group may be displayed to the user in a group summary. +* +* \param handle[in] - Valid SDK handle returned by NVGSDK_Create +* \param params[in] - Parameter struct containing the name of the group and additional metadata +* +* \param callback[in] - Callback return function as described by \ref section_async +* \param context[in] - Opaque context pointer as described by \ref section_async +* +* \retval NVGSDK_SUCCESS - Call was successful +* \retval NVGSDK_ERR_INVALID_PARAMETER - Invalid handle or other pointer provided +*/ +NVGSDK_EXPORT void NVGSDKApi +NVGSDK_Highlights_OpenGroupAsync(NVGSDK_HANDLE* handle, NVGSDK_HighlightOpenGroupParams const* params, NVGSDK_EmptyCallback callback, void* context); + +/*! +* Closes out a group and purges the unsaved contents. See @ref NVGSDK_Highlights_OpenGroupAsync +* +* \param handle[in] - Valid SDK handle returned by NVGSDK_Create +* \param groupName[in] - Parameter struct containing the name of the group and additional close instructions +* +* \param callback[in] - Callback return function as described by \ref section_async +* \param context[in] - Opaque context pointer as described by \ref section_async +* +* \retval NVGSDK_SUCCESS - Call was successful +* \retval NVGSDK_ERR_INVALID_PARAMETER - Invalid handle or other pointer provided +*/ +NVGSDK_EXPORT void NVGSDKApi +NVGSDK_Highlights_CloseGroupAsync(NVGSDK_HANDLE* handle, NVGSDK_HighlightCloseGroupParams const* params, NVGSDK_EmptyCallback callback, void* context); + +/*! +* Records a screenshot highlight for the given group. Attached metadata to it to make the Highlight more interesting. +* +* \param handle[in] - Valid SDK handle returned by NVGSDK_Create +* \param params[in] - GroupID and metadata to attach to the highlight +* +* \param callback[in] - Callback return function as described by \ref section_async +* \param context[in] - Opaque context pointer as described by \ref section_async +* +* \retval NVGSDK_SUCCESS - Call was successful +* \retval NVGSDK_ERR_INVALID_PARAMETER - Invalid handle or other pointer provided +*/ +NVGSDK_EXPORT void NVGSDKApi +NVGSDK_Highlights_SetScreenshotHighlightAsync(NVGSDK_HANDLE* handle, NVGSDK_ScreenshotHighlightParams const* params, NVGSDK_EmptyCallback callback, void* context); + +/*! +* Records a video highlight for the given group. Attached metadata to it to make the Highlight more interesting. +* Set the start and end delta to change the length +* of the video clip. +* +* Examples: +* * The API call is made at T+0, with startDelta at -5000 and endDelta 5000. The start of the desired highlight will be +* at T-5s, and the clip will be 10s long. +* * The API call is made at T+0, with startDelta at -10000 and endDelta -5000. The start of the desired highlight will be +* at T-10s, and the clip will be 5s long. +* * The API call is made at T+0, with startDelta at 5000 and endDelta 10000. The start of the desired highlight will be +* at T+5s, and the clip will be 5s long. +* +* \param handle[in] - Valid SDK handle returned by NVGSDK_Create +* \param params[in] - GroupID and metadata to attach to the highlight +* +* \param callback[in] - Callback return function as described by \ref section_async +* \param context[in] - Opaque context pointer as described by \ref section_async +* +* \retval NVGSDK_SUCCESS - Call was successful +* \retval NVGSDK_ERR_INVALID_PARAMETER - Invalid handle or other pointer provided +*/ +NVGSDK_EXPORT void NVGSDKApi +NVGSDK_Highlights_SetVideoHighlightAsync(NVGSDK_HANDLE* handle, NVGSDK_VideoHighlightParams const*, NVGSDK_EmptyCallback callback, void* context); + +/*! +* Opens up Summary Dialog for one or more groups +* +* \param handle[in] - Valid SDK handle returned by NVGSDK_Create +* \param params[in] - Struct containing the group names and filter params +* +* \param callback[in] - Callback return function as described by \ref section_async +* \param context[in] - Opaque context pointer as described by \ref section_async +*/ +NVGSDK_EXPORT void NVGSDKApi +NVGSDK_Highlights_OpenSummaryAsync(NVGSDK_HANDLE* handle, NVGSDK_SummaryParams const* params, NVGSDK_EmptyCallback callback, void* context); + +/*! +* Retrieves the number of highlights given the group ID and filtering params +* +* \param handle[in] - Valid SDK handle returned by NVGSDK_Create +* \param groupParams[in] - Struct containing the group names and filter params +* +* \param callback[in] - Callback return function as described by \ref section_async +* \param context[in] - Opaque context pointer as described by \ref section_async +*/ +NVGSDK_EXPORT void NVGSDKApi +NVGSDK_Highlights_GetNumberOfHighlightsAsync(NVGSDK_HANDLE* handle, NVGSDK_GroupView const* groupParams, NVGSDK_Highlights_GetNumberOfHighlightsCallback cb, void* context); + +#ifdef __cplusplus +} +#endif + +#endif // GFESDK_IHIGHLIGHTS_H diff --git a/ThirdParty/NVIDIAGfeSDK/Include/gfesdk/isdk.h b/ThirdParty/NVIDIAGfeSDK/Include/gfesdk/isdk.h new file mode 100644 index 0000000..b1fe6d7 --- /dev/null +++ b/ThirdParty/NVIDIAGfeSDK/Include/gfesdk/isdk.h @@ -0,0 +1,158 @@ +/* Copyright (c) 2016-2017, NVIDIA CORPORATION. All rights reserved. + * + * NVIDIA CORPORATION and its licensors retain all intellectual property + * and proprietary rights in and to this software, related documentation + * and any modifications thereto. Any use, reproduction, disclosure or + * distribution of this software and related documentation without an express + * license agreement from NVIDIA CORPORATION is strictly prohibited. + */ + +/*! + * \file + * C GFE SDK API + */ + +#ifndef GFESDK_ISDK_H +#define GFESDK_ISDK_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include +#include +#include "stdint.h" + +/////////////////// CORE + +/*! + * Allocates and initializes the SDK interface. This is a synchronous call and + * may take tens of milliseconds. + * + * Importantly, the app must pass a list of required scopes to this call. This + * is analagous to an oauth2 type of flow. GfeSDK will choose to allocate + * certain resources based on this list. For example, passing + * \ref NVGSDK_SCOPE_HIGHLIGHTS to this list will enable all of the calls + * starting with NVGSDK_Highlights_*. For more information on permissions, see + * \ref section_permissions. + * + * The next decision for the app is whether to accept asynchronous callbacks on + * a GfeSDK-controller thread, or to poll for callbacks on a game-controlled + * thread, usually the main game loop. See + * \ref NVGSDK_CreateInputParams::pollForCallbacks and + * \ref section_threading "Threading". When bringing the SDK up for the first + * time, it may be best to start with pollForCallbacks = false, until up and + * running, and then move to the more advanced polling model that gives control + * to the proper thread. + * + * Finally, the app can pass in a callback to recieve notifications, and an + * opaque pointer that will be passed untouched to be received by the callback. + * See \ref section_notifications + * + * \param handle[out] - Will be populated by the created SDK on success + * \param inParams[in] - Input parameters for SDK creation + * \param outParams[out] - Output params for SDK creation, will be populated on return. On fatal error, this will be NULL + * + * \retval NVGSDK_SUCCESS - SDK was successfully created and returned + * \retval NVGSDK_ERR_OUT_OF_MEMORY - Could not allocate system resources for handle + * \retval NVGSDK_ERR_INVALID_PARAMETER - Invalid handle pointer provided, or no app name provided + * \retval NVGSDK_ERR_LOAD_LIBRARY - SDK wasn't able to load dependencies. Perhaps GFE is not installed. + * \retval NVGSDK_ERR_CONNECTION - SDK is not able to contact GFE backend service + * \retval NVGSDK_ERR_UNHANDLED_EXCEPTION - SDK ran into an unhandled error and caught an exception before it + * returned to client code + * \retval NVGSDK_IPC_SUCCESS_OLD_SDK - SDK will work properly, but the GfeSDK DLL version is old. + See \ref section_version + * \retval NVGSDK_IPC_SUCCESS_OLD_GFE - SDK should work properly, but the backend GFE version is older, + and may not provide the latest features. See \ref section_version + * \retval NVGSDK_ERR_GFE_VERSION - GFE version is too old for communication. User must upgrade GFE. + See \ref section_version + * \retval NVGSDK_ERR_SDK_VERSION - GfeSDK DLL version is too old. Game must distribute a newer version. + See \ref section_version + */ +NVGSDK_EXPORT NVGSDK_RetCode NVGSDKApi NVGSDK_Create(NVGSDK_HANDLE** handle, NVGSDK_CreateInputParams const* inParams, NVGSDK_CreateResponse* outParams); + +/*! + * Release the main SDK interface after create. + * + * \param pHandle[in] - SDK Handle to release + * + * \retval NVGSDK_SUCCESS - SDK was successfully released + * \retval NVGSDK_ERR_INVALID_PARAMETER - Invalid handle provided + * \retval NVGSDK_ERR_UNHANDLED_EXCEPTION - SDK ran into an unhandled error and caught an exception before it + * returned to client code + */ +NVGSDK_EXPORT NVGSDK_RetCode NVGSDKApi NVGSDK_Release(NVGSDK_HANDLE* handle); + +/*! + * When \ref NVGSDK_CreateInputParams::pollForCallbacks is set to true, it becomes + * the app's responsibility to make calls to this function to recieve asynchronous + * callbacks. See \ref section_async for more information. + * + * \param handle[in] - Valid SDK handle returned by NVGSDK_Create + */ +NVGSDK_EXPORT NVGSDK_RetCode NVGSDKApi NVGSDK_Poll(NVGSDK_HANDLE* handle); + +/*! +* Adjusts the logging level of GfeSDK. Log level documentation is found at +* \ref NVGSDK_LogLevel. See \ref section_log for more information. +* +* \param fileLvl[in] - Logs at or above this priority will be written to logfile +*/ +NVGSDK_EXPORT NVGSDK_RetCode NVGSDKApi NVGSDK_SetLogLevel(NVGSDK_LogLevel fileLevel); + +/*! + * Pass in a callback function in order to receive the log messages that GfeSDK is + * recording. The primary usecase for this is to get the GfeSDK logs into the logfile + * of a game engine. See \ref section_log for more information. + * + * \param[in] callback - Will be called back with log priority and message + */ +NVGSDK_EXPORT NVGSDK_RetCode NVGSDKApi NVGSDK_AttachLogListener(NVGSDK_LoggingCallback callback); + +/*! +* Adjusts the listener logging level of GfeSDK. This affects calls to the callback +* given to \ref NVGSDK_AttachLogListener. See \ref section_log for more information. +* +* See \ref NVGSDK_LogLevel for a list of possible levels. +* +* \param level[in] - Logs at or above this priority will be sent to callback +*/ +NVGSDK_EXPORT NVGSDK_RetCode NVGSDKApi NVGSDK_SetListenerLogLevel(NVGSDK_LogLevel level); + +/*! + * Asks the user for permissions needed by the app. This will open up the + * \ref section_igo. + * + * If the user has already decided to grant or deny permissions for these + * scopes, no overlay will be displayed, and the corresponding return value + * will be passed into the callback. + * + * \param callback[in] - Callback return function as described by \ref section_async + * \param context[in] - Opaque context pointer as described by \ref section_async + */ +NVGSDK_EXPORT void NVGSDKApi NVGSDK_RequestPermissionsAsync(NVGSDK_HANDLE* handle, NVGSDK_RequestPermissionsParams const* params, NVGSDK_EmptyCallback callback, void* context); + +/*! + * Returns the language set by the user for the onscreen UI + * + * \param handle[in] - Valid SDK handle returned by NVGSDK_Create + * \param language[out] - Will be populated on NVGSDK_SUCCESS + * + * \param callback[in] - Callback return function as described by \ref section_async + * \param context[in] - Opaque context pointer as described by \ref section_async + * + * \retval NVGSDK_SUCCESS - Call was successful, and lang was populated with the result + * \retval NVGSDK_ERR_INVALID_PARAMETER - Invalid handle provided + * \retval NVGSDK_ERR_UNHANDLED_EXCEPTION - SDK ran into an unhandled error and caught an exception before it + * returned to client code + * \retval NVGSDK_IPC_ERR_NOT_SET - The user has not chosen a language and is using the default + */ +NVGSDK_EXPORT void NVGSDKApi NVGSDK_GetUILanguageAsync(NVGSDK_HANDLE* handle, NVGSDK_GetUILanguageCallback callback, void* context); + +#ifdef __cplusplus +} +#endif + +#endif // GFESDK_ISDK_H diff --git a/ThirdParty/NVIDIAGfeSDK/Include/gfesdk/os_defines.h b/ThirdParty/NVIDIAGfeSDK/Include/gfesdk/os_defines.h new file mode 100644 index 0000000..7cf4688 --- /dev/null +++ b/ThirdParty/NVIDIAGfeSDK/Include/gfesdk/os_defines.h @@ -0,0 +1,34 @@ +/* Copyright (c) 2016-2017, NVIDIA CORPORATION. All rights reserved. + * + * NVIDIA CORPORATION and its licensors retain all intellectual property + * and proprietary rights in and to this software, related documentation + * and any modifications thereto. Any use, reproduction, disclosure or + * distribution of this software and related documentation without an express + * license agreement from NVIDIA CORPORATION is strictly prohibited. + */ + +#ifndef GFESDK_OS_DEFINES_H +#define GFESDK_OS_DEFINES_H + +#ifdef __cplusplus +extern "C" { +#endif + +#if defined _WIN32 || defined _WIN64 +# if defined(NVGSDK_COMPILE_DLL) +# define NVGSDK_EXPORT __declspec(dllexport) +# else +# define NVGSDK_EXPORT __declspec(dllimport) +# endif + +# define NVGSDKApi __cdecl +# define NVGSDK_INTERFACE struct __declspec(novtable) +#else +#error Add the appropriate construct for the platform complier +#endif + +#ifdef __cplusplus +}; +#endif + +#endif // GFESDK_OS_DEFINES_H diff --git a/ThirdParty/NVIDIAGfeSDK/Include/gfesdk/sdk_types.h b/ThirdParty/NVIDIAGfeSDK/Include/gfesdk/sdk_types.h new file mode 100644 index 0000000..5c9fd44 --- /dev/null +++ b/ThirdParty/NVIDIAGfeSDK/Include/gfesdk/sdk_types.h @@ -0,0 +1,146 @@ +/* Copyright (c) 2016-2017, NVIDIA CORPORATION. All rights reserved. + * + * NVIDIA CORPORATION and its licensors retain all intellectual property + * and proprietary rights in and to this software, related documentation + * and any modifications thereto. Any use, reproduction, disclosure or + * distribution of this software and related documentation without an express + * license agreement from NVIDIA CORPORATION is strictly prohibited. + */ + +/*! + * \file + * GFE SDK Types. NOTE: Also see sdk_types_ipc.h for types defined by the GFE backend. + */ + +#ifndef GFESDK_SDK_TYPES_H +#define GFESDK_SDK_TYPES_H + +#include +#include +#include +#include + +size_t const NVGSDK_MAX_LENGTH = 256; +size_t const NVGSDK_MAX_LOCALE = 128; +size_t const NVGSDK_MAX_HIGHLIGHT_TABLE = 128; + +struct NVGSDK_HANDLE; +typedef struct NVGSDK_HANDLE NVGSDK_HANDLE; + +/*! Version returned by GfeSDK backend. See \ref section_version for more info */ +typedef struct +{ + uint16_t major; + uint16_t minor; + char const* gfeVersionStr; //!< Current version installed by the user +} NVGSDK_Version; + +/*! Possible log levels */ +typedef enum +{ + NVGSDK_LOG_NONE = 0, + NVGSDK_LOG_ERROR = 1, + NVGSDK_LOG_INFO = 2, + NVGSDK_LOG_DEBUG = 3, + NVGSDK_LOG_VERBOSE = 4, + NVGSDK_LOG_MAX +} NVGSDK_LogLevel; + +/*! Types of unsolicited notifications */ +typedef enum +{ + NVGSDK_NOTIFICATION_PERMISSIONS_CHANGED, //!< Sent when the user accepts/denies the permissions dialog, or toggles in GFE3 + NVGSDK_NOTIFICATION_OVERLAY_STATE_CHANGED, //!< Sent when the in-game overlay is shown or removed + NVGSDK_NOTIFICATION_MAX +} NVGSDK_NotificationType; + +/*! Callback function to recieve log messages */ +typedef void (__stdcall* NVGSDK_LoggingCallback)(NVGSDK_LogLevel level, char const* message); + +/*! Translation definition */ +typedef struct +{ + char const* localeCode; //!< locale code, such as en-us, fr-fr, etc + char const* localizedString; //!< String translated for given locale. Max length @ref NVGSDK_MAX_LENGTH - 1 +} NVGSDK_LocalizedPair; + +/*! Pairs of scope and the permission level given to them */ +typedef struct +{ + NVGSDK_Scope scope; + NVGSDK_Permission permission; +} NVGSDK_ScopePermission; + +//////////// Notifications + +/*! Notification sent when the user changes their permissions given to the app */ +typedef struct +{ + NVGSDK_ScopePermission* scopePermissionTable; + size_t scopePermissionTableSize; +} NVGSDK_PermissionsChangedNotification; + +/*! Notification sent when the in-game overlay is shown or removed */ +typedef struct +{ + bool open; //!< true if the overlay is opening, false if it is closing + NVGSDK_OverlayState state; //!< State the overlay is closing from or opening to +} NVGSDK_OverlayStateChangedNotification; + +/*! Union providing switched data depending on which notification occurred. See \ref section_notifications */ +typedef struct +{ + void* context; + union + { + NVGSDK_PermissionsChangedNotification permissionsChanged; + NVGSDK_OverlayStateChangedNotification overlayStateChanged; + }; +} NVGSDK_Notification; +typedef void(__stdcall* NVGSDK_NotificationCallback)(NVGSDK_NotificationType, NVGSDK_Notification const* response, void* context); + +/*! Parameters used to setup an SDK connection, given to \ref NVGSDK_Create */ +typedef struct +{ + char const* appName; //!< Provide the name of the application. Will be used in cases when NVIDIA cannot detect game. + NVGSDK_Scope* scopeTable; //!< List of scopes used by the application + size_t scopeTableSize; //!< Number of entries in the scope table + bool pollForCallbacks; /*!< \brief Set to true to poll for asynchronous callbacks on an app thread. + * If false, callbacks will occur on a GfeSDK controlled thread, no polling necessary */ + NVGSDK_NotificationCallback notificationCallback; //!< Called on unsolicited notifications + void* notificationCallbackContext; //!< Passed along unchanged with each notification + + uint32_t targetPid; //!< Advanced usage + char const* targetPath; //!< Advanced usage +} NVGSDK_CreateInputParams; + +/*! Parameters given to \ref NVGSDK_RequestPermissionsAsync */ +typedef struct +{ + NVGSDK_Scope* scopeTable; + size_t scopeTableSize; +} NVGSDK_RequestPermissionsParams; + +/////////////// Responses from API calls + +/*! Response from \ref NVGSDK_Create call */ +typedef struct +{ + uint16_t versionMajor; //!< Will be populated with SDK major version + uint16_t versionMinor; //!< Will be populated with SDK minor version + char gfeVersionStr[NVGSDK_MAX_LENGTH]; //!< Must be provided to call. Will be populated by GFE version string + NVGSDK_ScopePermission* scopePermissionTable; //!< Must be provided to call. Will be filled with scope/permission pairs + size_t scopePermissionTableSize; //!< Must be provided to call. +} NVGSDK_CreateResponse; +/*! Type of callback to provide to most asynchronous APIs that don't return extra data */ +typedef void(__stdcall* NVGSDK_EmptyCallback)(NVGSDK_RetCode, void*); + +/*! Gets populated with the user's GFE language choice */ +typedef struct +{ + char const* cultureCode; //!< Will be populated by the user's GFE language selection +} NVGSDK_Language; +/*! Type of callback to provide to NVGSDK_GetUILanguage */ +typedef void(__stdcall* NVGSDK_GetUILanguageCallback)(NVGSDK_RetCode, NVGSDK_Language const*, void*); + +#endif // GFESDK_SDK_TYPES_H diff --git a/ThirdParty/NVIDIAGfeSDK/Include/gfesdk/sdk_types_ipc.h b/ThirdParty/NVIDIAGfeSDK/Include/gfesdk/sdk_types_ipc.h new file mode 100644 index 0000000..03416c2 --- /dev/null +++ b/ThirdParty/NVIDIAGfeSDK/Include/gfesdk/sdk_types_ipc.h @@ -0,0 +1,224 @@ +// Copyright (c) 2016, NVIDIA CORPORATION. All rights reserved. +// +// NVIDIA CORPORATION and its licensors retain all intellectual property +// and proprietary rights in and to this software, related documentation +// and any modifications thereto. Any use, reproduction, disclosure or +// distribution of this software and related documentation without an express +// license agreement from NVIDIA CORPORATION is strictly prohibited. + +#ifndef NVSDKAPI_IPC_H +#define NVSDKAPI_IPC_H + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * The API distributed with the game represents a single version of the GfeSDK. + * The installed version of GFE may or may not be compatible with this version. A + * version check is initiated when the SDK is initialized. + * + * Whenever the API between the SDK and GFE backend gets updated, one of these version numbers + * gets bumped as follows: + * MAJOR.MINOR + * MINOR - An API has changed, but the old API is still being supported for backward compatibility + * Example: An existing call is reconfigured, or an optional field is added + * Case 1: SDK DLL version and GFE Backend version are equal. No problem + * Creation will return NVGSDK_SUCCESS + * Case 2: SDK DLL version is 0.2, and GFE Backend version is 0.1 + * API is likely to function as expected, but functionality new to 0.2 won't be expected + * to work. Game should consider asking the user to upgrade GFE + * Creation will return NVGSDK_SUCCESS_VERSION_OLD_GFE + * Case 3: SDK DLL version is 0.1 and GFE Backend version is 0.2. The game needs to update + * the distributed DLL to get access to the latest feature, but otherwise it will work correctly. + * The game should update to latest SDK version when possible. + * Creation will return NVGSDK_SUCCESS_VERSION_OLD_SDK + * MAJOR - The update will break backward compatibility completely. THIS IS NEVER TO BE USED IF POSSIBLE + * Case 1: SDK DLL version and GFE Backend version are equal. No problem + * Creation will return NVGSDK_SUCCESS + * Case 2: SDK DLL version is 1.0, and GFE Backend version is 0.1. + * SDK won't work as expected. GFE3 must be upgraded. + * Creation will return NVGSDK_ERR_GFE_VERSION + * Case 3: SDK DLL version is 0.1 and GFE Backend version is 1.0. + * SDK won't work as expected. Game must ship with a newer SDK DLL. + * Creation will return NVGSDK_ERR_SDK_VERSION + */ + +int const NVGSDK_IPC_VERSION_MAJOR = 1; +int const NVGSDK_IPC_VERSION_MINOR = 1; + +/*! +* \brief Possible return values of all external APIs +*/ +typedef enum _NVGSDK_RetCode +{ + NVGSDK_SUCCESS = 0, + NVGSDK_SUCCESS_VERSION_OLD_SDK = 1001, + NVGSDK_SUCCESS_VERSION_OLD_GFE = 1002, + NVGSDK_SUCCESS_PENDING = 1003, + NVGSDK_SUCCESS_USER_NOT_INTERESTED = 1004, + NVGSDK_SUCCESS_PERMISSION_GRANTED = 1005, + + NVGSDK_ERR_GENERIC = -1001, + NVGSDK_ERR_GFE_VERSION = -1002, + NVGSDK_ERR_SDK_VERSION = -1003, + NVGSDK_ERR_NOT_IMPLEMENTED = -1004, + NVGSDK_ERR_INVALID_PARAMETER = -1005, + NVGSDK_ERR_NOT_SET = -1006, + NVGSDK_ERR_SHADOWPLAY_IR_DISABLED = -1007, + NVGSDK_ERR_SDK_IN_USE = -1008, + NVGSDK_ERR_GROUP_NOT_FOUND = -1009, + NVGSDK_ERR_FILE_NOT_FOUND = -1010, + NVGSDK_ERR_HIGHLIGHTS_SETUP_FAILED = -1011, + NVGSDK_ERR_HIGHLIGHTS_NOT_CONFIGURED = -1012, + NVGSDK_ERR_HIGHLIGHTS_SAVE_FAILED = -1013, + NVGSDK_ERR_UNEXPECTED_EXCEPTION = -1014, + NVGSDK_ERR_NO_HIGHLIGHTS = -1015, + NVGSDK_ERR_NO_CONNECTION = -1016, + NVGSDK_ERR_PERMISSION_NOT_GRANTED = -1017, + NVGSDK_ERR_PERMISSION_DENIED = -1018, + NVGSDK_ERR_INVALID_HANDLE = -1019, + NVGSDK_ERR_UNHANDLED_EXCEPTION = -1020, + NVGSDK_ERR_OUT_OF_MEMORY = -1021, + NVGSDK_ERR_LOAD_LIBRARY = -1022, + NVGSDK_ERR_LIB_CALL_FAILED = -1023, + NVGSDK_ERR_IPC_FAILED = -1024, + NVGSDK_ERR_CONNECTION = -1025, + NVGSDK_ERR_MODULE_NOT_LOADED = -1026, + NVGSDK_ERR_LIB_CALL_TIMEOUT = -1027 +} NVGSDK_RetCode; + +// not using macros to avoid polluting namespace of SDK unnecessarily + +/*! NVGSDK_RetCode success function */ +inline bool NVGSDK_SUCCEEDED(NVGSDK_RetCode r) +{ + return r >= 0; +} + +/*! NVGSDK_RetCode failure function */ +inline bool NVGSDK_FAILED(NVGSDK_RetCode r) +{ + return r < 0; +} + +/*! Possible values for highlight types */ +typedef enum +{ + /*! + * Signifies direct progress towards completing the game. (e.g. completing a level) + */ + NVGSDK_HIGHLIGHT_TYPE_MILESTONE = 0x00000001, + /*! + * Player accomplishment of extra challenges independent of progress in completing a game. + * (e.g. perfect score in a level, found the easter egg) + */ + NVGSDK_HIGHLIGHT_TYPE_ACHIEVEMENT = 0x00000002, + /*! + * Event not significant in competion of game. (e.g. player kills a minion) + */ + NVGSDK_HIGHLIGHT_TYPE_INCIDENT = 0x00000004, + /*! + * Change in player state, triggered by player or externally by game. + * (e.g. equipping a weapon) + */ + NVGSDK_HIGHLIGHT_TYPE_STATE_CHANGE = 0x00000008, + /*! + * Special highlight type that does not notify the user as it happens, to avoid giving + * the user a competetive advantage. e.g. A game doesn't tell the user that they recorded + * a kill, but wants the highlight later for the user after the round is over. + */ + NVGSDK_HIGHLIGHT_TYPE_UNANNOUNCED = 0x00000010, + //! Invalid default value + NVGSDK_HIGHLIGHT_TYPE_MAX = 0x00000020 +} NVGSDK_HighlightType; + +/*! Functionality supported by the SDK and possibly requiring user permission */ +typedef enum +{ + NVGSDK_SCOPE_HIGHLIGHTS = 0, //!< Scope required to access highlights information, open group summary, etc + NVGSDK_SCOPE_HIGHLIGHTS_VIDEO = 1, //!< Scope required to save video highlights + NVGSDK_SCOPE_HIGHLIGHTS_SCREENSHOT = 2, //!< Scope required to save screenshot highlights + NVGSDK_SCOPE_MAX +} NVGSDK_Scope; + +/*! Possible permissions that may be implicitly given by GFE, or explicitly decided by the user */ +typedef enum +{ + NVGSDK_PERMISSION_GRANTED = 0, //!< Requested permission has been granted to the app by the user + NVGSDK_PERMISSION_MUST_ASK = 1, //!< Requested permission must be granted by the user. + NVGSDK_PERMISSION_DENIED = 2, //!< Requested permission has been denied to the app, feature won't function + NVGSDK_PERMISSION_UNKNOWN = 3, //!< Scope does not match list of known scopes. Version mismatch? + NVGSDK_PERMISSION_MAX +} NVGSDK_Permission; + +/*! State that the overlay can be in when it opens and closes */ +typedef enum +{ + NVGSDK_OVERLAY_STATE_MAIN, //!< Normal overlay menu + NVGSDK_OVERLAY_STATE_PERMISSION, //!< Menu that appears to ask user for permissions + NVGSDK_OVERLAY_STATE_HIGHLIGHTS_SUMMARY,//!< Menu that appears to show the user the highlights group summary + NVGSDK_OVERLAY_STATE_MAX +} NVGSDK_OverlayState; + +/*! + * Converts the code returns from an NVGSDK_* API to a printable string + */ +inline const char* NVGSDK_RetCodeToString(NVGSDK_RetCode const ret) +{ + switch (ret) + { + case NVGSDK_SUCCESS: return "NVGSDK_SUCCESS"; + case NVGSDK_SUCCESS_VERSION_OLD_SDK: return "NVGSDK_SUCCESS_VERSION_OLD_SDK"; + case NVGSDK_SUCCESS_VERSION_OLD_GFE: return "NVGSDK_SUCCESS_VERSION_OLD_GFE"; + case NVGSDK_SUCCESS_PENDING: return "NVGSDK_SUCCESS_PENDING"; + case NVGSDK_SUCCESS_USER_NOT_INTERESTED: return "NVGSDK_SUCCESS_USER_NOT_INTERESTED"; + case NVGSDK_SUCCESS_PERMISSION_GRANTED: return "NVGSDK_SUCCESS_PERMISSION_GRANTED"; + case NVGSDK_ERR_GENERIC: return "NVGSDK_ERR_GENERIC"; + case NVGSDK_ERR_GFE_VERSION: return "NVGSDK_ERR_GFE_VERSION"; + case NVGSDK_ERR_SDK_VERSION: return "NVGSDK_ERR_SDK_VERSION"; + case NVGSDK_ERR_NOT_IMPLEMENTED: return "NVGSDK_ERR_NOT_IMPLEMENTED"; + case NVGSDK_ERR_INVALID_PARAMETER: return "NVGSDK_ERR_INVALID_PARAMETER"; + case NVGSDK_ERR_NOT_SET: return "NVGSDK_ERR_NOT_SET"; + case NVGSDK_ERR_SHADOWPLAY_IR_DISABLED: return "NVGSDK_ERR_SHADOWPLAY_IR_DISABLED"; + case NVGSDK_ERR_SDK_IN_USE: return "NVGSDK_ERR_SDK_IN_USE"; + case NVGSDK_ERR_GROUP_NOT_FOUND: return "NVGSDK_ERR_GROUP_NOT_FOUND"; + case NVGSDK_ERR_FILE_NOT_FOUND: return "NVGSDK_ERR_FILE_NOT_FOUND"; + case NVGSDK_ERR_HIGHLIGHTS_SETUP_FAILED: return "NVGSDK_ERR_HIGHLIGHTS_SETUP_FAILED"; + case NVGSDK_ERR_HIGHLIGHTS_SAVE_FAILED: return "NVGSDK_ERR_HIGHLIGHTS_SAVE_FAILED"; + case NVGSDK_ERR_UNEXPECTED_EXCEPTION: return "NVGSDK_ERR_UNEXPECTED_EXCEPTION"; + case NVGSDK_ERR_NO_HIGHLIGHTS: return "NVGSDK_ERR_NO_HIGHLIGHTS"; + case NVGSDK_ERR_NO_CONNECTION: return "NVGSDK_ERR_NO_CONNECTION"; + case NVGSDK_ERR_PERMISSION_NOT_GRANTED: return "NVGSDK_ERR_PERMISSION_NOT_GRANTED"; + case NVGSDK_ERR_PERMISSION_DENIED: return "NVGSDK_ERR_PERMISSION_DENIED"; + case NVGSDK_ERR_INVALID_HANDLE: return "NVGSDK_ERR_INVALID_HANDLE"; + case NVGSDK_ERR_UNHANDLED_EXCEPTION: return "NVGSDK_ERR_UNHANDLED_EXCEPTION"; + case NVGSDK_ERR_OUT_OF_MEMORY: return "NVGSDK_ERR_OUT_OF_MEMORY"; + case NVGSDK_ERR_LOAD_LIBRARY: return "NVGSDK_ERR_LOAD_LIBRARY"; + case NVGSDK_ERR_LIB_CALL_FAILED: return "NVGSDK_ERR_LIB_CALL_FAILED"; + case NVGSDK_ERR_IPC_FAILED: return "NVGSDK_ERR_IPC_FAILED"; + case NVGSDK_ERR_CONNECTION: return "NVGSDK_ERR_CONNECTION"; + case NVGSDK_ERR_MODULE_NOT_LOADED: return "NVGSDK_ERR_MODULE_NOT_LOADED"; + case NVGSDK_ERR_LIB_CALL_TIMEOUT: return "NVGSDK_ERR_LIB_CALL_TIMEOUT"; + } + return "Unknown code"; +} + +// All alphanumeric and the hyphen +char const VALID_GROUPID_CHARS[] = "^[a-zA-Z0-9\\-_ ]+$"; +wchar_t const VALID_GROUPID_WCHARS[] = L"^[a-zA-Z0-9\\-_ ]+$"; + +char const VALID_HIGHLIGHT_DEF_ID_CHARS[] = "^[a-zA-Z0-9\\-_ ]+$"; +wchar_t const VALID_HIGHLIGHT_DEF_ID_WCHARS[] = L"^[a-zA-Z0-9\\-_ ]+$"; + +char const VALID_GAMENAME_CHARS[] = "^[a-zA-Z0-9\\-_ ]+$"; +wchar_t const VALID_GAMENAME_WCHARS[] = L"^[a-zA-Z0-9\\-_ ]+$"; + +size_t const VALID_HIGHLIGHT_SIGNIFICANCE_WIDTH = 0x8FF; +size_t const VALID_HIGHLIGHT_TAG_WIDTH = 0x1F; + +#ifdef __cplusplus +} +#endif + +#endif // NVSDKAPI_IPC_H diff --git a/ThirdParty/NVIDIAGfeSDK/lib/win32/GfeSDK.lib b/ThirdParty/NVIDIAGfeSDK/lib/win32/GfeSDK.lib new file mode 100644 index 0000000..ed020a1 Binary files /dev/null and b/ThirdParty/NVIDIAGfeSDK/lib/win32/GfeSDK.lib differ diff --git a/ThirdParty/NVIDIAGfeSDK/lib/win32_uwp/GfeSDK.lib b/ThirdParty/NVIDIAGfeSDK/lib/win32_uwp/GfeSDK.lib new file mode 100644 index 0000000..2725c13 Binary files /dev/null and b/ThirdParty/NVIDIAGfeSDK/lib/win32_uwp/GfeSDK.lib differ diff --git a/ThirdParty/NVIDIAGfeSDK/lib/win64/GfeSDK.lib b/ThirdParty/NVIDIAGfeSDK/lib/win64/GfeSDK.lib new file mode 100644 index 0000000..037a08b Binary files /dev/null and b/ThirdParty/NVIDIAGfeSDK/lib/win64/GfeSDK.lib differ diff --git a/ThirdParty/NVIDIAGfeSDK/lib/win64_uwp/GfeSDK.lib b/ThirdParty/NVIDIAGfeSDK/lib/win64_uwp/GfeSDK.lib new file mode 100644 index 0000000..3cf3d39 Binary files /dev/null and b/ThirdParty/NVIDIAGfeSDK/lib/win64_uwp/GfeSDK.lib differ diff --git a/ThirdParty/NVIDIAGfeSDK/redist/assets/img/img_logo_experience_512.png b/ThirdParty/NVIDIAGfeSDK/redist/assets/img/img_logo_experience_512.png new file mode 100644 index 0000000..f21f970 Binary files /dev/null and b/ThirdParty/NVIDIAGfeSDK/redist/assets/img/img_logo_experience_512.png differ diff --git a/ThirdParty/NVIDIAGfeSDK/redist/assets/img/menu.jpg b/ThirdParty/NVIDIAGfeSDK/redist/assets/img/menu.jpg new file mode 100644 index 0000000..c046ade Binary files /dev/null and b/ThirdParty/NVIDIAGfeSDK/redist/assets/img/menu.jpg differ diff --git a/ThirdParty/NVIDIAGfeSDK/redist/win32/GfeSDK.dll b/ThirdParty/NVIDIAGfeSDK/redist/win32/GfeSDK.dll new file mode 100644 index 0000000..75d9b1f Binary files /dev/null and b/ThirdParty/NVIDIAGfeSDK/redist/win32/GfeSDK.dll differ diff --git a/ThirdParty/NVIDIAGfeSDK/redist/win32_uwp/GfeSDK.dll b/ThirdParty/NVIDIAGfeSDK/redist/win32_uwp/GfeSDK.dll new file mode 100644 index 0000000..9cb804d Binary files /dev/null and b/ThirdParty/NVIDIAGfeSDK/redist/win32_uwp/GfeSDK.dll differ diff --git a/ThirdParty/NVIDIAGfeSDK/redist/win64/GfeSDK.dll b/ThirdParty/NVIDIAGfeSDK/redist/win64/GfeSDK.dll new file mode 100644 index 0000000..ff73301 Binary files /dev/null and b/ThirdParty/NVIDIAGfeSDK/redist/win64/GfeSDK.dll differ diff --git a/ThirdParty/NVIDIAGfeSDK/redist/win64_uwp/GfeSDK.dll b/ThirdParty/NVIDIAGfeSDK/redist/win64_uwp/GfeSDK.dll new file mode 100644 index 0000000..62a2815 Binary files /dev/null and b/ThirdParty/NVIDIAGfeSDK/redist/win64_uwp/GfeSDK.dll differ -- cgit v1.2.3