WinRTWindow.cpp

Branch :

Show log
Commit
Author : Michael Spang
Date : 2019-01-21 18:09:15
Hash : 229fc83d
Message : Vulkan: Port renderer to Fuchsia (reland) Add DisplayVk and WindowSurfaceVk subclasses for Fuchsia to the vulkan renderer, as well as an implementation of OSWindow that renders fullscreen for the test suite. Disallow use of the vulkan loader from third_party as Fuchsia uses a fork of the loader and has not sent those changes upstream yet. Add a small wayland-inspired library libfuchsia-egl to provide a type "struct fuchsia_egl_window" to use as EGLNativeWindowType. This type combines a zx_handle_t to an image pipe channel and a surface size. Image pipes can only be used once to create a VkSurfaceKHR. This means we have to recreate the pipe in tests that call eglCreateWindowSurface more than once with a single OSWindow, or the second call will fail. Add a resetNativeWindow() method to accomplish this. Reland disabling -Wextra-semi. BUG=angleproject:2475 TEST=angle_end2end_tests on Fuchsia Change-Id: Ie91715bcd760c6c04d4b8a02a91daa71e32ee30c Reviewed-on: https://chromium-review.googlesource.com/c/1467603 Commit-Queue: Michael Spang <spang@chromium.org> Reviewed-by: Jamie Madill <jmadill@chromium.org>

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 <windows.applicationmodel.core.h>
#include <windows.ui.xaml.h>
#include <wrl.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();
}

void WinRTWindow::resetNativeWindow() {}

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 *OSWindow::New()
{
    return new WinRTWindow();
}

kc3-lang/angle/util/windows/winrt/WinRTWindow.cpp

Commit

kc3-lang/angle /util/windows/winrt/WinRTWindow.cpp