UWPUtils.h

#pragma once
 
#if PL_DISABLED(PL_PLATFORM_WINDOWS_UWP)
#  error "uwp util header should only be included in UWP builds!"
#endif
 
#include <Foundation/Basics/Platform/Win/HResultUtils.h>
#include <Foundation/Types/Types.h>
 
#include <Foundation/Basics/Platform/Win/IncludeWindows.h>
 
#include <asyncinfo.h>
#include <guiddef.h>
#include <windows.foundation.collections.h>
#include <windows.foundation.h>
#include <windows.foundation.numerics.h>
#include <wrl/client.h>
#include <wrl/event.h>
#include <wrl/implements.h>
#include <wrl/wrappers/corewrappers.h>
 
class plUuid;
 
using namespace Microsoft::WRL::Wrappers;
using namespace Microsoft::WRL;
 
namespace plUwpUtils
{
  template <typename ElementQueryType, typename ElementType, typename Callback>
  HRESULT plWinRtIterateIVectorView(
    const ComPtr<ABI::Windows::Foundation::Collections::IVectorView<ElementType>>& pVectorView, const Callback& callback)
  {
    UINT numElements = 0;
    HRESULT result = pVectorView->get_Size(&numElements);
    if (FAILED(result))
      return result;
 
    for (UINT i = 0; i < numElements; ++i)
    {
      ElementQueryType pElement;
      result = pVectorView->GetAt(i, &pElement);
      if (FAILED(result))
        return result;
 
      if (!callback(i, pElement))
        return S_OK;
    }
 
    return result;
  }
 
  template <typename ValueInterfaceType, typename KeyType, typename ValueType, typename Callback>
  void plWinRtIterateIMapView(const ComPtr<ABI::Windows::Foundation::Collections::IMapView<KeyType, ValueType>>& pMapView, const Callback& callback)
  {
    using namespace ABI::Windows::Foundation::Collections;
    using namespace ABI::Windows::Foundation::Internal;
 
    using MapInterface = IIterable<IKeyValuePair<KeyType, GetLogicalType<ValueType>::type>*>;
 
    ComPtr<MapInterface> pIterable;
    pMapView->QueryInterface<MapInterface>(&pIterable);
 
    PL_ASSERT_DEBUG(pIterable != nullptr, "Invalid map iteration interface");
 
    ComPtr<IIterator<IKeyValuePair<KeyType, ValueType>*>> iterator;
    pIterable->First(&iterator);
 
    boolean hasCurrent = FALSE;
    iterator->get_HasCurrent(&hasCurrent);
 
    while (hasCurrent == TRUE)
    {
      IKeyValuePair<KeyType, ValueType>* pair;
      iterator->get_Current(&pair);
 
      KeyType key;
      pair->get_Key(&key);
 
      ValueInterfaceType value;
      pair->get_Value(&value);
 
      if (!callback(key, value))
        return;
 
      iterator->MoveNext(&hasCurrent);
    }
  }
 
  template <typename AsyncCompletedType, typename AsyncResultType, typename Callback, typename ObjectType>
  HRESULT plWinRtPutCompleted(ObjectType& object, Callback callback)
  {
    object->put_Completed(Microsoft::WRL::Callback<ABI::Windows::Foundation::IAsyncOperationCompletedHandler<AsyncCompletedType>>(
      [callback](ABI::Windows::Foundation::IAsyncOperation<AsyncCompletedType>* pCompletion, AsyncStatus status)
      {
        if (status != ABI::Windows::Foundation::AsyncStatus::Completed)
          return S_OK;
 
        AsyncResultType pResult;
        pCompletion->GetResults(&pResult);
 
        callback(pResult);
 
        return S_OK;
      }).Get());
 
    return S_OK;
  }
 
  template <typename T>
  void RetrieveStatics(const WCHAR* szRuntimeClassName, ComPtr<T>& out_Ptr)
  {
    if (FAILED(ABI::Windows::Foundation::GetActivationFactory(HStringReference(szRuntimeClassName).Get(), &out_Ptr)))
    {
      PL_REPORT_FAILURE("Failed to retrieve activation factory (statics) for '{0}'", plStringUtf8(szRuntimeClassName).GetData());
      out_Ptr = nullptr;
    }
  }
 
  template <typename T>
  void CreateInstance(const WCHAR* szRuntimeClassName, ComPtr<T>& out_Ptr)
  {
    ::RoActivateInstance(HStringReference(szRuntimeClassName).Get(), &out_Ptr);
  }
 
  plMat4 PL_FOUNDATION_DLL ConvertMat4(const ABI::Windows::Foundation::Numerics::Matrix4x4& in);
 
  plVec3 PL_FOUNDATION_DLL ConvertVec3(const ABI::Windows::Foundation::Numerics::Vector3& in);
  void PL_FOUNDATION_DLL ConvertVec3(const plVec3& in, ABI::Windows::Foundation::Numerics::Vector3& out);
 
  plQuat PL_FOUNDATION_DLL ConvertQuat(const ABI::Windows::Foundation::Numerics::Quaternion& in);
  void PL_FOUNDATION_DLL ConvertQuat(const plQuat& in, ABI::Windows::Foundation::Numerics::Quaternion& out);
 
  plUuid PL_FOUNDATION_DLL ConvertGuid(const GUID& in);
  void PL_FOUNDATION_DLL ConvertGuid(const plUuid& in, GUID& out);
} // namespace plUwpUtils