AvaloniaUI
/
angle
зеркало из https://github.com/AvaloniaUI/angle.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Support Desktop OpenGL context creation in end2end tests 

Validation of Desktop GL versions and profile masks is unimplemented.

Bug: angleproject:7360
Change-Id: Ifae94215b6aada895c2b02318a1d05c9515e9b96
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3664916
Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
Commit-Queue: Geoff Lang <geofflang@chromium.org>
Reviewed-by: Cody Northrop <cnorthrop@google.com>
This commit is contained in:
Geoff Lang 2022-05-24 12:40:16 -04:00 коммит произвёл Angle LUCI CQ
Родитель 61bcba8989
Коммит 785353fd35
35 изменённых файлов: 593 добавлений и 266 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

13
samples/sample_util/SampleApplication.cpp
Просмотреть файл

@ -77,8 +77,10 @@ bool IsGLExtensionEnabled(const std::string &extName)
SampleApplication::SampleApplication(std::string name,
int argc,
char **argv,
EGLint glesMajorVersion,
EGLint glesMinorVersion,
EGLenum clientType,
EGLint glMajorVersion,
EGLint glMinorVersion,
EGLint profileMask,
uint32_t width,
uint32_t height)
: mName(std::move(name)),
@ -115,11 +117,11 @@ SampleApplication::SampleApplication(std::string name,
if (useNativeGL)
{
#if defined(ANGLE_PLATFORM_WINDOWS)
mGLWindow = WGLWindow::New(glesMajorVersion, glesMinorVersion);
mGLWindow = WGLWindow::New(clientType, glMajorVersion, glMinorVersion, profileMask);
mEntryPointsLib.reset(angle::OpenSharedLibrary("opengl32", angle::SearchType::SystemDir));
mDriverType = angle::GLESDriverType::SystemWGL;
#else
mGLWindow = EGLWindow::New(glesMajorVersion, glesMinorVersion);
mGLWindow = EGLWindow::New(clientType, glMajorVersion, glMinorVersion, profileMask);
mEntryPointsLib.reset(angle::OpenSharedLibraryWithExtension(
angle::GetNativeEGLLibraryNameWithExtension(), angle::SearchType::SystemDir));
mDriverType = angle::GLESDriverType::SystemEGL;
@ -127,7 +129,8 @@ SampleApplication::SampleApplication(std::string name,
}
else
{
mGLWindow = mEGLWindow = EGLWindow::New(glesMajorVersion, glesMinorVersion);
mGLWindow = mEGLWindow =
EGLWindow::New(clientType, glMajorVersion, glMinorVersion, profileMask);
mEntryPointsLib.reset(
angle::OpenSharedLibrary(ANGLE_EGL_LIBRARY_NAME, angle::SearchType::ModuleDir));
}

10
samples/sample_util/SampleApplication.h
Просмотреть файл

@ -34,10 +34,12 @@ class SampleApplication
SampleApplication(std::string name,
int argc,
char **argv,
EGLint glesMajorVersion = 2,
EGLint glesMinorVersion = 0,
uint32_t width = 1280,
uint32_t height = 720);
EGLenum clientType = EGL_OPENGL_ES_API,
EGLint glMajorVersion = 2,
EGLint glMinorVersion = 0,
EGLint profileMask = 0,
uint32_t width = 1280,
uint32_t height = 720);
virtual ~SampleApplication();
virtual bool initialize();

1
src/compiler/translator/SymbolTable.h
Просмотреть файл

@ -313,6 +313,7 @@ class TSymbolTable : angle::NonCopyable, TSymbolTableBase
{
return mResources.UBOArgumentBufferBindingIndex;
}
ShShaderSpec getShaderSpec() const { return mShaderSpec; }
private:
friend class TSymbolUniqueId;

5
src/compiler/translator/tree_util/DriverUniform.cpp
Просмотреть файл

@ -283,8 +283,9 @@ TIntermTyped *DriverUniform::getHalfRenderArea() const
TIntermTyped *DriverUniform::getFlipXY(TSymbolTable *symbolTable, DriverUniformFlip stage) const
{
TIntermTyped *flipXY = createDriverUniformRef(kFlipXY);
TIntermTyped *values =
CreateBuiltInUnaryFunctionCallNode("unpackSnorm4x8", flipXY, *symbolTable, 310);
TIntermTyped *values = CreateBuiltInUnaryFunctionCallNode(
"unpackSnorm4x8", flipXY, *symbolTable,
GetESSLOrGLSLVersion(symbolTable->getShaderSpec(), 310, 400));
if (stage == DriverUniformFlip::Fragment)
{

5
src/compiler/translator/tree_util/IntermNode_util.cpp
Просмотреть файл

@ -376,6 +376,11 @@ TIntermTyped *CreateBuiltInUnaryFunctionCallNode(const char *name,
return CreateBuiltInFunctionCallNode(name, &seq, symbolTable, shaderVersion);
}
int GetESSLOrGLSLVersion(ShShaderSpec spec, int esslVersion, int glslVersion)
{
return IsDesktopGLSpec(spec) ? glslVersion : esslVersion;
}
// Returns true if a block ends in a branch (break, continue, return, etc). This is only correct
// after PruneNoOps, because it expects empty blocks after a branch to have been already pruned,
// i.e. a block can only end in a branch if its last statement is a branch or is a block ending in

2
src/compiler/translator/tree_util/IntermNode_util.h
Просмотреть файл

@ -91,6 +91,8 @@ TIntermTyped *CreateBuiltInUnaryFunctionCallNode(const char *name,
const TSymbolTable &symbolTable,
int shaderVersion);
int GetESSLOrGLSLVersion(ShShaderSpec spec, int esslVersion, int glslVersion);
inline void GetSwizzleIndex(TVector<int> *indexOut) {}
template <typename T, typename... ArgsT>

15
src/libANGLE/Compiler.cpp
Просмотреть файл

@ -27,12 +27,20 @@ size_t gActiveCompilers = 0;
ShShaderSpec SelectShaderSpec(GLint majorVersion,
GLint minorVersion,
bool isWebGL,
EGLenum clientType)
EGLenum clientType,
EGLint profileMask)
{
// For Desktop GL
if (clientType == EGL_OPENGL_API)
{
return SH_GL_COMPATIBILITY_SPEC;
if ((profileMask & EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT) != 0)
{
return SH_GL_CORE_SPEC;
}
else
{
return SH_GL_COMPATIBILITY_SPEC;
}
}
if (majorVersion >= 3)
@ -67,7 +75,8 @@ Compiler::Compiler(rx::GLImplFactory *implFactory, const State &state, egl::Disp
mSpec(SelectShaderSpec(state.getClientMajorVersion(),
state.getClientMinorVersion(),
state.isWebGL(),
state.getClientType())),
state.getClientType(),
state.getProfileMask())),
mOutputType(mImplementation->getTranslatorOutputType()),
mResources()
{

6
src/libANGLE/Context.cpp
Просмотреть файл

@ -169,6 +169,11 @@ Version GetClientVersion(egl::Display *display, const egl::AttributeMap &attribs
}
}
EGLint GetProfileMask(const egl::AttributeMap &attribs)
{
return attribs.getAsInt(EGL_CONTEXT_OPENGL_PROFILE_MASK, EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT);
}
GLenum GetResetStrategy(const egl::AttributeMap &attribs)
{
EGLAttrib resetStrategyExt =
@ -444,6 +449,7 @@ Context::Context(egl::Display *display,
&mOverlay,
clientType,
GetClientVersion(display, attribs),
GetProfileMask(attribs),
GetDebug(attribs),
GetBindGeneratesResource(attribs),
GetClientArraysEnabled(attribs),

2
src/libANGLE/State.cpp
Просмотреть файл

@ -335,6 +335,7 @@ State::State(const State *shareContextState,
const OverlayType *overlay,
const EGLenum clientType,
const Version &clientVersion,
EGLint profileMask,
bool debug,
bool bindGeneratesResourceCHROMIUM,
bool clientArraysEnabled,
@ -344,6 +345,7 @@ State::State(const State *shareContextState,
bool hasProtectedContent)
: mID({gIDCounter++}),
mClientType(clientType),
mProfileMask(profileMask),
mContextPriority(contextPriority),
mHasProtectedContent(hasProtectedContent),
mIsDebugContext(debug),

3
src/libANGLE/State.h
Просмотреть файл

@ -94,6 +94,7 @@ class State : angle::NonCopyable
const OverlayType *overlay,
const EGLenum clientType,
const Version &clientVersion,
EGLint profileMask,
bool debug,
bool bindGeneratesResourceCHROMIUM,
bool clientArraysEnabled,
@ -109,6 +110,7 @@ class State : angle::NonCopyable
// Getters
ContextID getContextID() const { return mID; }
EGLenum getClientType() const { return mClientType; }
EGLint getProfileMask() const { return mProfileMask; }
EGLenum getContextPriority() const { return mContextPriority; }
bool hasProtectedContent() const { return mHasProtectedContent; }
bool isDebugContext() const { return mIsDebugContext; }
@ -973,6 +975,7 @@ class State : angle::NonCopyable
ContextID mID;
EGLenum mClientType;
EGLint mProfileMask;
EGLenum mContextPriority;
bool mHasProtectedContent;
bool mIsDebugContext;

16
src/libANGLE/capture/FrameCapture.cpp
Просмотреть файл

@ -6714,10 +6714,10 @@ void FrameCaptureShared::runMidExecutionCapture(const gl::Context *mainContext)
shareGroup->finishAllContexts();
const gl::State &contextState = mainContext->getState();
gl::State mainContextReplayState(nullptr, nullptr, nullptr, nullptr, nullptr, EGL_OPENGL_ES_API,
contextState.getClientVersion(), false, true, true, true,
false, EGL_CONTEXT_PRIORITY_MEDIUM_IMG,
contextState.hasProtectedContent());
gl::State mainContextReplayState(
nullptr, nullptr, nullptr, nullptr, nullptr, contextState.getClientType(),
contextState.getClientVersion(), contextState.getProfileMask(), false, true, true, true,
false, EGL_CONTEXT_PRIORITY_MEDIUM_IMG, contextState.hasProtectedContent());
mainContextReplayState.initializeForCapture(mainContext);
CaptureShareGroupMidExecutionSetup(mainContext, &mShareGroupSetupCalls, &mResourceTracker,
@ -6741,10 +6741,12 @@ void FrameCaptureShared::runMidExecutionCapture(const gl::Context *mainContext)
}
else
{
const gl::State &shareContextState = shareContext->getState();
gl::State auxContextReplayState(
nullptr, nullptr, nullptr, nullptr, nullptr, EGL_OPENGL_ES_API,
shareContext->getState().getClientVersion(), false, true, true, true, false,
EGL_CONTEXT_PRIORITY_MEDIUM_IMG, shareContext->getState().hasProtectedContent());
nullptr, nullptr, nullptr, nullptr, nullptr, shareContextState.getClientType(),
shareContextState.getClientVersion(), shareContextState.getProfileMask(), false,
true, true, true, false, EGL_CONTEXT_PRIORITY_MEDIUM_IMG,
shareContextState.hasProtectedContent());
auxContextReplayState.initializeForCapture(shareContext);
CaptureMidExecutionSetup(shareContext, &frameCapture->getSetupCalls(),

170
src/libANGLE/validationEGL.cpp
Просмотреть файл

@ -1452,9 +1452,13 @@ bool ValidateCreateContextAttribute(const ValidationContext *val,
break;
case EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR:
// Only valid for OpenGL (non-ES) contexts
val->setError(EGL_BAD_ATTRIBUTE);
return false;
if (val->eglThread->getAPI() != EGL_OPENGL_API)
{
// Only valid for OpenGL (non-ES) contexts
val->setError(EGL_BAD_ATTRIBUTE, "OpenGL profile mask requires an OpenGL context.");
return false;
}
break;
case EGL_CONTEXT_OPENGL_ROBUST_ACCESS_EXT:
if (!display->getExtensions().createContextRobustness)
@ -1692,6 +1696,19 @@ bool ValidateCreateContextAttributeValue(const ValidationContext *val,
case EGL_CONTEXT_VIRTUALIZATION_GROUP_ANGLE:
break;
case EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR:
{
constexpr EGLint kValidProfileMaskFlags =
(EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT |
EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT);
if ((value & ~kValidProfileMaskFlags) != 0)
{
val->setError(EGL_BAD_ATTRIBUTE, "Invalid OpenGL profile mask.");
return false;
}
break;
}
case EGL_CONTEXT_FLAGS_KHR:
{
// Note: EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE_BIT_KHR does not apply to ES
@ -2329,78 +2346,93 @@ bool ValidateCreateContext(const ValidationContext *val,
// Get the requested client version (default is 1) and check it is 2 or 3.
EGLAttrib clientMajorVersion = attributes.get(EGL_CONTEXT_CLIENT_VERSION, 1);
EGLAttrib clientMinorVersion = attributes.get(EGL_CONTEXT_MINOR_VERSION, 0);
EGLenum api = val->eglThread->getAPI();
switch (clientMajorVersion)
switch (api)
{
case 1:
if (clientMinorVersion != 0 && clientMinorVersion != 1)
case EGL_OPENGL_ES_API:
switch (clientMajorVersion)
{
val->setError(EGL_BAD_ATTRIBUTE);
return false;
}
if (configuration == EGL_NO_CONFIG_KHR)
{
val->setError(EGL_BAD_MATCH);
return false;
}
if ((configuration != EGL_NO_CONFIG_KHR) &&
!(configuration->renderableType & EGL_OPENGL_ES_BIT))
{
val->setError(EGL_BAD_MATCH);
return false;
case 1:
if (clientMinorVersion != 0 && clientMinorVersion != 1)
{
val->setError(EGL_BAD_ATTRIBUTE);
return false;
}
if (configuration == EGL_NO_CONFIG_KHR)
{
val->setError(EGL_BAD_MATCH);
return false;
}
if ((configuration != EGL_NO_CONFIG_KHR) &&
!(configuration->renderableType & EGL_OPENGL_ES_BIT))
{
val->setError(EGL_BAD_MATCH);
return false;
}
break;
case 2:
if (clientMinorVersion != 0)
{
val->setError(EGL_BAD_ATTRIBUTE);
return false;
}
if ((configuration != EGL_NO_CONFIG_KHR) &&
!(configuration->renderableType & EGL_OPENGL_ES2_BIT))
{
val->setError(EGL_BAD_MATCH);
return false;
}
break;
case 3:
if (clientMinorVersion < 0 || clientMinorVersion > 2)
{
val->setError(EGL_BAD_ATTRIBUTE);
return false;
}
if ((configuration != EGL_NO_CONFIG_KHR) &&
!(configuration->renderableType & EGL_OPENGL_ES3_BIT))
{
val->setError(EGL_BAD_MATCH);
return false;
}
if (display->getMaxSupportedESVersion() <
gl::Version(static_cast<GLuint>(clientMajorVersion),
static_cast<GLuint>(clientMinorVersion)))
{
gl::Version max = display->getMaxSupportedESVersion();
val->setError(EGL_BAD_ATTRIBUTE,
"Requested GLES version (%" PRIxPTR ".%" PRIxPTR
") is greater than "
"max supported (%d, %d).",
clientMajorVersion, clientMinorVersion, max.major, max.minor);
return false;
}
if ((attributes.get(EGL_CONTEXT_WEBGL_COMPATIBILITY_ANGLE, EGL_FALSE) ==
EGL_TRUE) &&
(clientMinorVersion > 1))
{
val->setError(EGL_BAD_ATTRIBUTE,
"Requested GLES version (%" PRIxPTR ".%" PRIxPTR
") is greater than "
"max supported 3.1 for WebGL.",
clientMajorVersion, clientMinorVersion);
return false;
}
break;
default:
val->setError(EGL_BAD_ATTRIBUTE);
return false;
}
break;
case 2:
if (clientMinorVersion != 0)
{
val->setError(EGL_BAD_ATTRIBUTE);
return false;
}
if ((configuration != EGL_NO_CONFIG_KHR) &&
!(configuration->renderableType & EGL_OPENGL_ES2_BIT))
{
val->setError(EGL_BAD_MATCH);
return false;
}
break;
case 3:
if (clientMinorVersion < 0 || clientMinorVersion > 2)
{
val->setError(EGL_BAD_ATTRIBUTE);
return false;
}
if ((configuration != EGL_NO_CONFIG_KHR) &&
!(configuration->renderableType & EGL_OPENGL_ES3_BIT))
{
val->setError(EGL_BAD_MATCH);
return false;
}
if (display->getMaxSupportedESVersion() <
gl::Version(static_cast<GLuint>(clientMajorVersion),
static_cast<GLuint>(clientMinorVersion)))
{
gl::Version max = display->getMaxSupportedESVersion();
val->setError(EGL_BAD_ATTRIBUTE,
"Requested GLES version (%" PRIxPTR ".%" PRIxPTR
") is greater than "
"max supported (%d, %d).",
clientMajorVersion, clientMinorVersion, max.major, max.minor);
return false;
}
if ((attributes.get(EGL_CONTEXT_WEBGL_COMPATIBILITY_ANGLE, EGL_FALSE) == EGL_TRUE) &&
(clientMinorVersion > 1))
{
val->setError(EGL_BAD_ATTRIBUTE,
"Requested GLES version (%" PRIxPTR ".%" PRIxPTR
") is greater than "
"max supported 3.1 for WebGL.",
clientMajorVersion, clientMinorVersion);
return false;
}
case EGL_OPENGL_API:
// TODO: validate desktop OpenGL versions and profile mask
break;
default:
val->setError(EGL_BAD_ATTRIBUTE);
val->setError(EGL_BAD_MATCH, "Unsupported API.");
return false;
}
@ -4930,12 +4962,12 @@ bool ValidateBindAPI(const ValidationContext *val, const EGLenum api)
{
switch (api)
{
case EGL_OPENGL_ES_API:
case EGL_OPENGL_API:
break;
case EGL_OPENVG_API:
val->setError(EGL_BAD_PARAMETER);
return false; // Not supported by this implementation
case EGL_OPENGL_ES_API:
break;
default:
val->setError(EGL_BAD_PARAMETER);
return false;

4
src/tests/BUILD.gn
Просмотреть файл

@ -84,6 +84,10 @@ angle_static_library("angle_test_expectations") {
config("angle_common_test_utils_config") {
include_dirs = [ "." ]
defines = []
if (angle_enable_gl_desktop) {
defines += [ "ANGLE_ENABLE_OPENGL_DESKTOP" ]
}
}
template("angle_common_test_utils") {

1
src/tests/angle_end2end_tests.gni
Просмотреть файл

@ -60,6 +60,7 @@ angle_end2end_tests_sources = [
"gl_tests/DebugTest.cpp",
"gl_tests/DepthStencilFormatsTest.cpp",
"gl_tests/DepthStencilTest.cpp",
"gl_tests/DesktopGLSLTest.cpp",
"gl_tests/DifferentStencilMasksTest.cpp",
"gl_tests/DiscardFramebufferEXTTest.cpp",
"gl_tests/DrawBaseVertexBaseInstanceTest.cpp",

9
src/tests/capture_replay_tests/CaptureReplayTests.cpp
Просмотреть файл

@ -186,8 +186,13 @@ class CaptureReplayTests
if (!mEGLWindow)
{
mEGLWindow = EGLWindow::New(traceInfo.contextClientMajorVersion,
traceInfo.contextClientMinorVersion);
// TODO: to support desktop OpenGL traces, capture the client api and profile mask in
// TraceInfo
const EGLenum testClientAPI = EGL_OPENGL_ES_API;
const EGLint testProfileMask = 0;
mEGLWindow = EGLWindow::New(testClientAPI, traceInfo.contextClientMajorVersion,
traceInfo.contextClientMinorVersion, testProfileMask);
}
ConfigParameters configParams;

5
src/tests/egl_tests/EGLContextCompatibilityTest.cpp
Просмотреть файл

@ -112,7 +112,8 @@ std::vector<EGLConfig> GetConfigs(EGLDisplay display)
PlatformParameters FromRenderer(EGLint renderer)
{
return WithNoFixture(PlatformParameters(2, 0, EGLPlatformParameters(renderer)));
return WithNoFixture(
PlatformParameters(EGL_OPENGL_ES_API, 2, 0, 0, EGLPlatformParameters(renderer)));
}
std::string EGLConfigName(EGLDisplay display, EGLConfig config)
@ -180,7 +181,7 @@ class EGLContextCompatibilityTest : public ANGLETestBase, public testing::Test
EGLint dispattrs[] = {EGL_PLATFORM_ANGLE_TYPE_ANGLE, mRenderer, EGL_NONE};
mDisplay = eglGetPlatformDisplayEXT(
EGL_PLATFORM_ANGLE_ANGLE, reinterpret_cast<void *>(EGL_DEFAULT_DISPLAY), dispattrs);
EGL_PLATFORM_ANGLE_ANGLE, reinterpret_cast<void *>(EGL_DEFAULT_DISPLAY), dispattrs);
ASSERT_TRUE(mDisplay != EGL_NO_DISPLAY);
ASSERT_TRUE(eglInitialize(mDisplay, nullptr, nullptr) == EGL_TRUE);

55
src/tests/gl_tests/DesktopGLSLTest.cpp Normal file
Просмотреть файл

@ -0,0 +1,55 @@
//
// Copyright 2022 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.
//
#include "test_utils/ANGLETest.h"
#include "test_utils/gl_raii.h"
#include "util/shader_utils.h"
namespace angle
{
class DesktopGLSLTest : public ANGLETest<>
{
protected:
DesktopGLSLTest()
{
setWindowWidth(128);
setWindowHeight(128);
setConfigRedBits(8);
setConfigGreenBits(8);
setConfigBlueBits(8);
setConfigAlphaBits(8);
}
};
// Simple test case of compiling a desktop OpenGL shader to verify that the shader compiler
// initializes.
TEST_P(DesktopGLSLTest, BasicCompilation)
{
const char kVS[] = R"(#version 150
in vec4 position;
void main()
{
gl_Position = position;
})";
const char kFS[] = R"(#version 150
out vec4 fragColor;
void main()
{
fragColor = vec4(1.0, 0.5, 0.2, 1.0);
})";
ANGLE_GL_PROGRAM(testProgram, kVS, kFS);
}
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(DesktopGLSLTest);
ANGLE_INSTANTIATE_TEST_GL32_CORE(DesktopGLSLTest);
} // namespace angle

24
src/tests/gl_tests/FramebufferMultiviewTest.cpp
Просмотреть файл

@ -768,18 +768,18 @@ TEST_P(FramebufferMultiviewTest, NegativeMultisampledFramebufferTest)
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(FramebufferMultiviewTest);
ANGLE_INSTANTIATE_TEST(FramebufferMultiviewTest,
VertexShaderOpenGL(3, 0, ExtensionName::multiview),
VertexShaderVulkan(3, 0, ExtensionName::multiview),
GeomShaderD3D11(3, 0, ExtensionName::multiview),
VertexShaderOpenGL(3, 0, ExtensionName::multiview2),
VertexShaderVulkan(3, 0, ExtensionName::multiview2),
GeomShaderD3D11(3, 0, ExtensionName::multiview2));
VertexShaderOpenGL(EGL_OPENGL_ES_API, 3, 0, 0, ExtensionName::multiview),
VertexShaderVulkan(EGL_OPENGL_ES_API, 3, 0, 0, ExtensionName::multiview),
GeomShaderD3D11(EGL_OPENGL_ES_API, 3, 0, 0, ExtensionName::multiview),
VertexShaderOpenGL(EGL_OPENGL_ES_API, 3, 0, 0, ExtensionName::multiview2),
VertexShaderVulkan(EGL_OPENGL_ES_API, 3, 0, 0, ExtensionName::multiview2),
GeomShaderD3D11(EGL_OPENGL_ES_API, 3, 0, 0, ExtensionName::multiview2));
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(FramebufferMultiviewLayeredClearTest);
ANGLE_INSTANTIATE_TEST(FramebufferMultiviewLayeredClearTest,
VertexShaderOpenGL(3, 0, ExtensionName::multiview),
VertexShaderVulkan(3, 0, ExtensionName::multiview),
GeomShaderD3D11(3, 0, ExtensionName::multiview),
VertexShaderOpenGL(3, 0, ExtensionName::multiview2),
VertexShaderVulkan(3, 0, ExtensionName::multiview2),
GeomShaderD3D11(3, 0, ExtensionName::multiview2));
VertexShaderOpenGL(EGL_OPENGL_ES_API, 3, 0, 0, ExtensionName::multiview),
VertexShaderVulkan(EGL_OPENGL_ES_API, 3, 0, 0, ExtensionName::multiview),
GeomShaderD3D11(EGL_OPENGL_ES_API, 3, 0, 0, ExtensionName::multiview),
VertexShaderOpenGL(EGL_OPENGL_ES_API, 3, 0, 0, ExtensionName::multiview2),
VertexShaderVulkan(EGL_OPENGL_ES_API, 3, 0, 0, ExtensionName::multiview2),
GeomShaderD3D11(EGL_OPENGL_ES_API, 3, 0, 0, ExtensionName::multiview2));

1
src/tests/gl_tests/GLSLTest.cpp
Просмотреть файл

@ -15703,6 +15703,7 @@ void main()
ANGLE_GL_PROGRAM(testProgram, kVS, kFS);
}
} // anonymous namespace
ANGLE_INSTANTIATE_TEST_ES2_AND_ES3_AND(GLSLTest,

39
src/tests/gl_tests/MultiviewDrawTest.cpp
Просмотреть файл

@ -2241,46 +2241,53 @@ TEST_P(MultiviewRenderTest, FlatInterpolation2)
MultiviewRenderTestParams VertexShaderOpenGL(ExtensionName multiviewExtension)
{
return MultiviewRenderTestParams(0, VertexShaderOpenGL(3, 0, multiviewExtension));
return MultiviewRenderTestParams(
0, VertexShaderOpenGL(EGL_OPENGL_ES_API, 3, 0, 0, multiviewExtension));
}
MultiviewRenderTestParams VertexShaderVulkan(ExtensionName multiviewExtension)
{
return MultiviewRenderTestParams(0, VertexShaderVulkan(3, 0, multiviewExtension));
return MultiviewRenderTestParams(
0, VertexShaderVulkan(EGL_OPENGL_ES_API, 3, 0, 0, multiviewExtension));
}
MultiviewRenderTestParams GeomShaderD3D11(ExtensionName multiviewExtension)
{
return MultiviewRenderTestParams(0, GeomShaderD3D11(3, 0, multiviewExtension));
return MultiviewRenderTestParams(
0, GeomShaderD3D11(EGL_OPENGL_ES_API, 3, 0, 0, multiviewExtension));
}
MultiviewRenderTestParams VertexShaderD3D11(ExtensionName multiviewExtension)
{
return MultiviewRenderTestParams(0, VertexShaderD3D11(3, 0, multiviewExtension));
return MultiviewRenderTestParams(
0, VertexShaderD3D11(EGL_OPENGL_ES_API, 3, 0, 0, multiviewExtension));
}
MultiviewRenderTestParams MultisampledVertexShaderOpenGL(ExtensionName multiviewExtension)
{
return MultiviewRenderTestParams(2, VertexShaderOpenGL(3, 1, multiviewExtension));
return MultiviewRenderTestParams(
2, VertexShaderOpenGL(EGL_OPENGL_ES_API, 3, 1, 0, multiviewExtension));
}
MultiviewRenderTestParams MultisampledVertexShaderVulkan(ExtensionName multiviewExtension)
{
return MultiviewRenderTestParams(2, VertexShaderVulkan(3, 1, multiviewExtension));
return MultiviewRenderTestParams(
2, VertexShaderVulkan(EGL_OPENGL_ES_API, 3, 1, 0, multiviewExtension));
}
MultiviewRenderTestParams MultisampledVertexShaderD3D11(ExtensionName multiviewExtension)
{
return MultiviewRenderTestParams(2, VertexShaderD3D11(3, 1, multiviewExtension));
return MultiviewRenderTestParams(
2, VertexShaderD3D11(EGL_OPENGL_ES_API, 3, 1, 0, multiviewExtension));
}
#define ALL_VERTEX_SHADER_CONFIGS(minor) \
VertexShaderOpenGL(3, minor, ExtensionName::multiview), \
VertexShaderVulkan(3, minor, ExtensionName::multiview), \
VertexShaderD3D11(3, minor, ExtensionName::multiview), \
VertexShaderOpenGL(3, minor, ExtensionName::multiview2), \
VertexShaderVulkan(3, minor, ExtensionName::multiview2), \
VertexShaderD3D11(3, minor, ExtensionName::multiview2)
#define ALL_VERTEX_SHADER_CONFIGS(minor) \
VertexShaderOpenGL(EGL_OPENGL_ES_API, 3, minor, 0, ExtensionName::multiview), \
VertexShaderVulkan(EGL_OPENGL_ES_API, 3, minor, 0, ExtensionName::multiview), \
VertexShaderD3D11(EGL_OPENGL_ES_API, 3, minor, 0, ExtensionName::multiview), \
VertexShaderOpenGL(EGL_OPENGL_ES_API, 3, minor, 0, ExtensionName::multiview2), \
VertexShaderVulkan(EGL_OPENGL_ES_API, 3, minor, 0, ExtensionName::multiview2), \
VertexShaderD3D11(EGL_OPENGL_ES_API, 3, minor, 0, ExtensionName::multiview2)
#define ALL_SINGLESAMPLE_CONFIGS() \
VertexShaderOpenGL(ExtensionName::multiview), VertexShaderVulkan(ExtensionName::multiview), \
@ -2314,8 +2321,8 @@ ANGLE_INSTANTIATE_TEST(MultiviewOcclusionQueryTest, ALL_SINGLESAMPLE_CONFIGS());
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(MultiviewProgramGenerationTest);
ANGLE_INSTANTIATE_TEST(MultiviewProgramGenerationTest,
ALL_VERTEX_SHADER_CONFIGS(0),
GeomShaderD3D11(3, 0, ExtensionName::multiview),
GeomShaderD3D11(3, 0, ExtensionName::multiview2));
GeomShaderD3D11(EGL_OPENGL_ES_API, 3, 0, 0, ExtensionName::multiview),
GeomShaderD3D11(EGL_OPENGL_ES_API, 3, 0, 0, ExtensionName::multiview2));
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(MultiviewRenderPrimitiveTest);
ANGLE_INSTANTIATE_TEST(MultiviewRenderPrimitiveTest, ALL_SINGLESAMPLE_CONFIGS());

3
src/tests/gl_tests/ProgramBinaryTest.cpp
Просмотреть файл

@ -1403,7 +1403,8 @@ class ProgramBinariesAcrossPlatforms : public testing::TestWithParam<PlatformsWi
EGLWindow *createAndInitEGLWindow(angle::PlatformParameters &param)
{
EGLWindow *eglWindow = EGLWindow::New(param.majorVersion, param.minorVersion);
EGLWindow *eglWindow = EGLWindow::New(param.clientType, param.majorVersion,
param.minorVersion, param.profileMask);
ConfigParameters configParams;
bool result = eglWindow->initializeGL(mOSWindow, mEntryPointsLib.get(), param.driver,
param.eglParameters, configParams);

24
src/tests/gl_tests/RendererTest.cpp
Просмотреть файл

@ -131,23 +131,14 @@ TEST_P(RendererTest, RequestedRendererCreated)
EGLint glesMajorVersion = GetParam().majorVersion;
EGLint glesMinorVersion = GetParam().minorVersion;
// Ensure that the renderer string contains the requested version number
if (glesMajorVersion == 3 && glesMinorVersion == 1)
std::ostringstream expectedVersionString;
if (GetParam().clientType == EGL_OPENGL_ES_API)
{
ASSERT_NE(versionString.find(std::string("es 3.1")), std::string::npos);
}
else if (glesMajorVersion == 3 && glesMinorVersion == 0)
{
ASSERT_NE(versionString.find(std::string("es 3.0")), std::string::npos);
}
else if (glesMajorVersion == 2 && glesMinorVersion == 0)
{
ASSERT_NE(versionString.find(std::string("es 2.0")), std::string::npos);
}
else
{
FAIL() << "Unhandled GL ES client version.";
expectedVersionString << "es ";
}
expectedVersionString << glesMajorVersion << "." << glesMinorVersion;
ASSERT_NE(versionString.find(expectedVersionString.str()), std::string::npos);
ASSERT_GL_NO_ERROR();
ASSERT_EGL_SUCCESS();
@ -172,5 +163,6 @@ TEST_P(RendererTest, SimpleOperation)
// Select configurations (e.g. which renderer, which GLES major version) these tests should be run
// against.
ANGLE_INSTANTIATE_TEST_ES2_AND_ES3_AND_ES31_AND_NULL(RendererTest);
ANGLE_INSTANTIATE_TEST_ES2_AND_ES3_AND_ES31_AND_NULL_AND(RendererTest,
ANGLE_ALL_TEST_PLATFORMS_GL32_CORE);
} // anonymous namespace

4
src/tests/gl_tests/RobustBufferAccessBehaviorTest.cpp
Просмотреть файл

@ -46,7 +46,9 @@ class RobustBufferAccessBehaviorTest : public ANGLETest<>
Library *driverLib = ANGLETestEnvironment::GetDriverLibrary(GLESDriverType::AngleEGL);
mEGLWindow = EGLWindow::New(GetParam().majorVersion, GetParam().minorVersion);
const PlatformParameters &params = GetParam();
mEGLWindow = EGLWindow::New(params.clientType, params.majorVersion, params.minorVersion,
params.profileMask);
if (!mEGLWindow->initializeDisplay(mOSWindow, driverLib, GLESDriverType::AngleEGL,
GetParam().eglParameters))
{

9
src/tests/perf_tests/ANGLEPerfTest.cpp
Просмотреть файл

@ -731,12 +731,14 @@ ANGLERenderTest::ANGLERenderTest(const std::string &name,
switch (testParams.driver)
{
case GLESDriverType::AngleEGL:
mGLWindow = EGLWindow::New(testParams.majorVersion, testParams.minorVersion);
mGLWindow = EGLWindow::New(testParams.clientType, testParams.majorVersion,
testParams.minorVersion, testParams.profileMask);
mEntryPointsLib.reset(OpenSharedLibrary(ANGLE_EGL_LIBRARY_NAME, SearchType::ModuleDir));
break;
case GLESDriverType::SystemEGL:
#if defined(ANGLE_USE_UTIL_LOADER) && !defined(ANGLE_PLATFORM_WINDOWS)
mGLWindow = EGLWindow::New(testParams.majorVersion, testParams.minorVersion);
mGLWindow = EGLWindow::New(testParams.clientType, testParams.majorVersion,
testParams.minorVersion, testParams.profileMask);
mEntryPointsLib.reset(OpenSharedLibraryWithExtension(
GetNativeEGLLibraryNameWithExtension(), SearchType::SystemDir));
#else
@ -745,7 +747,8 @@ ANGLERenderTest::ANGLERenderTest(const std::string &name,
break;
case GLESDriverType::SystemWGL:
#if defined(ANGLE_USE_UTIL_LOADER) && defined(ANGLE_PLATFORM_WINDOWS)
mGLWindow = WGLWindow::New(testParams.majorVersion, testParams.minorVersion);
mGLWindow = WGLWindow::New(testParams.clientType, testParams.majorVersion,
testParams.minorVersion, testParams.profileMask);
mEntryPointsLib.reset(OpenSharedLibrary("opengl32", SearchType::SystemDir));
#else
skipTest("WGL driver not available.");

3
src/tests/test_utils/ANGLETest.cpp
Просмотреть файл

@ -553,7 +553,8 @@ void ANGLETestBase::initOSWindow()
case GLESDriverType::SystemEGL:
{
mFixture->eglWindow =
EGLWindow::New(mCurrentParams->majorVersion, mCurrentParams->minorVersion);
EGLWindow::New(mCurrentParams->clientType, mCurrentParams->majorVersion,
mCurrentParams->minorVersion, mCurrentParams->profileMask);
break;
}

30
src/tests/test_utils/MultiviewTest.cpp
Просмотреть файл

@ -231,36 +231,44 @@ std::ostream &operator<<(std::ostream &os, const MultiviewImplementationParams &
return os;
}
MultiviewImplementationParams VertexShaderOpenGL(GLint majorVersion,
MultiviewImplementationParams VertexShaderOpenGL(EGLenum clientType,
GLint majorVersion,
GLint minorVersion,
EGLint profileMask,
ExtensionName multiviewExtension)
{
return MultiviewImplementationParams(majorVersion, minorVersion, egl_platform::OPENGL(),
multiviewExtension);
return MultiviewImplementationParams(clientType, majorVersion, minorVersion, profileMask,
egl_platform::OPENGL(), multiviewExtension);
}
MultiviewImplementationParams VertexShaderVulkan(GLint majorVersion,
MultiviewImplementationParams VertexShaderVulkan(EGLenum clientType,
GLint majorVersion,
GLint minorVersion,
EGLint profileMask,
ExtensionName multiviewExtension)
{
return MultiviewImplementationParams(majorVersion, minorVersion, egl_platform::VULKAN(),
multiviewExtension);
return MultiviewImplementationParams(clientType, majorVersion, minorVersion, profileMask,
egl_platform::VULKAN(), multiviewExtension);
}
MultiviewImplementationParams VertexShaderD3D11(GLint majorVersion,
MultiviewImplementationParams VertexShaderD3D11(EGLenum clientType,
GLint majorVersion,
GLint minorVersion,
EGLint profileMask,
ExtensionName multiviewExtension)
{
return MultiviewImplementationParams(majorVersion, minorVersion, egl_platform::D3D11(),
multiviewExtension);
return MultiviewImplementationParams(clientType, majorVersion, minorVersion, profileMask,
egl_platform::D3D11(), multiviewExtension);
}
MultiviewImplementationParams GeomShaderD3D11(GLint majorVersion,
MultiviewImplementationParams GeomShaderD3D11(EGLenum clientType,
GLint majorVersion,
GLint minorVersion,
EGLint profileMask,
ExtensionName multiviewExtension)
{
return MultiviewImplementationParams(
majorVersion, minorVersion,
clientType, majorVersion, minorVersion, profileMask,
egl_platform::D3D11().enable(Feature::SelectViewInGeometryShader), multiviewExtension);
}

26
src/tests/test_utils/MultiviewTest.h
Просмотреть файл

@ -62,28 +62,42 @@ void AttachMultiviewTextures(GLenum target,
struct MultiviewImplementationParams : public PlatformParameters
{
MultiviewImplementationParams(GLint majorVersion,
MultiviewImplementationParams(EGLenum clientType,
GLint majorVersion,
GLint minorVersion,
EGLint profileMask,
const EGLPlatformParameters &eglPlatformParameters,
ExtensionName multiviewExtension)
: PlatformParameters(majorVersion, minorVersion, eglPlatformParameters),
: PlatformParameters(clientType,
majorVersion,
minorVersion,
profileMask,
eglPlatformParameters),
mMultiviewExtension(multiviewExtension)
{}
ExtensionName mMultiviewExtension;
};
std::ostream &operator<<(std::ostream &os, const MultiviewImplementationParams &params);
MultiviewImplementationParams VertexShaderOpenGL(GLint majorVersion,
MultiviewImplementationParams VertexShaderOpenGL(EGLenum clientType,
GLint majorVersion,
GLint minorVersion,
EGLint profileMask,
ExtensionName multiviewExtension);
MultiviewImplementationParams VertexShaderVulkan(GLint majorVersion,
MultiviewImplementationParams VertexShaderVulkan(EGLenum clientType,
GLint majorVersion,
GLint minorVersion,
EGLint profileMask,
ExtensionName multiviewExtension);
MultiviewImplementationParams VertexShaderD3D11(GLint majorVersion,
MultiviewImplementationParams VertexShaderD3D11(EGLenum clientType,
GLint majorVersion,
GLint minorVersion,
EGLint profileMask,
ExtensionName multiviewExtension);
MultiviewImplementationParams GeomShaderD3D11(GLint majorVersion,
MultiviewImplementationParams GeomShaderD3D11(EGLenum clientType,
GLint majorVersion,
GLint minorVersion,
EGLint profileMask,
ExtensionName multiviewExtension);
class MultiviewTestBase : public ANGLETestBase

218
src/tests/test_utils/angle_test_configs.cpp
Просмотреть файл

@ -6,6 +6,7 @@
#include "test_utils/angle_test_configs.h"
#include "common/debug.h"
#include "common/platform.h"
#include "common/string_utils.h"
#include "util/util_gl.h"
@ -38,24 +39,37 @@ bool HasFeatureOverride(const std::vector<Feature> &overrides, Feature feature)
}
} // namespace
PlatformParameters::PlatformParameters() : PlatformParameters(2, 0, GLESDriverType::AngleEGL) {}
PlatformParameters::PlatformParameters()
: PlatformParameters(EGL_OPENGL_ES_API, 2, 0, 0, GLESDriverType::AngleEGL)
{}
PlatformParameters::PlatformParameters(EGLint majorVersion,
PlatformParameters::PlatformParameters(EGLenum clientType,
EGLint majorVersion,
EGLint minorVersion,
EGLint profileMask,
const EGLPlatformParameters &eglPlatformParameters)
: driver(GLESDriverType::AngleEGL),
noFixture(false),
eglParameters(eglPlatformParameters),
clientType(clientType),
majorVersion(majorVersion),
minorVersion(minorVersion)
minorVersion(minorVersion),
profileMask(profileMask)
{
initDefaultParameters();
}
PlatformParameters::PlatformParameters(EGLint majorVersion,
PlatformParameters::PlatformParameters(EGLenum clientType,
EGLint majorVersion,
EGLint minorVersion,
EGLint profileMask,
GLESDriverType driver)
: driver(driver), noFixture(false), majorVersion(majorVersion), minorVersion(minorVersion)
: driver(driver),
noFixture(false),
clientType(clientType),
majorVersion(majorVersion),
minorVersion(minorVersion),
profileMask(profileMask)
{
initDefaultParameters();
}
@ -85,6 +99,11 @@ bool PlatformParameters::isANGLE() const
return driver == GLESDriverType::AngleEGL;
}
bool PlatformParameters::isDesktopOpenGLFrontend() const
{
return clientType == EGL_OPENGL_API;
}
void PlatformParameters::initDefaultParameters()
{
// Default debug layers to enabled in tests.
@ -143,12 +162,49 @@ const char *GetRendererName(EGLint renderer)
std::ostream &operator<<(std::ostream &stream, const PlatformParameters &pp)
{
stream << "ES" << pp.majorVersion << "_";
switch (pp.clientType)
{
case EGL_OPENGL_ES_API:
stream << "ES";
break;
case EGL_OPENGL_API:
stream << "GL";
break;
case EGL_OPENVG_API:
stream << "VG";
break;
default:
UNREACHABLE();
stream << "Error";
break;
}
stream << pp.majorVersion << "_";
if (pp.minorVersion != 0)
{
stream << pp.minorVersion << "_";
}
if (pp.clientType == EGL_OPENGL_API)
{
if ((pp.profileMask & EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT) != 0)
{
stream << "Core_";
}
if ((pp.profileMask & EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT) != 0)
{
stream << "Compatibility_";
}
}
else
{
// Profile mask is only valid for desktop OpenGL contexts.
ASSERT(pp.profileMask == 0);
}
switch (pp.driver)
{
case GLESDriverType::AngleEGL:
@ -473,336 +529,352 @@ EGLPlatformParameters METAL()
// ANGLE tests platforms
PlatformParameters ES1_D3D9()
{
return PlatformParameters(1, 0, egl_platform::D3D9());
return PlatformParameters(EGL_OPENGL_ES_API, 1, 0, 0, egl_platform::D3D9());
}
PlatformParameters ES2_D3D9()
{
return PlatformParameters(2, 0, egl_platform::D3D9());
return PlatformParameters(EGL_OPENGL_ES_API, 2, 0, 0, egl_platform::D3D9());
}
PlatformParameters ES1_D3D11()
{
return PlatformParameters(1, 0, egl_platform::D3D11());
return PlatformParameters(EGL_OPENGL_ES_API, 1, 0, 0, egl_platform::D3D11());
}
PlatformParameters ES2_D3D11()
{
return PlatformParameters(2, 0, egl_platform::D3D11());
return PlatformParameters(EGL_OPENGL_ES_API, 2, 0, 0, egl_platform::D3D11());
}
PlatformParameters ES2_D3D11_PRESENT_PATH_FAST()
{
return PlatformParameters(2, 0, egl_platform::D3D11_PRESENT_PATH_FAST());
return PlatformParameters(EGL_OPENGL_ES_API, 2, 0, 0, egl_platform::D3D11_PRESENT_PATH_FAST());
}
PlatformParameters ES2_D3D11_FL11_0()
{
return PlatformParameters(2, 0, egl_platform::D3D11_FL11_0());
return PlatformParameters(EGL_OPENGL_ES_API, 2, 0, 0, egl_platform::D3D11_FL11_0());
}
PlatformParameters ES2_D3D11_FL10_1()
{
return PlatformParameters(2, 0, egl_platform::D3D11_FL10_1());
return PlatformParameters(EGL_OPENGL_ES_API, 2, 0, 0, egl_platform::D3D11_FL10_1());
}
PlatformParameters ES2_D3D11_FL10_0()
{
return PlatformParameters(2, 0, egl_platform::D3D11_FL10_0());
return PlatformParameters(EGL_OPENGL_ES_API, 2, 0, 0, egl_platform::D3D11_FL10_0());
}
PlatformParameters ES2_D3D11_WARP()
{
return PlatformParameters(2, 0, egl_platform::D3D11_WARP());
return PlatformParameters(EGL_OPENGL_ES_API, 2, 0, 0, egl_platform::D3D11_WARP());
}
PlatformParameters ES2_D3D11_FL11_0_WARP()
{
return PlatformParameters(2, 0, egl_platform::D3D11_FL11_0_WARP());
return PlatformParameters(EGL_OPENGL_ES_API, 2, 0, 0, egl_platform::D3D11_FL11_0_WARP());
}
PlatformParameters ES2_D3D11_FL10_1_WARP()
{
return PlatformParameters(2, 0, egl_platform::D3D11_FL10_1_WARP());
return PlatformParameters(EGL_OPENGL_ES_API, 2, 0, 0, egl_platform::D3D11_FL10_1_WARP());
}
PlatformParameters ES2_D3D11_FL10_0_WARP()
{
return PlatformParameters(2, 0, egl_platform::D3D11_FL10_0_WARP());
return PlatformParameters(EGL_OPENGL_ES_API, 2, 0, 0, egl_platform::D3D11_FL10_0_WARP());
}
PlatformParameters ES2_D3D11_REFERENCE()
{
return PlatformParameters(2, 0, egl_platform::D3D11_REFERENCE());
return PlatformParameters(EGL_OPENGL_ES_API, 2, 0, 0, egl_platform::D3D11_REFERENCE());
}
PlatformParameters ES2_D3D11_FL11_0_REFERENCE()
{
return PlatformParameters(2, 0, egl_platform::D3D11_FL11_0_REFERENCE());
return PlatformParameters(EGL_OPENGL_ES_API, 2, 0, 0, egl_platform::D3D11_FL11_0_REFERENCE());
}
PlatformParameters ES2_D3D11_FL10_1_REFERENCE()
{
return PlatformParameters(2, 0, egl_platform::D3D11_FL10_1_REFERENCE());
return PlatformParameters(EGL_OPENGL_ES_API, 2, 0, 0, egl_platform::D3D11_FL10_1_REFERENCE());
}
PlatformParameters ES2_D3D11_FL10_0_REFERENCE()
{
return PlatformParameters(2, 0, egl_platform::D3D11_FL10_0_REFERENCE());
return PlatformParameters(EGL_OPENGL_ES_API, 2, 0, 0, egl_platform::D3D11_FL10_0_REFERENCE());
}
PlatformParameters ES3_D3D11()
{
return PlatformParameters(3, 0, egl_platform::D3D11());
return PlatformParameters(EGL_OPENGL_ES_API, 3, 0, 0, egl_platform::D3D11());
}
PlatformParameters ES3_D3D11_FL11_1()
{
return PlatformParameters(3, 0, egl_platform::D3D11_FL11_1());
return PlatformParameters(EGL_OPENGL_ES_API, 3, 0, 0, egl_platform::D3D11_FL11_1());
}
PlatformParameters ES3_D3D11_FL11_0()
{
return PlatformParameters(3, 0, egl_platform::D3D11_FL11_0());
return PlatformParameters(EGL_OPENGL_ES_API, 3, 0, 0, egl_platform::D3D11_FL11_0());
}
PlatformParameters ES3_D3D11_FL10_1()
{
return PlatformParameters(3, 0, egl_platform::D3D11_FL10_1());
return PlatformParameters(EGL_OPENGL_ES_API, 3, 0, 0, egl_platform::D3D11_FL10_1());
}
PlatformParameters ES31_D3D11()
{
return PlatformParameters(3, 1, egl_platform::D3D11());
return PlatformParameters(EGL_OPENGL_ES_API, 3, 1, 0, egl_platform::D3D11());
}
PlatformParameters ES31_D3D11_FL11_1()
{
return PlatformParameters(3, 1, egl_platform::D3D11_FL11_1());
return PlatformParameters(EGL_OPENGL_ES_API, 3, 1, 0, egl_platform::D3D11_FL11_1());
}
PlatformParameters ES31_D3D11_FL11_0()
{
return PlatformParameters(3, 1, egl_platform::D3D11_FL11_0());
return PlatformParameters(EGL_OPENGL_ES_API, 3, 1, 0, egl_platform::D3D11_FL11_0());
}
PlatformParameters ES3_D3D11_WARP()
{
return PlatformParameters(3, 0, egl_platform::D3D11_WARP());
return PlatformParameters(EGL_OPENGL_ES_API, 3, 0, 0, egl_platform::D3D11_WARP());
}
PlatformParameters ES3_D3D11_FL11_1_WARP()
{
return PlatformParameters(3, 0, egl_platform::D3D11_FL11_1_WARP());
return PlatformParameters(EGL_OPENGL_ES_API, 3, 0, 0, egl_platform::D3D11_FL11_1_WARP());
}
PlatformParameters ES3_D3D11_FL11_0_WARP()
{
return PlatformParameters(3, 0, egl_platform::D3D11_FL11_0_WARP());
return PlatformParameters(EGL_OPENGL_ES_API, 3, 0, 0, egl_platform::D3D11_FL11_0_WARP());
}
PlatformParameters ES3_D3D11_FL10_1_WARP()
{
return PlatformParameters(3, 0, egl_platform::D3D11_FL10_1_WARP());
return PlatformParameters(EGL_OPENGL_ES_API, 3, 0, 0, egl_platform::D3D11_FL10_1_WARP());
}
PlatformParameters ES1_OPENGLES()
{
return PlatformParameters(1, 0, egl_platform::OPENGLES());
return PlatformParameters(EGL_OPENGL_ES_API, 1, 0, 0, egl_platform::OPENGLES());
}
PlatformParameters ES2_OPENGLES()
{
return PlatformParameters(2, 0, egl_platform::OPENGLES());
return PlatformParameters(EGL_OPENGL_ES_API, 2, 0, 0, egl_platform::OPENGLES());
}
PlatformParameters ES2_OPENGLES(EGLint major, EGLint minor)
{
return PlatformParameters(2, 0, egl_platform::OPENGLES(major, minor));
return PlatformParameters(EGL_OPENGL_ES_API, 2, 0, 0, egl_platform::OPENGLES(major, minor));
}
PlatformParameters ES3_OPENGLES()
{
return PlatformParameters(3, 0, egl_platform::OPENGLES());
return PlatformParameters(EGL_OPENGL_ES_API, 3, 0, 0, egl_platform::OPENGLES());
}
PlatformParameters ES3_OPENGLES(EGLint major, EGLint minor)
{
return PlatformParameters(3, 0, egl_platform::OPENGLES(major, minor));
return PlatformParameters(EGL_OPENGL_ES_API, 3, 0, 0, egl_platform::OPENGLES(major, minor));
}
PlatformParameters ES31_OPENGLES()
{
return PlatformParameters(3, 1, egl_platform::OPENGLES());
return PlatformParameters(EGL_OPENGL_ES_API, 3, 1, 0, egl_platform::OPENGLES());
}
PlatformParameters ES31_OPENGLES(EGLint major, EGLint minor)
{
return PlatformParameters(3, 1, egl_platform::OPENGLES(major, minor));
return PlatformParameters(EGL_OPENGL_ES_API, 3, 1, 0, egl_platform::OPENGLES(major, minor));
}
PlatformParameters ES1_OPENGL()
{
return PlatformParameters(1, 0, egl_platform::OPENGL());
return PlatformParameters(EGL_OPENGL_ES_API, 1, 0, 0, egl_platform::OPENGL());
}
PlatformParameters ES2_OPENGL()
{
return PlatformParameters(2, 0, egl_platform::OPENGL());
return PlatformParameters(EGL_OPENGL_ES_API, 2, 0, 0, egl_platform::OPENGL());
}
PlatformParameters ES2_OPENGL(EGLint major, EGLint minor)
{
return PlatformParameters(2, 0, egl_platform::OPENGL(major, minor));
return PlatformParameters(EGL_OPENGL_ES_API, 2, 0, 0, egl_platform::OPENGL(major, minor));
}
PlatformParameters ES3_OPENGL()
{
return PlatformParameters(3, 0, egl_platform::OPENGL());
return PlatformParameters(EGL_OPENGL_ES_API, 3, 0, 0, egl_platform::OPENGL());
}
PlatformParameters ES3_OPENGL(EGLint major, EGLint minor)
{
return PlatformParameters(3, 0, egl_platform::OPENGL(major, minor));
return PlatformParameters(EGL_OPENGL_ES_API, 3, 0, 0, egl_platform::OPENGL(major, minor));
}
PlatformParameters ES31_OPENGL()
{
return PlatformParameters(3, 1, egl_platform::OPENGL());
return PlatformParameters(EGL_OPENGL_ES_API, 3, 1, 0, egl_platform::OPENGL());
}
PlatformParameters ES31_OPENGL(EGLint major, EGLint minor)
{
return PlatformParameters(3, 1, egl_platform::OPENGL(major, minor));
return PlatformParameters(EGL_OPENGL_ES_API, 3, 1, 0, egl_platform::OPENGL(major, minor));
}
PlatformParameters ES1_NULL()
{
return PlatformParameters(1, 0, EGLPlatformParameters(EGL_PLATFORM_ANGLE_TYPE_NULL_ANGLE));
return PlatformParameters(EGL_OPENGL_ES_API, 1, 0, 0,
EGLPlatformParameters(EGL_PLATFORM_ANGLE_TYPE_NULL_ANGLE));
}
PlatformParameters ES2_NULL()
{
return PlatformParameters(2, 0, EGLPlatformParameters(EGL_PLATFORM_ANGLE_TYPE_NULL_ANGLE));
return PlatformParameters(EGL_OPENGL_ES_API, 2, 0, 0,
EGLPlatformParameters(EGL_PLATFORM_ANGLE_TYPE_NULL_ANGLE));
}
PlatformParameters ES3_NULL()
{
return PlatformParameters(3, 0, EGLPlatformParameters(EGL_PLATFORM_ANGLE_TYPE_NULL_ANGLE));
return PlatformParameters(EGL_OPENGL_ES_API, 3, 0, 0,
EGLPlatformParameters(EGL_PLATFORM_ANGLE_TYPE_NULL_ANGLE));
}
PlatformParameters ES31_NULL()
{
return PlatformParameters(3, 1, EGLPlatformParameters(EGL_PLATFORM_ANGLE_TYPE_NULL_ANGLE));
return PlatformParameters(EGL_OPENGL_ES_API, 3, 1, 0,
EGLPlatformParameters(EGL_PLATFORM_ANGLE_TYPE_NULL_ANGLE));
}
PlatformParameters ES1_VULKAN()
{
return PlatformParameters(1, 0, egl_platform::VULKAN());
return PlatformParameters(EGL_OPENGL_ES_API, 1, 0, 0, egl_platform::VULKAN());
}
PlatformParameters ES1_VULKAN_NULL()
{
return PlatformParameters(1, 0, egl_platform::VULKAN_NULL());
return PlatformParameters(EGL_OPENGL_ES_API, 1, 0, 0, egl_platform::VULKAN_NULL());
}
PlatformParameters ES1_VULKAN_SWIFTSHADER()
{
return PlatformParameters(1, 0, egl_platform::VULKAN_SWIFTSHADER());
return PlatformParameters(EGL_OPENGL_ES_API, 1, 0, 0, egl_platform::VULKAN_SWIFTSHADER());
}
PlatformParameters ES2_VULKAN()
{
return PlatformParameters(2, 0, egl_platform::VULKAN());
return PlatformParameters(EGL_OPENGL_ES_API, 2, 0, 0, egl_platform::VULKAN());
}
PlatformParameters ES2_VULKAN_NULL()
{
return PlatformParameters(2, 0, egl_platform::VULKAN_NULL());
return PlatformParameters(EGL_OPENGL_ES_API, 2, 0, 0, egl_platform::VULKAN_NULL());
}
PlatformParameters ES2_VULKAN_SWIFTSHADER()
{
return PlatformParameters(2, 0, egl_platform::VULKAN_SWIFTSHADER());
return PlatformParameters(EGL_OPENGL_ES_API, 2, 0, 0, egl_platform::VULKAN_SWIFTSHADER());
}
PlatformParameters ES3_VULKAN()
{
return PlatformParameters(3, 0, egl_platform::VULKAN());
return PlatformParameters(EGL_OPENGL_ES_API, 3, 0, 0, egl_platform::VULKAN());
}
PlatformParameters ES3_VULKAN_NULL()
{
return PlatformParameters(3, 0, egl_platform::VULKAN_NULL());
return PlatformParameters(EGL_OPENGL_ES_API, 3, 0, 0, egl_platform::VULKAN_NULL());
}
PlatformParameters ES3_VULKAN_SWIFTSHADER()
{
return PlatformParameters(3, 0, egl_platform::VULKAN_SWIFTSHADER());
return PlatformParameters(EGL_OPENGL_ES_API, 3, 0, 0, egl_platform::VULKAN_SWIFTSHADER());
}
PlatformParameters ES31_VULKAN()
{
return PlatformParameters(3, 1, egl_platform::VULKAN());
return PlatformParameters(EGL_OPENGL_ES_API, 3, 1, 0, egl_platform::VULKAN());
}
PlatformParameters ES31_VULKAN_NULL()
{
return PlatformParameters(3, 1, egl_platform::VULKAN_NULL());
return PlatformParameters(EGL_OPENGL_ES_API, 3, 1, 0, egl_platform::VULKAN_NULL());
}
PlatformParameters ES31_VULKAN_SWIFTSHADER()
{
return PlatformParameters(3, 1, egl_platform::VULKAN_SWIFTSHADER());
return PlatformParameters(EGL_OPENGL_ES_API, 3, 1, 0, egl_platform::VULKAN_SWIFTSHADER());
}
PlatformParameters ES32_VULKAN()
{
return PlatformParameters(3, 2, egl_platform::VULKAN());
return PlatformParameters(EGL_OPENGL_ES_API, 3, 2, 0, egl_platform::VULKAN());
}
PlatformParameters ES32_VULKAN_NULL()
{
return PlatformParameters(3, 2, egl_platform::VULKAN_NULL());
return PlatformParameters(EGL_OPENGL_ES_API, 3, 2, 0, egl_platform::VULKAN_NULL());
}
PlatformParameters ES32_VULKAN_SWIFTSHADER()
{
return PlatformParameters(3, 2, egl_platform::VULKAN_SWIFTSHADER());
return PlatformParameters(EGL_OPENGL_ES_API, 3, 2, 0, egl_platform::VULKAN_SWIFTSHADER());
}
PlatformParameters GL32_CORE_VULKAN()
{
return PlatformParameters(EGL_OPENGL_API, 3, 2, EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT,
egl_platform::VULKAN());
}
PlatformParameters GL32_CORE_VULKAN_SWIFTSHADER()
{
return PlatformParameters(EGL_OPENGL_API, 3, 2, EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT,
egl_platform::VULKAN_SWIFTSHADER());
}
PlatformParameters ES1_METAL()
{
return PlatformParameters(1, 0, egl_platform::METAL());
return PlatformParameters(EGL_OPENGL_ES_API, 1, 0, 0, egl_platform::METAL());
}
PlatformParameters ES2_METAL()
{
return PlatformParameters(2, 0, egl_platform::METAL());
return PlatformParameters(EGL_OPENGL_ES_API, 2, 0, 0, egl_platform::METAL());
}
PlatformParameters ES3_METAL()
{
return PlatformParameters(3, 0, egl_platform::METAL());
return PlatformParameters(EGL_OPENGL_ES_API, 3, 0, 0, egl_platform::METAL());
}
PlatformParameters ES2_WGL()
{
return PlatformParameters(2, 0, GLESDriverType::SystemWGL);
return PlatformParameters(EGL_OPENGL_ES_API, 2, 0, 0, GLESDriverType::SystemWGL);
}
PlatformParameters ES3_WGL()
{
return PlatformParameters(3, 0, GLESDriverType::SystemWGL);
return PlatformParameters(EGL_OPENGL_ES_API, 3, 0, 0, GLESDriverType::SystemWGL);
}
PlatformParameters ES2_EGL()
{
return PlatformParameters(2, 0, GLESDriverType::SystemEGL);
return PlatformParameters(EGL_OPENGL_ES_API, 2, 0, 0, GLESDriverType::SystemEGL);
}
PlatformParameters ES3_EGL()
{
return PlatformParameters(3, 0, GLESDriverType::SystemEGL);
return PlatformParameters(EGL_OPENGL_ES_API, 3, 0, 0, GLESDriverType::SystemEGL);
}
} // namespace angle

18
src/tests/test_utils/angle_test_configs.h
Просмотреть файл

@ -26,22 +26,30 @@ namespace angle
struct PlatformParameters
{
PlatformParameters();
PlatformParameters(EGLint majorVersion,
PlatformParameters(EGLenum clientType,
EGLint majorVersion,
EGLint minorVersion,
EGLint profileMask,
const EGLPlatformParameters &eglPlatformParameters);
PlatformParameters(EGLint majorVersion, EGLint minorVersion, GLESDriverType driver);
PlatformParameters(EGLenum clientType,
EGLint majorVersion,
EGLint minorVersion,
EGLint profileMask,
GLESDriverType driver);
EGLint getRenderer() const;
EGLint getDeviceType() const;
bool isSwiftshader() const;
bool isVulkan() const;
bool isANGLE() const;
bool isDesktopOpenGLFrontend() const;
void initDefaultParameters();
auto tie() const
{
return std::tie(driver, noFixture, eglParameters, majorVersion, minorVersion);
return std::tie(driver, noFixture, eglParameters, clientType, majorVersion, minorVersion,
profileMask);
}
// Helpers to enable and disable ANGLE features. Expects a Feature::* value from
@ -62,8 +70,10 @@ struct PlatformParameters
GLESDriverType driver;
bool noFixture;
EGLPlatformParameters eglParameters;
EGLenum clientType;
EGLint majorVersion;
EGLint minorVersion;
EGLint profileMask;
};
const char *GetRendererName(EGLint renderer);
@ -192,6 +202,8 @@ PlatformParameters ES31_VULKAN_SWIFTSHADER();
PlatformParameters ES32_VULKAN();
PlatformParameters ES32_VULKAN_NULL();
PlatformParameters ES32_VULKAN_SWIFTSHADER();
PlatformParameters GL32_CORE_VULKAN();
PlatformParameters GL32_CORE_VULKAN_SWIFTSHADER();
PlatformParameters ES1_METAL();
PlatformParameters ES2_METAL();

17
src/tests/test_utils/angle_test_instantiate.cpp
Просмотреть файл

@ -47,7 +47,8 @@ bool IsAngleEGLConfigSupported(const PlatformParameters &param, OSWindow *osWind
angle::OpenSharedLibrary(ANGLE_EGL_LIBRARY_NAME, angle::SearchType::ModuleDir));
#endif
EGLWindow *eglWindow = EGLWindow::New(param.majorVersion, param.minorVersion);
EGLWindow *eglWindow =
EGLWindow::New(param.clientType, param.majorVersion, param.minorVersion, param.profileMask);
ConfigParameters configParams;
bool result =
eglWindow->initializeGL(osWindow, eglLibrary.get(), angle::GLESDriverType::AngleEGL,
@ -63,7 +64,8 @@ bool IsSystemWGLConfigSupported(const PlatformParameters &param, OSWindow *osWin
std::unique_ptr<angle::Library> openglLibrary(
angle::OpenSharedLibrary("opengl32", angle::SearchType::SystemDir));
WGLWindow *wglWindow = WGLWindow::New(param.majorVersion, param.minorVersion);
WGLWindow *wglWindow =
WGLWindow::New(param.clientType, param.majorVersion, param.minorVersion, param.profileMask);
ConfigParameters configParams;
bool result =
wglWindow->initializeGL(osWindow, openglLibrary.get(), angle::GLESDriverType::SystemWGL,
@ -84,7 +86,8 @@ bool IsSystemEGLConfigSupported(const PlatformParameters &param, OSWindow *osWin
eglLibrary.reset(OpenSharedLibraryWithExtension(GetNativeEGLLibraryNameWithExtension(),
SearchType::SystemDir));
EGLWindow *eglWindow = EGLWindow::New(param.majorVersion, param.minorVersion);
EGLWindow *eglWindow =
EGLWindow::New(param.clientType, param.majorVersion, param.minorVersion, param.profileMask);
ConfigParameters configParams;
bool result =
eglWindow->initializeGL(osWindow, eglLibrary.get(), angle::GLESDriverType::SystemEGL,
@ -441,6 +444,14 @@ bool IsConfigAllowlisted(const SystemInfo &systemInfo, const PlatformParameters
return false;
}
// Skip test configs that target the desktop OpenGL frontend when it's not enabled.
#if !defined(ANGLE_ENABLE_OPENGL_DESKTOP)
if (param.isDesktopOpenGLFrontend())
{
return false;
}
#endif
if (IsWindows())
{
switch (param.driver)

21
src/tests/test_utils/angle_test_instantiate.h
Просмотреть файл

@ -145,6 +145,8 @@ struct CombinedPrintToStringParamName
#define ANGLE_ALL_TEST_PLATFORMS_ES32 \
ES32_VULKAN(), ES32_VULKAN().enable(Feature::AsyncCommandQueue)
#define ANGLE_ALL_TEST_PLATFORMS_GL32_CORE GL32_CORE_VULKAN(), GL32_CORE_VULKAN_SWIFTSHADER()
#define ANGLE_ALL_TEST_PLATFORMS_NULL ES2_NULL(), ES3_NULL(), ES31_NULL()
// Instantiate the test once for each GLES1 platform
@ -197,6 +199,18 @@ struct CombinedPrintToStringParamName
INSTANTIATE_TEST_SUITE_P(, testName, ANGLE_INSTANTIATE_TEST_PLATFORMS(testName), \
testing::PrintToStringParamName())
// Instantiate the test once for each desktop GL 3.2 core platform
#define ANGLE_INSTANTIATE_TEST_GL32_CORE(testName) \
const PlatformParameters testName##params[] = {ANGLE_ALL_TEST_PLATFORMS_GL32_CORE}; \
INSTANTIATE_TEST_SUITE_P(, testName, ANGLE_INSTANTIATE_TEST_PLATFORMS(testName), \
testing::PrintToStringParamName())
#define ANGLE_INSTANTIATE_TEST_GL32_CORE_AND(testName, ...) \
const PlatformParameters testName##params[] = {ANGLE_ALL_TEST_PLATFORMS_GL32_CORE, \
__VA_ARGS__}; \
INSTANTIATE_TEST_SUITE_P(, testName, ANGLE_INSTANTIATE_TEST_PLATFORMS(testName), \
testing::PrintToStringParamName())
// Multiple ES Version macros
#define ANGLE_INSTANTIATE_TEST_ES2_AND_ES3(testName) \
const PlatformParameters testName##params[] = {ANGLE_ALL_TEST_PLATFORMS_ES2, \
@ -231,6 +245,13 @@ struct CombinedPrintToStringParamName
INSTANTIATE_TEST_SUITE_P(, testName, ANGLE_INSTANTIATE_TEST_PLATFORMS(testName), \
testing::PrintToStringParamName())
#define ANGLE_INSTANTIATE_TEST_ES2_AND_ES3_AND_ES31_AND_NULL_AND(testName, ...) \
const PlatformParameters testName##params[] = { \
ANGLE_ALL_TEST_PLATFORMS_ES2, ANGLE_ALL_TEST_PLATFORMS_ES3, ANGLE_ALL_TEST_PLATFORMS_ES31, \
ANGLE_ALL_TEST_PLATFORMS_NULL, __VA_ARGS__}; \
INSTANTIATE_TEST_SUITE_P(, testName, ANGLE_INSTANTIATE_TEST_PLATFORMS(testName), \
testing::PrintToStringParamName())
#define ANGLE_INSTANTIATE_TEST_ES3_AND_ES31(testName) \
const PlatformParameters testName##params[] = {ANGLE_ALL_TEST_PLATFORMS_ES3, \
ANGLE_ALL_TEST_PLATFORMS_ES31}; \

32
util/EGLWindow.cpp
Просмотреть файл

@ -51,15 +51,24 @@ void ConfigParameters::reset()
}
// GLWindowBase implementation.
GLWindowBase::GLWindowBase(EGLint glesMajorVersion, EGLint glesMinorVersion)
: mClientMajorVersion(glesMajorVersion), mClientMinorVersion(glesMinorVersion)
GLWindowBase::GLWindowBase(EGLenum clientType,
GLint glesMajorVersion,
EGLint glesMinorVersion,
EGLint profileMask)
: mClientType(clientType),
mClientMajorVersion(glesMajorVersion),
mClientMinorVersion(glesMinorVersion),
mProfileMask(profileMask)
{}
GLWindowBase::~GLWindowBase() = default;
// EGLWindow implementation.
EGLWindow::EGLWindow(EGLint glesMajorVersion, EGLint glesMinorVersion)
: GLWindowBase(glesMajorVersion, glesMinorVersion),
EGLWindow::EGLWindow(EGLenum clientType,
EGLint glesMajorVersion,
EGLint glesMinorVersion,
EGLint profileMask)
: GLWindowBase(clientType, glesMajorVersion, glesMinorVersion, profileMask),
mConfig(0),
mDisplay(EGL_NO_DISPLAY),
mSurface(EGL_NO_SURFACE),
@ -495,7 +504,7 @@ EGLContext EGLWindow::createContext(EGLContext share, EGLint *extraAttributes)
return EGL_NO_CONTEXT;
}
eglBindAPI(EGL_OPENGL_ES_API);
eglBindAPI(mClientType);
if (eglGetError() != EGL_SUCCESS)
{
fprintf(stderr, "Error on eglBindAPI.\n");
@ -518,6 +527,12 @@ EGLContext EGLWindow::createContext(EGLContext share, EGLint *extraAttributes)
contextAttributes.push_back(EGL_CONTEXT_MINOR_VERSION_KHR);
contextAttributes.push_back(mClientMinorVersion);
if (mProfileMask != 0)
{
contextAttributes.push_back(EGL_CONTEXT_OPENGL_PROFILE_MASK);
contextAttributes.push_back(mProfileMask);
}
// Note that the Android loader currently doesn't handle this flag despite reporting 1.5.
// Work around this by only using the debug bit when we request a debug context.
if (hasDebug && mConfigParams.debug)
@ -829,9 +844,12 @@ void GLWindowBase::Delete(GLWindowBase **window)
}
// static
EGLWindow *EGLWindow::New(EGLint glesMajorVersion, EGLint glesMinorVersion)
EGLWindow *EGLWindow::New(EGLenum clientType,
EGLint glesMajorVersion,
EGLint glesMinorVersion,
EGLint profileMask)
{
return new EGLWindow(glesMajorVersion, glesMinorVersion);
return new EGLWindow(clientType, glesMajorVersion, glesMinorVersion, profileMask);
}
// static

19
util/EGLWindow.h
Просмотреть файл

@ -88,6 +88,8 @@ class ANGLE_UTIL_EXPORT GLWindowBase : angle::NonCopyable
// It should also be possible to set multisample and floating point framebuffers.
EGLint getClientMajorVersion() const { return mClientMajorVersion; }
EGLint getClientMinorVersion() const { return mClientMinorVersion; }
EGLenum getClientType() const { return mClientType; }
EGLint getProfileMask() const { return mProfileMask; }
virtual bool initializeGL(OSWindow *osWindow,
angle::Library *glWindowingLibrary,
@ -140,11 +142,16 @@ class ANGLE_UTIL_EXPORT GLWindowBase : angle::NonCopyable
const ConfigParameters &getConfigParams() const { return mConfigParams; }
protected:
GLWindowBase(EGLint glesMajorVersion, EGLint glesMinorVersion);
GLWindowBase(EGLenum clientType,
EGLint glesMajorVersion,
EGLint glesMinorVersion,
EGLint profileMask);
virtual ~GLWindowBase();
EGLenum mClientType;
EGLint mClientMajorVersion;
EGLint mClientMinorVersion;
EGLint mProfileMask;
EGLPlatformParameters mPlatform;
ConfigParameters mConfigParams;
};
@ -152,7 +159,10 @@ class ANGLE_UTIL_EXPORT GLWindowBase : angle::NonCopyable
class ANGLE_UTIL_EXPORT EGLWindow : public GLWindowBase
{
public:
static EGLWindow *New(EGLint glesMajorVersion, EGLint glesMinorVersion);
static EGLWindow *New(EGLenum clientType,
EGLint glesMajorVersion,
EGLint glesMinorVersion,
EGLint profileMask);
static void Delete(EGLWindow **window);
static EGLBoolean FindEGLConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *config);
@ -231,7 +241,10 @@ class ANGLE_UTIL_EXPORT EGLWindow : public GLWindowBase
bool isDisplayInitialized() const { return mDisplay != EGL_NO_DISPLAY; }
private:
EGLWindow(EGLint glesMajorVersion, EGLint glesMinorVersion);
EGLWindow(EGLenum clientType,
EGLint glesMajorVersion,
EGLint glesMinorVersion,
EGLint profileMask);
~EGLWindow() override;
EGLConfig mConfig;

45
util/windows/WGLWindow.cpp
Просмотреть файл

@ -114,8 +114,8 @@ std::vector<int> GetPixelFormatAttributes(const ConfigParameters &configParams)
} // namespace
WGLWindow::WGLWindow(int glesMajorVersion, int glesMinorVersion)
: GLWindowBase(glesMajorVersion, glesMinorVersion),
WGLWindow::WGLWindow(EGLenum clientType, int majorVersion, int minorVersion, int profileMask)
: GLWindowBase(clientType, majorVersion, minorVersion, profileMask),
mDeviceContext(nullptr),
mWGLContext(nullptr),
mWindow(nullptr)
@ -269,17 +269,34 @@ HGLRC WGLWindow::createContext(const ConfigParameters &configParams, HGLRC share
// Tear down the context and create another with ES2 compatibility.
_wglDeleteContext(context);
// This could be extended to cover ES1 compatiblity.
int kCreateAttribs[] = {WGL_CONTEXT_MAJOR_VERSION_ARB,
mClientMajorVersion,
WGL_CONTEXT_MINOR_VERSION_ARB,
mClientMinorVersion,
WGL_CONTEXT_PROFILE_MASK_ARB,
WGL_CONTEXT_ES2_PROFILE_BIT_EXT,
0,
0};
// This could be extended to cover ES1 compatibility and desktop GL profiles.
int profileMask = 0;
if (mClientType == EGL_OPENGL_ES_API)
{
profileMask = WGL_CONTEXT_ES2_PROFILE_BIT_EXT;
}
else
{
if ((mProfileMask & EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT) != 0)
{
profileMask |= WGL_CONTEXT_CORE_PROFILE_BIT_ARB;
}
if ((mProfileMask & EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT) != 0)
{
profileMask |= WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB;
}
}
context = _wglCreateContextAttribsARB(mDeviceContext, shareContext, kCreateAttribs);
const int createAttribs[] = {WGL_CONTEXT_MAJOR_VERSION_ARB,
mClientMajorVersion,
WGL_CONTEXT_MINOR_VERSION_ARB,
mClientMinorVersion,
WGL_CONTEXT_PROFILE_MASK_ARB,
profileMask,
0,
0};
context = _wglCreateContextAttribsARB(mDeviceContext, shareContext, createAttribs);
if (!context)
{
std::cerr << "Failed to create an ES2 compatible WGL context." << std::endl;
@ -439,9 +456,9 @@ angle::GenericProc WGLWindow::getProcAddress(const char *name)
}
// static
WGLWindow *WGLWindow::New(int glesMajorVersion, int glesMinorVersion)
WGLWindow *WGLWindow::New(EGLenum clientType, int majorVersion, int minorVersion, int profileMask)
{
return new WGLWindow(glesMajorVersion, glesMinorVersion);
return new WGLWindow(clientType, majorVersion, minorVersion, profileMask);
}
// static

4
util/windows/WGLWindow.h
Просмотреть файл

@ -24,7 +24,7 @@ class Library;
class ANGLE_UTIL_EXPORT WGLWindow : public GLWindowBase
{
public:
static WGLWindow *New(int glesMajorVersion, int glesMinorVersion);
static WGLWindow *New(EGLenum clientType, int majorVersion, int minorVersion, int profileMask);
static void Delete(WGLWindow **window);
// Internally initializes GL resources.
@ -74,7 +74,7 @@ class ANGLE_UTIL_EXPORT WGLWindow : public GLWindowBase
bool makeCurrent(HGLRC context);
private:
WGLWindow(int glesMajorVersion, int glesMinorVersion);
WGLWindow(EGLenum clientType, int majorVersion, int minorVersion, int profileMask);
~WGLWindow() override;
// OS resources.