From 2415f5df72265afb368d5189b91cbe6242da4e5f Mon Sep 17 00:00:00 2001
From: Grigoriy <godegov@nvidia.com>
Date: Mon, 12 Mar 2018 00:30:49 +0300
Subject: First commit

---
 Source/NVIDIAGfeSDK/Private/GfeSDKHighlights.cpp | 245 +++++++++++++++++++++++
 1 file changed, 245 insertions(+)
 create mode 100644 Source/NVIDIAGfeSDK/Private/GfeSDKHighlights.cpp

(limited to 'Source/NVIDIAGfeSDK/Private/GfeSDKHighlights.cpp')

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<LocaleStringPair> Strings;
+	std::vector<GfeSDK::NVGSDK_LocalizedPair> 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<GfeSDK::NVGSDK_Highlight> Highlights(Params.HighlightDefinitions.Num());
+	// TCHAR_TO_UTF8 shares internal buffer, so its results need to be assigned by copy, not pointer.
+	std::vector <std::string> id(Params.HighlightDefinitions.Num()); // Workaround for usage of TCHAR_TO_UTF8.
+	std::vector<LocaleHighlightsList> LocaleStringPairs(Params.HighlightDefinitions.Num());
+
+    for (int32 i=0; i<Params.HighlightDefinitions.Num(); i++)
+    {
+		GfeSDK::NVGSDK_Highlight def;
+        
+		const FGfeSDKHighlightDefinition& ueDef(Params.HighlightDefinitions[i]);
+		id[i] = TCHAR_TO_UTF8(*ueDef.Id);
+		def.id = id[i].c_str();
+		def.highlightTags = TranslateBitfieldEnum(kHighlightTypeUnrealToSdk, ueDef.HighlightTags);
+		def.significance = TranslateBitfieldEnum(kHighlightSignificanceUnrealToSdk, ueDef.Significance);
+		def.userInterest = ueDef.UserDefaultInterest;
+
+		LocaleStringPairs[i].Pairs.resize(ueDef.NameTranslationTable.Num());
+		LocaleStringPairs[i].Strings.resize(ueDef.NameTranslationTable.Num());
+
+		int32 s = 0;
+		for (auto& Entry : ueDef.NameTranslationTable)
+        {			
+			LocaleStringPairs[i].Strings[s].localeCode = TCHAR_TO_UTF8(*Entry.Key);
+			LocaleStringPairs[i].Strings[s].localizedString = TCHAR_TO_UTF8(*Entry.Value);
+
+			LocaleStringPairs[i].Pairs[s].localeCode = LocaleStringPairs[i].Strings[s].localeCode.c_str();
+			LocaleStringPairs[i].Pairs[s].localizedString = LocaleStringPairs[i].Strings[s].localizedString.c_str();
+			s++;
+        }
+		
+		def.nameTable = LocaleStringPairs[i].Pairs.data();
+		def.nameTableSize = LocaleStringPairs[i].Pairs.size();
+
+		Highlights[i] = def;
+    }
+	cParams.highlightDefinitionTable = Highlights.data();
+	cParams.highlightTableSize = Highlights.size();
+	GfeSDK::NVGSDK_Highlights_ConfigureAsync(GFEHandle, &cParams, Callback, Context);
+}
+
+void FGfeSDKHighlights::GetUserSettingsAsync(GfeSDK::NVGSDK_Highlights_GetUserSettingsCallback Callback, void* Context) const
+{
+    VALIDATE_MODULE_HIGHLIGHTS_SPECIALIZED();
+	GfeSDK::NVGSDK_Highlights_GetUserSettingsAsync(GFEHandle, Callback, Context);
+}
+
+void FGfeSDKHighlights::OpenGroupAsync(FGfeSDKHighlightOpenGroupParams const& Params, GfeSDK::NVGSDK_EmptyCallback Callback, void* Context)
+{
+    VALIDATE_MODULE_HIGHLIGHTS();
+
+	LocaleHighlightsList LocaleHighlights;
+	LocaleHighlights.Pairs.resize(Params.GroupDescriptionTranslationTable.Num());
+	LocaleHighlights.Strings.resize(Params.GroupDescriptionTranslationTable.Num());
+
+	GfeSDK::NVGSDK_HighlightOpenGroupParams params;
+
+	const std::string groupId(TCHAR_TO_UTF8(*Params.GroupId));
+	params.groupId = groupId.c_str();
+
+	int32 s = 0;
+    for (auto& Entry : Params.GroupDescriptionTranslationTable)
+    {
+		LocaleHighlights.Strings[s].localeCode = TCHAR_TO_UTF8(*Entry.Key);
+		LocaleHighlights.Strings[s].localizedString = TCHAR_TO_UTF8(*Entry.Value);
+		LocaleHighlights.Pairs[s].localeCode = LocaleHighlights.Strings[s].localeCode.c_str();
+		LocaleHighlights.Pairs[s].localizedString = LocaleHighlights.Strings[s].localizedString.c_str();
+    }
+
+	params.groupDescriptionTable = LocaleHighlights.Pairs.data();
+	params.groupDescriptionTableSize = LocaleHighlights.Pairs.size();
+
+	GfeSDK::NVGSDK_Highlights_OpenGroupAsync(GFEHandle, &params, Callback, Context);
+}
+
+void FGfeSDKHighlights::CloseGroupAsync(FGfeSDKHighlightCloseGroupParams const& Params, GfeSDK::NVGSDK_EmptyCallback Callback, void* Context)
+{
+    VALIDATE_MODULE_HIGHLIGHTS();
+
+	GfeSDK::NVGSDK_HighlightCloseGroupParams params;
+	std::string ID = TCHAR_TO_UTF8(*Params.GroupId);
+	params.groupId = ID.c_str();
+	params.destroyHighlights = Params.DestroyHighlights;
+
+	GfeSDK::NVGSDK_Highlights_CloseGroupAsync(GFEHandle, &params, Callback, Context);
+}
+
+void FGfeSDKHighlights::SetScreenshotHighlightAsync(FGfeSDKHighlightScreenshotParams const& Params, GfeSDK::NVGSDK_EmptyCallback Callback, void* Context)
+{
+    VALIDATE_MODULE_HIGHLIGHTS();
+	std::string gID = TCHAR_TO_UTF8(*Params.GroupId);
+	std::string hID = TCHAR_TO_UTF8(*Params.HighlightId);
+
+	GfeSDK::NVGSDK_ScreenshotHighlightParams params;
+
+    params.groupId = gID.c_str();
+    params.highlightId = hID.c_str();
+
+	GfeSDK::NVGSDK_Highlights_SetScreenshotHighlightAsync(GFEHandle, &params, Callback, Context);
+}
+
+void FGfeSDKHighlights::SetVideoHighlightAsync(FGfeSDKHighlightVideoParams const& Params, GfeSDK::NVGSDK_EmptyCallback Callback, void* Context)
+{
+    VALIDATE_MODULE_HIGHLIGHTS();
+	GfeSDK::NVGSDK_VideoHighlightParams cParams;
+
+	std::string gID = TCHAR_TO_UTF8(*Params.GroupId);
+	std::string hID = TCHAR_TO_UTF8(*Params.HighlightId);
+
+	cParams.groupId = gID.c_str();
+	cParams.highlightId = hID.c_str();
+	cParams.endDelta = Params.EndDelta;
+	cParams.startDelta = Params.StartDelta;
+
+	GfeSDK::NVGSDK_Highlights_SetVideoHighlightAsync(GFEHandle, &cParams, Callback, Context);
+}
+
+void FGfeSDKHighlights::OpenSummaryAsync(FGfeSDKHighlightSummaryParams const& Params, GfeSDK::NVGSDK_EmptyCallback Callback, void* Context)
+{
+    VALIDATE_MODULE_HIGHLIGHTS();
+	GfeSDK::NVGSDK_SummaryParams cParams;
+	
+	std::vector<GfeSDK::NVGSDK_GroupView> cGroupViews(Params.GroupViews.Num());
+	std::vector<std::string> 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<SNumHighlightsInfo*>(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
-- 
cgit v1.2.3