First commit

1 files changed, 245 insertions, 0 deletions

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