Add WinrtWindow.cpp and WinRT version of angle_util

util/util.gyp

@@ -27,13 +27,24 @@
         ],
         'util_win32_sources':
         [
-            'win32/Win32_system_utils.cpp',
-            'win32/Win32Pixmap.cpp',
-            'win32/Win32Pixmap.h',
-            'win32/Win32Timer.cpp',
-            'win32/Win32Timer.h',
-            'win32/Win32Window.cpp',
-            'win32/Win32Window.h',
+            'windows/win32/Win32_system_utils.cpp',
+            'windows/win32/Win32Pixmap.cpp',
+            'windows/win32/Win32Pixmap.h',
+            'windows/win32/Win32Window.cpp',
+            'windows/win32/Win32Window.h',
+            'windows/Windows_system_utils.cpp',
+            'windows/WindowsTimer.cpp',
+            'windows/WindowsTimer.h',
+        ],
+        'util_winrt_sources':
+        [
+            'windows/winrt/WinRT_system_utils.cpp',
+            'windows/winrt/WinRTPixmap.cpp',
+            'windows/winrt/WinRTWindow.cpp',
+            'windows/winrt/WinRTWindow.h',
+            'windows/Windows_system_utils.cpp',
+            'windows/WindowsTimer.cpp',
+            'windows/WindowsTimer.h',
         ],
         'util_linux_sources':
         [
@@ -106,14 +117,20 @@
             },
             'conditions':
             [
-                ['OS=="win"',
+                ['OS=="win" and angle_build_winrt==0',
                 {
-                    'msvs_disabled_warnings': [ 4201 ],
                     'sources':
                     [
                         '<@(util_win32_sources)',
                     ],
                 }],
+                ['OS=="win" and angle_build_winrt==1',
+                {
+                    'sources':
+                    [
+                        '<@(util_winrt_sources)',
+                    ],
+                }],
                 ['OS=="linux"',
                 {
                     'sources':

util/win32/Win32Timer.cpp → util/windows/WindowsTimer.cpp

@@ -4,18 +4,15 @@
 // found in the LICENSE file.
 //
 
-// Win32Timer.cpp: Implementation of a high precision timer class on Windows
+// WindowsTimer.cpp: Implementation of a high precision timer class on Windows
 
-#include "win32/Win32Timer.h"
+#include "windows/WindowsTimer.h"
 
-Win32Timer::Win32Timer()
-    : mRunning(false),
-      mStartTime(0),
-      mStopTime(0)
+WindowsTimer::WindowsTimer() : mRunning(false), mStartTime(0), mStopTime(0)
 {
 }
 
-void Win32Timer::start()
+void WindowsTimer::start()
 {
     LARGE_INTEGER frequency;
     QueryPerformanceFrequency(&frequency);
@@ -28,7 +25,7 @@ void Win32Timer::start()
     mRunning = true;
 }
 
-void Win32Timer::stop()
+void WindowsTimer::stop()
 {
     LARGE_INTEGER curTime;
     QueryPerformanceCounter(&curTime);
@@ -37,7 +34,7 @@ void Win32Timer::stop()
     mRunning = false;
 }
 
-double Win32Timer::getElapsedTime() const
+double WindowsTimer::getElapsedTime() const
 {
     LONGLONG endTime;
     if (mRunning)
@@ -56,5 +53,5 @@ double Win32Timer::getElapsedTime() const
 
 Timer *CreateTimer()
 {
-    return new Win32Timer();
+    return new WindowsTimer();
 }

util/win32/Win32Timer.h → util/windows/WindowsTimer.h

@@ -4,19 +4,19 @@
 // found in the LICENSE file.
 //
 
-// Win32Timer.h: Definition of a high precision timer class on Windows
+// WindowsTimer.h: Definition of a high precision timer class on Windows
 
-#ifndef UTIL_WIN32_TIMER_H
-#define UTIL_WIN32_TIMER_H
+#ifndef UTIL_WINDOWS_TIMER_H
+#define UTIL_WINDOWS_TIMER_H
 
 #include <windows.h>
 
 #include "Timer.h"
 
-class Win32Timer : public Timer
+class WindowsTimer : public Timer
 {
   public:
-    Win32Timer();
+    WindowsTimer();
 
     void start() override;
     void stop() override;
@@ -30,4 +30,4 @@ class Win32Timer : public Timer
     LONGLONG mFrequency;
 };
 
-#endif // UTIL_WIN32_TIMER_H
+#endif  // UTIL_WINDOWS_TIMER_H

util/win32/Win32_system_utils.cpp → util/windows/Windows_system_utils.cpp

@@ -4,7 +4,7 @@
 // found in the LICENSE file.
 //
 
-// Win32_system_utils.cpp: Implementation of OS-specific functions for Windows
+// Windows_system_utils.cpp: Implementation of OS-specific functions for Windows
 
 #include "system_utils.h"
 
@@ -34,9 +34,4 @@ void Sleep(unsigned int milliseconds)
     ::Sleep(static_cast<DWORD>(milliseconds));
 }
 
-void SetLowPriorityProcess()
-{
-    SetPriorityClass(GetCurrentProcess(), BELOW_NORMAL_PRIORITY_CLASS);
-}
-
-} // namespace angle
+}  // namespace angle

util/win32/Win32Pixmap.cpp → util/windows/win32/Win32Pixmap.cpp

@@ -4,12 +4,11 @@
 // found in the LICENSE file.
 //
 
-// Win32Pixmap.cpp: Implementation of OSPixmap for Windows
+// Win32Pixmap.cpp: Implementation of OSPixmap for Win32 (Windows)
 
-#include "win32/Win32Pixmap.h"
+#include "windows/win32/Win32Pixmap.h"
 
-Win32Pixmap::Win32Pixmap()
-    : mBitmap(nullptr)
+Win32Pixmap::Win32Pixmap() : mBitmap(nullptr)
 {
 }
 
@@ -31,20 +30,20 @@ bool Win32Pixmap::initialize(EGLNativeDisplayType display, size_t width, size_t
         return false;
     }
 
-    bitmapInfo.bmiHeader.biSize = sizeof(bitmapInfo);
+    bitmapInfo.bmiHeader.biSize          = sizeof(bitmapInfo);
     bitmapInfo.bmiHeader.biWidth         = static_cast<LONG>(width);
     bitmapInfo.bmiHeader.biHeight        = static_cast<LONG>(height);
-    bitmapInfo.bmiHeader.biPlanes = 1;
-    bitmapInfo.bmiHeader.biBitCount = static_cast<WORD>(depth);
-    bitmapInfo.bmiHeader.biCompression = BI_RGB;
-    bitmapInfo.bmiHeader.biSizeImage = 0;
+    bitmapInfo.bmiHeader.biPlanes        = 1;
+    bitmapInfo.bmiHeader.biBitCount      = static_cast<WORD>(depth);
+    bitmapInfo.bmiHeader.biCompression   = BI_RGB;
+    bitmapInfo.bmiHeader.biSizeImage     = 0;
     bitmapInfo.bmiHeader.biXPelsPerMeter = 1;
     bitmapInfo.bmiHeader.biYPelsPerMeter = 1;
-    bitmapInfo.bmiHeader.biClrUsed = 0;
-    bitmapInfo.bmiHeader.biClrImportant = 0;
+    bitmapInfo.bmiHeader.biClrUsed       = 0;
+    bitmapInfo.bmiHeader.biClrImportant  = 0;
 
     void *bitmapPtr = nullptr;
-    mBitmap = CreateDIBSection(display, &bitmapInfo, DIB_RGB_COLORS, &bitmapPtr, nullptr, 0);
+    mBitmap         = CreateDIBSection(display, &bitmapInfo, DIB_RGB_COLORS, &bitmapPtr, nullptr, 0);
 
     return mBitmap != nullptr;
 }

util/win32/Win32Pixmap.h → util/windows/win32/Win32Pixmap.h

@@ -4,7 +4,7 @@
 // found in the LICENSE file.
 //
 
-// Win32Pixmap.h: Definition of the implementation of OSPixmap for Windows
+// Win32Pixmap.h: Definition of the implementation of OSPixmap for Win32 (Windows)
 
 #ifndef UTIL_WIN32_PIXMAP_H_
 #define UTIL_WIN32_PIXMAP_H_
@@ -27,4 +27,4 @@ class Win32Pixmap : public OSPixmap
     HBITMAP mBitmap;
 };
 
