Remove ANGLE

This marks the end of EGL and OpenGL ES support on Windows.

The concepts of -opengl dynamic, -opengl desktop, QT_OPENGL=software,
etc. remain unchanged, with the exception of the disapperance of
everything ANGLE related.

CMake builds now work identically to qmake on Windows: they default to
'dynamic' OpenGL on Windows, unless -DINPUT_opengl=desktop is specified.

On Windows, Qt 6 is expected to default to the "dynamic" OpenGL model by
default, just like Qt 5.15. This can be changed by switching to "desktop"
OpenGL, which will link to opengl32 (publicly, so other libs and applications
will do so as well) and disallows using another OpenGL DLL.

The "dynamic" mode is essential still because the fallback to a software
rasterizer, such as the opengl32sw.dll we ship with the Qt packages,
has to to work exactly like in Qt 5, the removal of ANGLE does not
change this concept in any way (except of course that the middle option
of using ANGLE is now gone)

When it comes to the windows plugin's OpenGL blacklist feature, it works
like before and accepts the ANGLE/D3D related keywords. They will
then be ignored. Similarly, requesting QT_OPENGL=angle is ignored (but
will show a warning).

The D3D11 and DXGI configure time tests are removed: Qt 5.14 already
depends on D3D 11.1 and DXGI 1.3 headers being available unconditionally
on Win32 (in QRhi's D3D11 backend). No need to test for these.

[ChangeLog][Windows] ANGLE is no longer included with Qt. Dynamic OpenGL
builds work like before but ANGLE is no longer an option. OpenGL proper
or an alternative opengl32 implementation are the two remaining options
now. Attempting to set QT_OPENGL=angle or Qt::AA_UseOpenGLES will have
no effect on Windows.

Fixes: QTBUG-79103
Change-Id: Ia404e0d07f3fe191b27434d863c81180112ecb3b
Reviewed-by: Oliver Wolff <oliver.wolff@qt.io>

1 files changed, 0 insertions, 174 deletions

diff --git a/src/3rdparty/angle/src/libANGLE/SizedMRUCache.h b/src/3rdparty/angle/src/libANGLE/SizedMRUCache.h
deleted file mode 100644
index 6a608a697e..0000000000
--- a/src/3rdparty/angle/src/libANGLE/SizedMRUCache.h
+++ /dev/null
@@ -1,174 +0,0 @@
-//
-// Copyright 2017 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.
-//
-// SizedMRUCache.h: A hashing map that stores blobs of sized, untyped data.
-
-#ifndef LIBANGLE_SIZED_MRU_CACHE_H_
-#define LIBANGLE_SIZED_MRU_CACHE_H_
-
-#include <anglebase/containers/mru_cache.h>
-#include "common/third_party/smhasher/src/PMurHash.h"
-
-namespace angle
-{
-
-template <typename Key, typename Value>
-class SizedMRUCache final : angle::NonCopyable
-{
-  public:
-    SizedMRUCache(size_t maximumTotalSize)
-        : mMaximumTotalSize(maximumTotalSize),
-          mCurrentSize(0),
-          mStore(SizedMRUCacheStore::NO_AUTO_EVICT)
-    {
-    }
-
-    // Returns nullptr on failure.
-    const Value *put(const Key &key, Value &&value, size_t size)
-    {
-        if (size > mMaximumTotalSize)
-        {
-            return nullptr;
-        }
-
-        // Check for existing key.
-        eraseByKey(key);
-
-        auto retVal = mStore.Put(key, ValueAndSize(std::move(value), size));
-        mCurrentSize += size;
-
-        shrinkToSize(mMaximumTotalSize);
-
-        return &retVal->second.value;
-    }
-
-    bool get(const Key &key, const Value **valueOut)
-    {
-        const auto &iter = mStore.Get(key);
-        if (iter == mStore.end())
-        {
-            return false;
-        }
-        *valueOut = &iter->second.value;
-        return true;
-    }
-
-    bool getAt(size_t index, Key *keyOut, const Value **valueOut)
-    {
-        if (index < mStore.size())
-        {
-            auto it = mStore.begin();
-            std::advance(it, index);
-            *keyOut   = it->first;
-            *valueOut = &it->second.value;
-            return true;
-        }
-        *valueOut = nullptr;
-        return false;
-    }
-
-    bool empty() const { return mStore.empty(); }
-
-    void clear()
-    {
-        mStore.Clear();
-        mCurrentSize = 0;
-    }
-
-    bool eraseByKey(const Key &key)
-    {
-        // Check for existing key.
-        auto existing = mStore.Peek(key);
-        if (existing != mStore.end())
-        {
-            mCurrentSize -= existing->second.size;
-            mStore.Erase(existing);
-            return true;
-        }
-
-        return false;
-    }
-
-    size_t entryCount() const { return mStore.size(); }
-
-    size_t size() const { return mCurrentSize; }
-
-    // Also discards the cache contents.
-    void resize(size_t maximumTotalSize)
-    {
-        clear();
-        mMaximumTotalSize = maximumTotalSize;
-    }
-
-    // Reduce current memory usage.
-    size_t shrinkToSize(size_t limit)
-    {
-        size_t initialSize = mCurrentSize;
-
-        while (mCurrentSize > limit)
-        {
-            ASSERT(!mStore.empty());
-            auto iter = mStore.rbegin();
-            mCurrentSize -= iter->second.size;
-            mStore.Erase(iter);
-        }
-
-        return (initialSize - mCurrentSize);
-    }
-
-    size_t maxSize() const { return mMaximumTotalSize; }
-
-  private:
-    struct ValueAndSize
-    {
-        ValueAndSize() : value(), size(0) {}
-        ValueAndSize(Value &&value, size_t size) : value(std::move(value)), size(size) {}
-        ValueAndSize(ValueAndSize &&other) : ValueAndSize() { *this = std::move(other); }
-        ValueAndSize &operator=(ValueAndSize &&other)
-        {
-            std::swap(value, other.value);
-            std::swap(size, other.size);
-            return *this;
-        }
-
-        Value value;
-        size_t size;
-    };
-
-    using SizedMRUCacheStore = base::HashingMRUCache<Key, ValueAndSize>;
-
-    size_t mMaximumTotalSize;
-    size_t mCurrentSize;
-    SizedMRUCacheStore mStore;
-};
-
-// Helper function used in a few places.
-template <typename T>
-void TrimCache(size_t maxStates, size_t gcLimit, const char *name, T *cache)
-{
-    const size_t kGarbageCollectionLimit = maxStates / 2 + gcLimit;
-
-    if (cache->size() >= kGarbageCollectionLimit)
-    {
-        WARN() << "Overflowed the " << name << " cache limit of " << (maxStates / 2)
-               << " elements, removing the least recently used to make room.";
-        cache->ShrinkToSize(maxStates / 2);
-    }
-}
-
-// Computes a hash of struct "key". Any structs passed to this function must be multiples of
-// 4 bytes, since the PMurhHas32 method can only operate increments of 4-byte words.
-template <typename T>
-std::size_t ComputeGenericHash(const T &key)
-{
-    static const unsigned int seed = 0xABCDEF98;
-
-    // We can't support "odd" alignments.
-    static_assert(sizeof(key) % 4 == 0, "ComputeGenericHash requires aligned types");
-    return PMurHash32(seed, &key, sizeof(T));
-}
-
-}  // namespace angle
-#endif  // LIBANGLE_SIZED_MRU_CACHE_H_