-#endif // UTIL_WIN32_PIXMAP_H_
+#endif  // UTIL_WIN32_PIXMAP_H_

util/win32/Win32Window.h → util/windows/win32/Win32Window.h

@@ -4,7 +4,7 @@
 // found in the LICENSE file.
 //
 
-// Win32Window.h: Definition of the implementation of OSWindow for Windows
+// Win32Window.h: Definition of the implementation of OSWindow for Win32 (Windows)
 
 #ifndef UTIL_WIN32_WINDOW_H
 #define UTIL_WIN32_WINDOW_H
@@ -19,7 +19,7 @@ class Win32Window : public OSWindow
 {
   public:
     Win32Window();
-    ~Win32Window();
+    ~Win32Window() override;
 
     bool initialize(const std::string &name, size_t width, size_t height) override;
     void destroy() override;
@@ -52,4 +52,4 @@ class Win32Window : public OSWindow
     EGLNativeDisplayType mNativeDisplay;
 };
 
-#endif // UTIL_WIN32_WINDOW_H
+#endif  // UTIL_WIN32_WINDOW_H

util/windows/win32/Win32_system_utils.cpp

+//
+// Copyright (c) 2014 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// Win32_system_utils.cpp: Implementation of OS-specific functions for Win32 (Windows)
+
+#include "system_utils.h"
+
+#include <windows.h>
+#include <array>
+
+namespace angle
+{
+
+void SetLowPriorityProcess()
+{
+    SetPriorityClass(GetCurrentProcess(), BELOW_NORMAL_PRIORITY_CLASS);
+}
+
+}  // namespace angle

util/windows/winrt/WinRTPixmap.cpp

+//
+// Copyright (c) 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// WinRTPixmap.cpp: Stub implementation of OSPixmap functions for WinRT (Windows)
+
+#include "OSPixmap.h"
+
+#include "common/debug.h"
+
+OSPixmap *CreateOSPixmap()
+{
+    UNIMPLEMENTED();
+    return nullptr;
+}
\ No newline at end of file

util/windows/winrt/WinRTWindow.cpp

+//
+// Copyright (c) 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// WinRTWindow.cpp: Implementation of OSWindow for WinRT (Windows)
+
+#include "windows/winrt/WinRTWindow.h"
+
+#include <wrl.h>
+#include <windows.applicationmodel.core.h>
+#include <windows.ui.xaml.h>
+
+#include "angle_windowsstore.h"
+#include "common/debug.h"
+
+using namespace ABI::Windows::ApplicationModel::Core;
+using namespace ABI::Windows::Foundation;
+using namespace ABI::Windows::Foundation::Collections;
+using namespace ABI::Windows::UI::Core;
+using namespace Microsoft::WRL;
+using namespace Microsoft::WRL::Wrappers;
+
+WinRTWindow::WinRTWindow() : mNativeWindow(nullptr)
+{
+}
+
+WinRTWindow::~WinRTWindow()
+{
+    destroy();
+}
+
+bool WinRTWindow::initialize(const std::string &name, size_t width, size_t height)
+{
+    ComPtr<ICoreWindowStatic> coreWindowStatic;
+    ComPtr<IActivationFactory> propertySetFactory;
+    ComPtr<IPropertyValueStatics> propertyValueStatics;
+
+    ComPtr<ICoreApplication> coreApplication;
+    ComPtr<IPropertySet> coreApplicationProperties;
+    ComPtr<IMap<HSTRING, IInspectable *>> coreApplicationPropertiesAsMap;
+
+    ComPtr<IMap<HSTRING, IInspectable *>> nativeWindowAsMap;
+    ComPtr<IInspectable> sizeValue;
+
+    HRESULT result           = S_OK;
+    boolean propertyReplaced = false;
+
+    destroy();
+
+    // Get all the relevant activation factories
+    result = GetActivationFactory(
+        HStringReference(RuntimeClass_Windows_UI_Core_CoreWindow).Get(), &coreWindowStatic);
+    if (FAILED(result))
+    {
+        return false;
+    }
+
+    result = GetActivationFactory(
+        HStringReference(RuntimeClass_Windows_Foundation_Collections_PropertySet).Get(),
+        &propertySetFactory);
+    if (FAILED(result))
+    {
+        return false;
+    }
+
+    result =
+        GetActivationFactory(HStringReference(RuntimeClass_Windows_Foundation_PropertyValue).Get(),
+                             &propertyValueStatics);
+    if (FAILED(result))
+    {
+        return false;
+    }
+
+    result = GetActivationFactory(
+        HStringReference(RuntimeClass_Windows_ApplicationModel_Core_CoreApplication).Get(),
+        &coreApplication);
+    if (FAILED(result))
+    {
+        return false;
+    }
+
+    // Create a PropertySet to be used as the native window
+    result = propertySetFactory->ActivateInstance(&mNativeWindow);
+    if (FAILED(result))
+    {
+        return false;
+    }
+
+    // Get the PropertySet as a map, so we can Insert things into it later
+    ComPtr<IInspectable> tempNativeWindow = mNativeWindow;
+    result = tempNativeWindow.As(&nativeWindowAsMap);
+    if (FAILED(result))
+    {
+        return false;
+    }
+
+    // Get the CoreApplication properties
+    result = coreApplication->get_Properties(coreApplicationProperties.GetAddressOf());
+    if (FAILED(result))
+    {
+        return false;
+    }
+
+    // Get the CoreApplication properties as a map
+    result = coreApplicationProperties.As(&coreApplicationPropertiesAsMap);
+    if (FAILED(result))
+    {
+        return false;
+    }
+
+    // See if the application properties contain an EGLNativeWindowTypeProperty
+    boolean hasEGLNativeWindowTypeProperty;
+    result = coreApplicationPropertiesAsMap->HasKey(
+        HStringReference(EGLNativeWindowTypeProperty).Get(), &hasEGLNativeWindowTypeProperty);
+    if (FAILED(result))
+    {
+        return false;
+    }
+
+    // If an EGLNativeWindowTypeProperty is inputted then use it
+    if (hasEGLNativeWindowTypeProperty)
+    {
+        ComPtr<IInspectable> coreApplicationPropertyNativeWindow;
+
+        result = coreApplicationPropertiesAsMap->Lookup(
+            HStringReference(EGLNativeWindowTypeProperty).Get(),
+            &coreApplicationPropertyNativeWindow);
+        if (FAILED(result))
+        {
+            return false;
+        }
+
+        // See if the inputted window was a CoreWindow
+        ComPtr<ICoreWindow> applicationPropertyCoreWindow;
+        if (SUCCEEDED(coreApplicationPropertyNativeWindow.As(&applicationPropertyCoreWindow)))
+        {
+            // Store away the CoreWindow's dispatcher, to be used later to process messages
+            result = applicationPropertyCoreWindow->get_Dispatcher(&mCoreDispatcher);
+            if (FAILED(result))
+            {
+                return false;
+            }
+        }
+        else
+        {
+            ComPtr<IPropertySet> propSet;
+
+            // Disallow Property Sets here, since we want to wrap this window in
+            // a property set with the size property below
+            if (SUCCEEDED(coreApplicationPropertyNativeWindow.As(&propSet)))
+            {
+                return false;
+            }
+        }
+
+        // Add the window to the map
+        result =
+            nativeWindowAsMap->Insert(HStringReference(EGLNativeWindowTypeProperty).Get(),
+                                      coreApplicationPropertyNativeWindow.Get(), &propertyReplaced);
+        if (FAILED(result))
+        {
+            return false;
+        }
+    }
+    else
+    {
+        ComPtr<ICoreWindow> currentThreadCoreWindow;
+
+        // Get the CoreWindow for the current thread
+        result = coreWindowStatic->GetForCurrentThread(&currentThreadCoreWindow);
+        if (FAILED(result))
+        {
+            return false;
+        }
+
+        // By default, just add this thread's CoreWindow to the PropertySet
+        result = nativeWindowAsMap->Insert(HStringReference(EGLNativeWindowTypeProperty).Get(),
+                                           currentThreadCoreWindow.Get(), &propertyReplaced);
+        if (FAILED(result))
+        {
+            return false;
+        }
+
+        // Store away the CoreWindow's dispatcher, to be used later to process messages
+        result = currentThreadCoreWindow->get_Dispatcher(&mCoreDispatcher);
+        if (FAILED(result))
+        {
+            return false;
+        }
+    }
+
+    // Create a Size to represent the Native Window's size
+    Size renderSize;
+    renderSize.Width  = static_cast<float>(width);
+    renderSize.Height = static_cast<float>(height);
+    result = propertyValueStatics->CreateSize(renderSize, sizeValue.GetAddressOf());
+    if (FAILED(result))
+    {
+        return false;
+    }
+
+    // Add the Size to the PropertySet
+    result = nativeWindowAsMap->Insert(HStringReference(EGLRenderSurfaceSizeProperty).Get(),
+                                       sizeValue.Get(), &propertyReplaced);
+    if (FAILED(result))
+    {
+        return false;
+    }
+
+    return true;
+};
+
+void WinRTWindow::destroy()
+{
+    SafeRelease(mNativeWindow);
+
+    mCoreDispatcher.Reset();
+}
+
+EGLNativeWindowType WinRTWindow::getNativeWindow() const
+{
+    return mNativeWindow;
+}
+
+EGLNativeDisplayType WinRTWindow::getNativeDisplay() const
+{
+    UNIMPLEMENTED();
+    return static_cast<EGLNativeDisplayType>(0);
+}
+
+void WinRTWindow::messageLoop()
+{
+    // If we have a CoreDispatcher then use it to process events
+    if (mCoreDispatcher)
+    {
+        HRESULT result =
+            mCoreDispatcher->ProcessEvents(CoreProcessEventsOption_ProcessAllIfPresent);
+        UNUSED_ASSERTION_VARIABLE(result);
+        ASSERT(SUCCEEDED(result));
+    }
+}
+
+void WinRTWindow::setMousePosition(int /* x */, int /* y */)
+{
+    UNIMPLEMENTED();
+}
+
+bool WinRTWindow::setPosition(int /* x */, int /* y */)
+{
+    UNIMPLEMENTED();
+    return false;
+}
+
+bool WinRTWindow::resize(int /* width */, int /* height */)
+{
+    UNIMPLEMENTED();
+    return false;
+}
+
+void WinRTWindow::setVisible(bool isVisible)
+{
+    if (isVisible)
+    {
+        // Already visible by default
+        return;
+    }
+    else
+    {
+        // Not implemented in WinRT
+        UNIMPLEMENTED();
+    }
+}
+
+void WinRTWindow::signalTestEvent()
+{
+    UNIMPLEMENTED();
+}
+
+OSWindow *CreateOSWindow()
+{
+    return new WinRTWindow();
+}
\ No newline at end of file

util/windows/winrt/WinRTWindow.h

+//
+// Copyright (c) 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// WinRTWindow.h: Definition of the implementation of OSWindow for WinRT (Windows)
+
+#ifndef UTIL_WINRT_WINDOW_H
+#define UTIL_WINRT_WINDOW_H
+
+#include <string>
+#include <windows.h>
+#include <windows.applicationmodel.core.h>
+#include <wrl.h>
+
+#include "OSWindow.h"
+
+class WinRTWindow : public OSWindow
+{
+  public:
+    WinRTWindow();
+    ~WinRTWindow() override;
+
+    bool initialize(const std::string &name, size_t width, size_t height) override;
+    void destroy() override;
+
+    EGLNativeWindowType getNativeWindow() const override;
+    EGLNativeDisplayType getNativeDisplay() const override;
+
+    void messageLoop() override;
+
+    void setMousePosition(int x, int y) override;
+    bool setPosition(int x, int y) override;
+    bool resize(int width, int height) override;
+    void setVisible(bool isVisible) override;
+
+    void signalTestEvent() override;
+
+  private:
+    EGLNativeWindowType mNativeWindow;
+    Microsoft::WRL::ComPtr<ABI::Windows::UI::Core::ICoreDispatcher> mCoreDispatcher;
+};
+
+#endif  // UTIL_WINRT_WINDOW_H

util/windows/winrt/WinRT_system_utils.cpp

+//
+// Copyright (c) 2015 The ANGLE Project Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+
+// WinRT_system_utils.cpp: Implementation of OS-specific functions for WinRT (Windows)
+
+#include "system_utils.h"
+
+#include <windows.h>
+#include <array>
+
+namespace angle
+{
+
+void SetLowPriorityProcess()
+{
+    // No equivalent to this in WinRT
+}
+
+}  // namespace angle