godotengine/godot-angle-static
1
0
Fork 0
mirror of https://github.com/godotengine/godot-angle-static.git synced 2026-01-03 14:09:33 +03:00
Code Issues Packages Projects Releases Wiki Activity

Move EGL Display config into EGLPlatformParameters.

Browse Source 
This CL moves all of the EGLDisplay configuration into an EGL platform
struct. Consolidating display configuration in the struct allows us to
move configuration out of the test constructor. Then when we filter
test configs we don't need to wait for the individual test setup.

Bug: angleproject:3393
Change-Id: I5bd06dcdc9f2867ebc43c1d4984077ada35cafc8
Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/1574674
Commit-Queue: Jamie Madill <jmadill@chromium.org>
Reviewed-by: Yuly Novikov <ynovikov@chromium.org>
This commit is contained in:
Jamie Madill
2019-05-01 15:11:46 -04:00
committed by Commit Bot
parent ca49e6dc71
commit 3089f92e8a
16 changed files with 261 additions and 310 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
samples/sample_util/SampleApplication.cpp
View File

@@ -56,18 +56,19 @@ SampleApplication::SampleApplication(std::string name,
mEGLWindow(nullptr),
mOSWindow(nullptr)
{
EGLint requestedRenderer = EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE;
mPlatformParams.majorVersion = glesMajorVersion;
mPlatformParams.minorVersion = glesMinorVersion;
mPlatformParams.renderer = EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE;
if (argc > 1 && strncmp(argv[1], kUseAngleArg, strlen(kUseAngleArg)) == 0)
{
requestedRenderer = GetDisplayTypeFromArg(argv[1] + strlen(kUseAngleArg));
mPlatformParams.renderer = GetDisplayTypeFromArg(argv[1] + strlen(kUseAngleArg));
}
// Load EGL library so we can initialize the display.
mEntryPointsLib.reset(angle::OpenSharedLibrary(ANGLE_EGL_LIBRARY_NAME));
mEGLWindow = EGLWindow::New(glesMajorVersion, glesMinorVersion,
EGLPlatformParameters(requestedRenderer));
mEGLWindow = EGLWindow::New(glesMajorVersion, glesMinorVersion);
mTimer.reset(CreateTimer());
mOSWindow = OSWindow::New();
}
@@ -136,7 +137,7 @@ int SampleApplication::run()
configParams.depthBits = 24;
configParams.stencilBits = 8;
if (!mEGLWindow->initializeGL(mOSWindow, mEntryPointsLib.get(), configParams))
if (!mEGLWindow->initializeGL(mOSWindow, mEntryPointsLib.get(), mPlatformParams, configParams))
{
return -1;
}

3
samples/sample_util/SampleApplication.h
View File

@@ -12,6 +12,7 @@
#include <memory>
#include <string>
#include "util/EGLPlatformParameters.h"
#include "util/OSWindow.h"
#include "util/Timer.h"
#include "util/egl_loader_autogen.h"
@@ -64,6 +65,8 @@ class SampleApplication
EGLWindow *mEGLWindow;
OSWindow *mOSWindow;
EGLPlatformParameters mPlatformParams;
// Handle to the entry point binding library.
std::unique_ptr<angle::Library> mEntryPointsLib;
};

9
src/tests/gl_tests/MultithreadingTest.cpp
View File

@@ -27,7 +27,6 @@ class MultithreadingTest : public ANGLETest
setConfigGreenBits(8);
setConfigBlueBits(8);
setConfigAlphaBits(8);
setContextVirtualization(false);
}
bool platformSupportsMultithreading() const { return (IsOpenGLES() && IsAndroid()); }
@@ -158,9 +157,9 @@ TEST_P(MultithreadingTest, MakeCurrentMultiContext)
// TODO(geofflang): Test sharing a program between multiple shared contexts on multiple threads
ANGLE_INSTANTIATE_TEST(MultithreadingTest,
ES2_OPENGL(),
ES3_OPENGL(),
ES2_OPENGLES(),
ES3_OPENGLES());
WithNoVirtualContexts(ES2_OPENGL()),
WithNoVirtualContexts(ES3_OPENGL()),
WithNoVirtualContexts(ES2_OPENGLES()),
WithNoVirtualContexts(ES3_OPENGLES()));
} // namespace angle

8
src/tests/gl_tests/ProgramBinaryTest.cpp
View File

@@ -719,11 +719,11 @@ class ProgramBinariesAcrossPlatforms : public testing::TestWithParam<PlatformsWi
EGLWindow *createAndInitEGLWindow(angle::PlatformParameters &param)
{
EGLWindow *eglWindow =
EGLWindow::New(param.majorVersion, param.minorVersion, param.eglParameters);
EGLWindow *eglWindow = EGLWindow::New(param.majorVersion, param.minorVersion);
ConfigParameters configParams;
bool result = eglWindow->initializeGL(mOSWindow, mEntryPointsLib.get(), configParams);
if (result == false)
bool result = eglWindow->initializeGL(mOSWindow, mEntryPointsLib.get(), param.eglParameters,
configParams);
if (!result)
{
EGLWindow::Delete(&eglWindow);
}

17
src/tests/perf_tests/ANGLEPerfTest.cpp
View File

@@ -362,7 +362,7 @@ ANGLERenderTest::ANGLERenderTest(const std::string &name, const RenderTestParams
switch (testParams.driver)
{
case angle::GLESDriverType::AngleEGL:
mGLWindow = createEGLWindow(testParams);
mGLWindow = EGLWindow::New(testParams.majorVersion, testParams.minorVersion);
mEntryPointsLib.reset(angle::OpenSharedLibrary(ANGLE_EGL_LIBRARY_NAME));
break;
case angle::GLESDriverType::SystemEGL:
@@ -426,8 +426,6 @@ void ANGLERenderTest::SetUp()
mPlatformMethods.monotonicallyIncreasingTime = MonotonicallyIncreasingTime;
mPlatformMethods.context = this;
mConfigParams.platformMethods = &mPlatformMethods;
if (!mOSWindow->initialize(mName, mTestParams.windowWidth, mTestParams.windowHeight))
{
mSkipTest = true;
@@ -435,7 +433,11 @@ void ANGLERenderTest::SetUp()
// FAIL returns.
}
if (!mGLWindow->initializeGL(mOSWindow, mEntryPointsLib.get(), mConfigParams))
// Override platform method parameter.
EGLPlatformParameters withMethods = mTestParams.eglParameters;
withMethods.platformMethods = &mPlatformMethods;
if (!mGLWindow->initializeGL(mOSWindow, mEntryPointsLib.get(), withMethods, mConfigParams))
{
mSkipTest = true;
FAIL() << "Failed initializing GL Window";
@@ -607,10 +609,3 @@ std::vector<TraceEvent> &ANGLERenderTest::getTraceEventBuffer()
{
return mTraceEventBuffer;
}
// static
EGLWindow *ANGLERenderTest::createEGLWindow(const RenderTestParams &testParams)
{
return EGLWindow::New(testParams.majorVersion, testParams.minorVersion,
testParams.eglParameters);
}

2
src/tests/perf_tests/ANGLEPerfTest.h
View File

@@ -157,8 +157,6 @@ class ANGLERenderTest : public ANGLEPerfTest
bool areExtensionPrerequisitesFulfilled() const;
static EGLWindow *createEGLWindow(const RenderTestParams &testParams);
GLWindowBase *mGLWindow;
OSWindow *mOSWindow;
std::vector<const char *> mExtensionPrerequisites;

170
src/tests/test_utils/ANGLETest.cpp
View File

@@ -323,22 +323,26 @@ ANGLETestBase::ANGLETestBase(const angle::PlatformParameters &params)
mDeferContextInit(false),
mAlwaysForceNewDisplay(angle::ShouldAlwaysForceNewDisplay()),
mForceNewDisplay(mAlwaysForceNewDisplay),
mCurrentPlatform(nullptr)
mCurrentParams(nullptr),
mFixture(nullptr)
{
auto iter = gPlatforms.find(params);
// Override the default platform methods with the ANGLE test methods pointer.
angle::PlatformParameters withMethods = params;
withMethods.eglParameters.platformMethods = &gDefaultPlatformMethods;
auto iter = gPlatforms.find(withMethods);
if (iter != gPlatforms.end())
{
mCurrentPlatform = &iter->second;
mCurrentPlatform->configParams.reset();
// Default debug layers to enabled in tests.
mCurrentPlatform->configParams.debugLayersEnabled = true;
mCurrentParams = &iter->first;
mFixture = &iter->second;
mFixture->configParams.reset();
return;
}
Platform platform;
auto insertIter = gPlatforms.emplace(params, platform);
mCurrentPlatform = &insertIter.first->second;
TestFixture platform;
auto insertIter = gPlatforms.emplace(withMethods, platform);
mCurrentParams = &insertIter.first->first;
mFixture = &insertIter.first->second;
std::stringstream windowNameStream;
windowNameStream << "ANGLE Tests - " << params;
@@ -346,29 +350,28 @@ ANGLETestBase::ANGLETestBase(const angle::PlatformParameters &params)
if (mAlwaysForceNewDisplay)
{
mCurrentPlatform->osWindow = mOSWindowSingleton;
mFixture->osWindow = mOSWindowSingleton;
}
if (!mCurrentPlatform->osWindow)
if (!mFixture->osWindow)
{
mCurrentPlatform->osWindow = OSWindow::New();
if (!mCurrentPlatform->osWindow->initialize(windowName.c_str(), 128, 128))
mFixture->osWindow = OSWindow::New();
if (!mFixture->osWindow->initialize(windowName.c_str(), 128, 128))
{
std::cerr << "Failed to initialize OS Window.";
}
mOSWindowSingleton = mCurrentPlatform->osWindow;
mOSWindowSingleton = mFixture->osWindow;
}
// On Linux we must keep the test windows visible. On Windows it doesn't seem to need it.
mCurrentPlatform->osWindow->setVisible(!angle::IsWindows());
mFixture->osWindow->setVisible(!angle::IsWindows());
switch (params.driver)
{
case angle::GLESDriverType::AngleEGL:
{
mCurrentPlatform->eglWindow =
EGLWindow::New(params.majorVersion, params.minorVersion, params.eglParameters);
mFixture->eglWindow = EGLWindow::New(params.majorVersion, params.minorVersion);
break;
}
@@ -385,9 +388,6 @@ ANGLETestBase::ANGLETestBase(const angle::PlatformParameters &params)
break;
}
}
// Default debug layers to enabled in tests.
mCurrentPlatform->configParams.debugLayersEnabled = true;
}
ANGLETestBase::~ANGLETestBase()
@@ -418,7 +418,6 @@ void ANGLETestBase::ANGLETestSetUp()
gDefaultPlatformMethods.logWarning = angle::TestPlatform_logWarning;
gDefaultPlatformMethods.logInfo = angle::TestPlatform_logInfo;
gDefaultPlatformMethods.context = &gPlatformContext;
mCurrentPlatform->configParams.platformMethods = &gDefaultPlatformMethods;
gPlatformContext.ignoreMessages = false;
gPlatformContext.warningsAsErrors = false;
@@ -427,10 +426,9 @@ void ANGLETestBase::ANGLETestSetUp()
// Resize the window before creating the context so that the first make current
// sets the viewport and scissor box to the right size.
bool needSwap = false;
if (mCurrentPlatform->osWindow->getWidth() != mWidth ||
mCurrentPlatform->osWindow->getHeight() != mHeight)
if (mFixture->osWindow->getWidth() != mWidth || mFixture->osWindow->getHeight() != mHeight)
{
if (!mCurrentPlatform->osWindow->resize(mWidth, mHeight))
if (!mFixture->osWindow->resize(mWidth, mHeight))
{
FAIL() << "Failed to resize ANGLE test window.";
}
@@ -438,33 +436,34 @@ void ANGLETestBase::ANGLETestSetUp()
}
// WGL tests are currently disabled.
if (mCurrentPlatform->wglWindow)
if (mFixture->wglWindow)
{
FAIL() << "Unsupported driver.";
}
else
{
if (mForceNewDisplay || !mCurrentPlatform->eglWindow->isDisplayInitialized() ||
!ConfigParameters::CanShareDisplay(mCurrentPlatform->configParams,
mCurrentPlatform->eglWindow->getConfigParams()))
if (mForceNewDisplay || !mFixture->eglWindow->isDisplayInitialized())
{
mCurrentPlatform->eglWindow->destroyGL();
if (!mCurrentPlatform->eglWindow->initializeDisplay(
mCurrentPlatform->osWindow, ANGLETestEnvironment::GetEGLLibrary(),
mCurrentPlatform->configParams))
mFixture->eglWindow->destroyGL();
if (!mFixture->eglWindow->initializeDisplay(mFixture->osWindow,
ANGLETestEnvironment::GetEGLLibrary(),
mCurrentParams->eglParameters))
{
FAIL() << "egl display init failed.";
FAIL() << "EGL Display init failed.";
}
}
else if (mCurrentParams->eglParameters != mFixture->eglWindow->getPlatform())
{
FAIL() << "Internal parameter conflict error.";
}
if (!mCurrentPlatform->eglWindow->initializeSurface(mCurrentPlatform->osWindow,
ANGLETestEnvironment::GetEGLLibrary(),
mCurrentPlatform->configParams))
if (!mFixture->eglWindow->initializeSurface(
mFixture->osWindow, ANGLETestEnvironment::GetEGLLibrary(), mFixture->configParams))
{
FAIL() << "egl surface init failed.";
}
if (!mDeferContextInit && !mCurrentPlatform->eglWindow->initializeContext())
if (!mDeferContextInit && !mFixture->eglWindow->initializeContext())
{
FAIL() << "GL Context init failed.";
}
@@ -495,27 +494,27 @@ void ANGLETestBase::ANGLETestTearDown()
angle::WriteDebugMessage("Exiting %s.%s\n", info->test_case_name(), info->name());
swapBuffers();
mCurrentPlatform->osWindow->messageLoop();
mFixture->osWindow->messageLoop();
if (mCurrentPlatform->eglWindow)
if (mFixture->eglWindow)
{
checkD3D11SDKLayersMessages();
}
if (mCurrentPlatform->reuseCounter++ >= kWindowReuseLimit || mForceNewDisplay)
if (mFixture->reuseCounter++ >= kWindowReuseLimit || mForceNewDisplay)
{
mCurrentPlatform->reuseCounter = 0;
mFixture->reuseCounter = 0;
getGLWindow()->destroyGL();
}
else
{
mCurrentPlatform->eglWindow->destroyContext();
mCurrentPlatform->eglWindow->destroySurface();
mFixture->eglWindow->destroyContext();
mFixture->eglWindow->destroySurface();
}
// Check for quit message
Event myEvent;
while (mCurrentPlatform->osWindow->popEvent(&myEvent))
while (mFixture->osWindow->popEvent(&myEvent))
{
if (myEvent.Type == Event::EVENT_CLOSED)
{
@@ -530,7 +529,7 @@ void ANGLETestBase::swapBuffers()
{
getGLWindow()->swap();
if (mCurrentPlatform->eglWindow)
if (mFixture->eglWindow)
{
EXPECT_EGL_SUCCESS();
}
@@ -882,15 +881,14 @@ void ANGLETestBase::checkD3D11SDKLayersMessages()
// On Windows D3D11, check ID3D11InfoQueue to see if any D3D11 SDK Layers messages
// were outputted by the test. We enable the Debug layers in Release tests as well.
if (mIgnoreD3D11SDKLayersWarnings ||
mCurrentPlatform->eglWindow->getPlatform().renderer !=
EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE ||
mCurrentPlatform->eglWindow->getDisplay() == EGL_NO_DISPLAY)
mFixture->eglWindow->getPlatform().renderer != EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE ||
mFixture->eglWindow->getDisplay() == EGL_NO_DISPLAY)
{
return;
}
const char *extensionString = static_cast<const char *>(
eglQueryString(mCurrentPlatform->eglWindow->getDisplay(), EGL_EXTENSIONS));
eglQueryString(mFixture->eglWindow->getDisplay(), EGL_EXTENSIONS));
if (!extensionString)
{
std::cout << "Error getting extension string from EGL Window." << std::endl;
@@ -915,8 +913,8 @@ void ANGLETestBase::checkD3D11SDKLayersMessages()
ASSERT_NE(nullptr, queryDisplayAttribEXT);
ASSERT_NE(nullptr, queryDeviceAttribEXT);
ASSERT_EGL_TRUE(queryDisplayAttribEXT(mCurrentPlatform->eglWindow->getDisplay(), EGL_DEVICE_EXT,
&angleDevice));
ASSERT_EGL_TRUE(
queryDisplayAttribEXT(mFixture->eglWindow->getDisplay(), EGL_DEVICE_EXT, &angleDevice));
ASSERT_EGL_TRUE(queryDeviceAttribEXT(reinterpret_cast<EGLDeviceEXT>(angleDevice),
EGL_D3D11_DEVICE_ANGLE, &device));
ID3D11Device *d3d11Device = reinterpret_cast<ID3D11Device *>(device);
@@ -970,115 +968,105 @@ void ANGLETestBase::setWindowHeight(int height)
GLWindowBase *ANGLETestBase::getGLWindow() const
{
// WGL tests are currently disabled.
assert(!mCurrentPlatform->wglWindow);
return mCurrentPlatform->eglWindow;
assert(!mFixture->wglWindow);
return mFixture->eglWindow;
}
void ANGLETestBase::setConfigRedBits(int bits)
{
mCurrentPlatform->configParams.redBits = bits;
mFixture->configParams.redBits = bits;
}
void ANGLETestBase::setConfigGreenBits(int bits)
{
mCurrentPlatform->configParams.greenBits = bits;
mFixture->configParams.greenBits = bits;
}
void ANGLETestBase::setConfigBlueBits(int bits)
{
mCurrentPlatform->configParams.blueBits = bits;
mFixture->configParams.blueBits = bits;
}
void ANGLETestBase::setConfigAlphaBits(int bits)
{
mCurrentPlatform->configParams.alphaBits = bits;
mFixture->configParams.alphaBits = bits;
}
void ANGLETestBase::setConfigDepthBits(int bits)
{
mCurrentPlatform->configParams.depthBits = bits;
mFixture->configParams.depthBits = bits;
}
void ANGLETestBase::setConfigStencilBits(int bits)
{
mCurrentPlatform->configParams.stencilBits = bits;
mFixture->configParams.stencilBits = bits;
}
void ANGLETestBase::setConfigComponentType(EGLenum componentType)
{
mCurrentPlatform->configParams.componentType = componentType;
mFixture->configParams.componentType = componentType;
}
void ANGLETestBase::setMultisampleEnabled(bool enabled)
{
mCurrentPlatform->configParams.multisample = enabled;
mFixture->configParams.multisample = enabled;
}
void ANGLETestBase::setSamples(EGLint samples)
{
mCurrentPlatform->configParams.samples = samples;
mFixture->configParams.samples = samples;
}
void ANGLETestBase::setDebugEnabled(bool enabled)
{
mCurrentPlatform->configParams.debug = enabled;
mFixture->configParams.debug = enabled;
}
void ANGLETestBase::setNoErrorEnabled(bool enabled)
{
mCurrentPlatform->configParams.noError = enabled;
mFixture->configParams.noError = enabled;
}
void ANGLETestBase::setWebGLCompatibilityEnabled(bool webglCompatibility)
{
mCurrentPlatform->configParams.webGLCompatibility = webglCompatibility;
mFixture->configParams.webGLCompatibility = webglCompatibility;
}
void ANGLETestBase::setExtensionsEnabled(bool extensionsEnabled)
{
mCurrentPlatform->configParams.extensionsEnabled = extensionsEnabled;
mFixture->configParams.extensionsEnabled = extensionsEnabled;
}
void ANGLETestBase::setRobustAccess(bool enabled)
{
mCurrentPlatform->configParams.robustAccess = enabled;
mFixture->configParams.robustAccess = enabled;
}
void ANGLETestBase::setBindGeneratesResource(bool bindGeneratesResource)
{
mCurrentPlatform->configParams.bindGeneratesResource = bindGeneratesResource;
}
void ANGLETestBase::setDebugLayersEnabled(bool enabled)
{
mCurrentPlatform->configParams.debugLayersEnabled = enabled;
mFixture->configParams.bindGeneratesResource = bindGeneratesResource;
}
void ANGLETestBase::setClientArraysEnabled(bool enabled)
{
mCurrentPlatform->configParams.clientArraysEnabled = enabled;
mFixture->configParams.clientArraysEnabled = enabled;
}
void ANGLETestBase::setRobustResourceInit(bool enabled)
{
mCurrentPlatform->configParams.robustResourceInit = enabled;
mFixture->configParams.robustResourceInit = enabled;
}
void ANGLETestBase::setContextProgramCacheEnabled(bool enabled,
angle::CacheProgramFunc cacheProgramFunc)
{
mCurrentPlatform->configParams.contextProgramCacheEnabled = enabled;
mFixture->configParams.contextProgramCacheEnabled = enabled;
gDefaultPlatformMethods.cacheProgram = cacheProgramFunc;
}
void ANGLETestBase::setContextVirtualization(bool enabled)
{
mCurrentPlatform->configParams.contextVirtualization = enabled;
}
void ANGLETestBase::setContextResetStrategy(EGLenum resetStrategy)
{
mCurrentPlatform->configParams.resetStrategy = resetStrategy;
mFixture->configParams.resetStrategy = resetStrategy;
}
void ANGLETestBase::forceNewDisplay()
@@ -1103,7 +1091,7 @@ int ANGLETestBase::getClientMinorVersion() const
EGLWindow *ANGLETestBase::getEGLWindow() const
{
return mCurrentPlatform->eglWindow;
return mFixture->eglWindow;
}
int ANGLETestBase::getWindowWidth() const
@@ -1118,12 +1106,12 @@ int ANGLETestBase::getWindowHeight() const
bool ANGLETestBase::isMultisampleEnabled() const
{
return mCurrentPlatform->eglWindow->isMultisample();
return mFixture->eglWindow->isMultisample();
}
void ANGLETestBase::setWindowVisible(bool isVisible)
{
mCurrentPlatform->osWindow->setVisible(isVisible);
mFixture->osWindow->setVisible(isVisible);
}
bool IsIntel()
@@ -1219,13 +1207,13 @@ bool IsRelease()
return !IsDebug();
}
ANGLETestBase::Platform::Platform() = default;
ANGLETestBase::Platform::~Platform() = default;
ANGLETestBase::TestFixture::TestFixture() = default;
ANGLETestBase::TestFixture::~TestFixture() = default;
EGLint ANGLETestBase::getPlatformRenderer() const
{
assert(mCurrentPlatform->eglWindow);
return mCurrentPlatform->eglWindow->getPlatform().renderer;
assert(mFixture->eglWindow);
return mFixture->eglWindow->getPlatform().renderer;
}
void ANGLETestBase::ignoreD3D11SDKLayersWarnings()
@@ -1254,7 +1242,7 @@ ANGLETestBase::ScopedIgnorePlatformMessages::~ScopedIgnorePlatformMessages()
}
OSWindow *ANGLETestBase::mOSWindowSingleton = nullptr;
std::map<angle::PlatformParameters, ANGLETestBase::Platform> ANGLETestBase::gPlatforms;
std::map<angle::PlatformParameters, ANGLETestBase::TestFixture> ANGLETestBase::gPlatforms;
Optional<EGLint> ANGLETestBase::mLastRendererType;
std::unique_ptr<angle::Library> ANGLETestEnvironment::gEGLLibrary;

15
src/tests/test_utils/ANGLETest.h
View File

@@ -360,11 +360,9 @@ class ANGLETestBase
void setExtensionsEnabled(bool extensionsEnabled);
void setRobustAccess(bool enabled);
void setBindGeneratesResource(bool bindGeneratesResource);
void setDebugLayersEnabled(bool enabled);
void setClientArraysEnabled(bool enabled);
void setRobustResourceInit(bool enabled);
void setContextProgramCacheEnabled(bool enabled, angle::CacheProgramFunc cacheProgramFunc);
void setContextVirtualization(bool enabled);
void setContextResetStrategy(EGLenum resetStrategy);
void forceNewDisplay();
@@ -387,7 +385,7 @@ class ANGLETestBase
// Allows a test to be more restrictive about platform warnings.
void treatPlatformWarningsAsErrors();
OSWindow *getOSWindow() { return mCurrentPlatform->osWindow; }
OSWindow *getOSWindow() { return mFixture->osWindow; }
GLuint get2DTexturedQuadProgram();
@@ -412,10 +410,10 @@ class ANGLETestBase
bool useInstancedDrawCalls,
GLuint numInstances);
struct Platform
struct TestFixture
{
Platform();
~Platform();
TestFixture();
~TestFixture();
EGLWindow *eglWindow = nullptr;
WGLWindow *wglWindow = nullptr;
@@ -446,8 +444,9 @@ class ANGLETestBase
// different config. This OSWindow sharing seemed to lead to driver bugs on some platforms.
static OSWindow *mOSWindowSingleton;
static std::map<angle::PlatformParameters, Platform> gPlatforms;
Platform *mCurrentPlatform;
static std::map<angle::PlatformParameters, TestFixture> gPlatforms;
const angle::PlatformParameters *mCurrentParams;
TestFixture *mFixture;
// Workaround for NVIDIA not being able to share a window with OpenGL and Vulkan.
static Optional<EGLint> mLastRendererType;

49
src/tests/test_utils/angle_test_configs.cpp
View File

@@ -12,47 +12,51 @@
namespace angle
{
PlatformParameters::PlatformParameters() : PlatformParameters(2, 0, EGLPlatformParameters()) {}
PlatformParameters::PlatformParameters() : PlatformParameters(2, 0, GLESDriverType::AngleEGL) {}
PlatformParameters::PlatformParameters(EGLint majorVersion,
EGLint minorVersion,
const EGLPlatformParameters &eglPlatformParameters)
: majorVersion(majorVersion),
minorVersion(minorVersion),
: driver(GLESDriverType::AngleEGL),
eglParameters(eglPlatformParameters),
driver(GLESDriverType::AngleEGL)
{}
majorVersion(majorVersion),
minorVersion(minorVersion)
{
initDefaultParameters();
}
PlatformParameters::PlatformParameters(EGLint majorVersion,
EGLint minorVersion,
GLESDriverType driver)
: majorVersion(majorVersion), minorVersion(minorVersion), driver(driver)
{}
: driver(driver), majorVersion(majorVersion), minorVersion(minorVersion)
{
initDefaultParameters();
}
EGLint PlatformParameters::getRenderer() const
{
return eglParameters.renderer;
}
void PlatformParameters::initDefaultParameters()
{
// Default debug layers to enabled in tests.
eglParameters.debugLayersEnabled = EGL_TRUE;
}
bool operator<(const PlatformParameters &a, const PlatformParameters &b)
{
if (a.majorVersion != b.majorVersion)
{
return a.majorVersion < b.majorVersion;
}
if (a.minorVersion != b.minorVersion)
{
return a.minorVersion < b.minorVersion;
}
return a.eglParameters < b.eglParameters;
return a.tie() < b.tie();
}
bool operator==(const PlatformParameters &a, const PlatformParameters &b)
{
return (a.majorVersion == b.majorVersion) && (a.minorVersion == b.minorVersion) &&
(a.eglParameters == b.eglParameters);
return a.tie() == b.tie();
}
bool operator!=(const PlatformParameters &a, const PlatformParameters &b)
{
return a.tie() != b.tie();
}
std::ostream &operator<<(std::ostream &stream, const PlatformParameters &pp)
@@ -160,6 +164,11 @@ std::ostream &operator<<(std::ostream &stream, const PlatformParameters &pp)
break;
}
if (pp.eglParameters.contextVirtualization == EGL_FALSE)
{
stream << "_NO_VIRTUAL";
}
return stream;
}

15
src/tests/test_utils/angle_test_configs.h
View File

@@ -45,10 +45,14 @@ struct PlatformParameters
EGLint getRenderer() const;
void initDefaultParameters();
auto tie() const { return std::tie(driver, eglParameters, majorVersion, minorVersion); }
GLESDriverType driver;
EGLPlatformParameters eglParameters;
EGLint majorVersion;
EGLint minorVersion;
EGLPlatformParameters eglParameters;
GLESDriverType driver;
};
bool operator<(const PlatformParameters &a, const PlatformParameters &b);
@@ -173,6 +177,13 @@ PlatformParameters ES3_VULKAN_NULL();
PlatformParameters ES2_WGL();
PlatformParameters ES3_WGL();
inline PlatformParameters WithNoVirtualContexts(const PlatformParameters &params)
{
PlatformParameters withNoVirtualContexts = params;
withNoVirtualContexts.eglParameters.contextVirtualization = EGL_FALSE;
return withNoVirtualContexts;
}
} // namespace angle
#endif // ANGLE_TEST_CONFIGS_H_

11
src/tests/test_utils/angle_test_instantiate.cpp
View File

@@ -36,10 +36,10 @@ bool IsANGLEConfigSupported(const PlatformParameters &param, OSWindow *osWindow)
eglLibrary.reset(angle::OpenSharedLibrary(ANGLE_EGL_LIBRARY_NAME));
#endif
EGLWindow *eglWindow =
EGLWindow::New(param.majorVersion, param.minorVersion, param.eglParameters);
EGLWindow *eglWindow = EGLWindow::New(param.majorVersion, param.minorVersion);
ConfigParameters configParams;
bool result = eglWindow->initializeGL(osWindow, eglLibrary.get(), configParams);
bool result =
eglWindow->initializeGL(osWindow, eglLibrary.get(), param.eglParameters, configParams);
eglWindow->destroyGL();
EGLWindow::Delete(&eglWindow);
return result;
@@ -52,7 +52,8 @@ bool IsWGLConfigSupported(const PlatformParameters &param, OSWindow *osWindow)
WGLWindow *wglWindow = WGLWindow::New(param.majorVersion, param.minorVersion);
ConfigParameters configParams;
bool result = wglWindow->initializeGL(osWindow, openglLibrary.get(), configParams);
bool result =
wglWindow->initializeGL(osWindow, openglLibrary.get(), param.eglParameters, configParams);
wglWindow->destroyGL();
WGLWindow::Delete(&wglWindow);
return result;
@@ -433,6 +434,8 @@ bool IsPlatformAvailable(const PlatformParameters &param)
<< " because it is not available." << std::endl;
}
// Uncomment this to print available platforms.
// std::cout << "Platform: " << param << " (" << paramAvailabilityCache.size() << ")\n";
return result;
}
}

68
util/EGLPlatformParameters.h
View File

@@ -8,32 +8,72 @@
#ifndef UTIL_EGLPLATFORMPARAMETERS_H_
#define UTIL_EGLPLATFORMPARAMETERS_H_
#include <EGL/eglplatform.h>
#include "util/util_gl.h"
#include "util/util_export.h"
#include <tuple>
struct ANGLE_UTIL_EXPORT EGLPlatformParameters
namespace angle
{
EGLint renderer;
EGLint majorVersion;
EGLint minorVersion;
EGLint deviceType;
EGLint presentPath;
struct PlatformMethods;
} // namespace angle
struct EGLPlatformParameters
{
EGLPlatformParameters() = default;
explicit EGLPlatformParameters(EGLint renderer) : renderer(renderer) {}
EGLPlatformParameters();
explicit EGLPlatformParameters(EGLint renderer);
EGLPlatformParameters(EGLint renderer,
EGLint majorVersion,
EGLint minorVersion,
EGLint deviceType);
EGLint deviceType)
: renderer(renderer),
majorVersion(majorVersion),
minorVersion(minorVersion),
deviceType(deviceType)
{}
EGLPlatformParameters(EGLint renderer,
EGLint majorVersion,
EGLint minorVersion,
EGLint deviceType,
EGLint presentPath);
EGLint presentPath)
: renderer(renderer),
majorVersion(majorVersion),
minorVersion(minorVersion),
deviceType(deviceType),
presentPath(presentPath)
{}
auto tie() const
{
return std::tie(renderer, majorVersion, minorVersion, deviceType, presentPath,
debugLayersEnabled, contextVirtualization, platformMethods);
}
EGLint renderer = EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE;
EGLint majorVersion = EGL_DONT_CARE;
EGLint minorVersion = EGL_DONT_CARE;
EGLint deviceType = EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE;
EGLint presentPath = EGL_DONT_CARE;
EGLint debugLayersEnabled = EGL_DONT_CARE;
EGLint contextVirtualization = EGL_DONT_CARE;
angle::PlatformMethods *platformMethods = nullptr;
};
ANGLE_UTIL_EXPORT bool operator<(const EGLPlatformParameters &a, const EGLPlatformParameters &b);
ANGLE_UTIL_EXPORT bool operator==(const EGLPlatformParameters &a, const EGLPlatformParameters &b);
inline bool operator<(const EGLPlatformParameters &a, const EGLPlatformParameters &b)
{
return a.tie() < b.tie();
}
inline bool operator==(const EGLPlatformParameters &a, const EGLPlatformParameters &b)
{
return a.tie() == b.tie();
}
inline bool operator!=(const EGLPlatformParameters &a, const EGLPlatformParameters &b)
{
return a.tie() != b.tie();
}
#endif // UTIL_EGLPLATFORMPARAMETERS_H_

137
util/EGLWindow.cpp
View File

@@ -16,81 +16,9 @@
#include "util/OSWindow.h"
#include "util/system_utils.h"
EGLPlatformParameters::EGLPlatformParameters()
: renderer(EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE),
majorVersion(EGL_DONT_CARE),
minorVersion(EGL_DONT_CARE),
deviceType(EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE),
presentPath(EGL_DONT_CARE)
{}
EGLPlatformParameters::EGLPlatformParameters(EGLint renderer)
: renderer(renderer),
majorVersion(EGL_DONT_CARE),
minorVersion(EGL_DONT_CARE),
deviceType(EGL_PLATFORM_ANGLE_DEVICE_TYPE_HARDWARE_ANGLE),
presentPath(EGL_DONT_CARE)
{}
EGLPlatformParameters::EGLPlatformParameters(EGLint renderer,
EGLint majorVersion,
EGLint minorVersion,
EGLint deviceType)
: renderer(renderer),
majorVersion(majorVersion),
minorVersion(minorVersion),
deviceType(deviceType),
presentPath(EGL_DONT_CARE)
{}
EGLPlatformParameters::EGLPlatformParameters(EGLint renderer,
EGLint majorVersion,
EGLint minorVersion,
EGLint deviceType,
EGLint presentPath)
: renderer(renderer),
majorVersion(majorVersion),
minorVersion(minorVersion),
deviceType(deviceType),
presentPath(presentPath)
{}
bool operator<(const EGLPlatformParameters &a, const EGLPlatformParameters &b)
{
if (a.renderer != b.renderer)
{
return a.renderer < b.renderer;
}
if (a.majorVersion != b.majorVersion)
{
return a.majorVersion < b.majorVersion;
}
if (a.minorVersion != b.minorVersion)
{
return a.minorVersion < b.minorVersion;
}
if (a.deviceType != b.deviceType)
{
return a.deviceType < b.deviceType;
}
return a.presentPath < b.presentPath;
}
bool operator==(const EGLPlatformParameters &a, const EGLPlatformParameters &b)
{
return (a.renderer == b.renderer) && (a.majorVersion == b.majorVersion) &&
(a.minorVersion == b.minorVersion) && (a.deviceType == b.deviceType) &&
(a.presentPath == b.presentPath);
}
// ConfigParameters implementation.
ConfigParameters::ConfigParameters()
: platformMethods(nullptr),
redBits(-1),
: redBits(-1),
greenBits(-1),
blueBits(-1),
alphaBits(-1),
@@ -114,14 +42,6 @@ void ConfigParameters::reset()
*this = ConfigParameters();
}
// static
bool ConfigParameters::CanShareDisplay(const ConfigParameters &a, const ConfigParameters &b)
{
return a.debugLayersEnabled == b.debugLayersEnabled &&
a.contextVirtualization == b.contextVirtualization &&
a.platformMethods == b.platformMethods;
}
// GLWindowBase implementation.
GLWindowBase::GLWindowBase(EGLint glesMajorVersion, EGLint glesMinorVersion)
: mClientMajorVersion(glesMajorVersion), mClientMinorVersion(glesMinorVersion)
@@ -130,17 +50,14 @@ GLWindowBase::GLWindowBase(EGLint glesMajorVersion, EGLint glesMinorVersion)
GLWindowBase::~GLWindowBase() = default;
// EGLWindow implementation.
EGLWindow::EGLWindow(EGLint glesMajorVersion,
EGLint glesMinorVersion,
const EGLPlatformParameters &platform)
EGLWindow::EGLWindow(EGLint glesMajorVersion, EGLint glesMinorVersion)
: GLWindowBase(glesMajorVersion, glesMinorVersion),
mConfig(0),
mDisplay(EGL_NO_DISPLAY),
mSurface(EGL_NO_SURFACE),
mContext(EGL_NO_CONTEXT),
mEGLMajorVersion(0),
mEGLMinorVersion(0),
mPlatform(platform)
mEGLMinorVersion(0)
{}
EGLWindow::~EGLWindow()
@@ -175,11 +92,12 @@ EGLContext EGLWindow::getContext() const
bool EGLWindow::initializeGL(OSWindow *osWindow,
angle::Library *glWindowingLibrary,
const ConfigParameters &params)
const EGLPlatformParameters &platformParams,
const ConfigParameters &configParams)
{
if (!initializeDisplay(osWindow, glWindowingLibrary, params))
if (!initializeDisplay(osWindow, glWindowingLibrary, platformParams))
return false;
if (!initializeSurface(osWindow, glWindowingLibrary, params))
if (!initializeSurface(osWindow, glWindowingLibrary, configParams))
return false;
if (!initializeContext())
return false;
@@ -188,10 +106,8 @@ bool EGLWindow::initializeGL(OSWindow *osWindow,
bool EGLWindow::initializeDisplay(OSWindow *osWindow,
angle::Library *glWindowingLibrary,
const ConfigParameters &params)
const EGLPlatformParameters &params)
{
mConfigParams = params;
#if defined(ANGLE_USE_UTIL_LOADER)
PFNEGLGETPROCADDRESSPROC getProcAddress;
glWindowingLibrary->getAs("eglGetProcAddress", &getProcAddress);
@@ -206,19 +122,19 @@ bool EGLWindow::initializeDisplay(OSWindow *osWindow,
std::vector<EGLAttrib> displayAttributes;
displayAttributes.push_back(EGL_PLATFORM_ANGLE_TYPE_ANGLE);
displayAttributes.push_back(mPlatform.renderer);
displayAttributes.push_back(params.renderer);
displayAttributes.push_back(EGL_PLATFORM_ANGLE_MAX_VERSION_MAJOR_ANGLE);
displayAttributes.push_back(mPlatform.majorVersion);
displayAttributes.push_back(params.majorVersion);
displayAttributes.push_back(EGL_PLATFORM_ANGLE_MAX_VERSION_MINOR_ANGLE);
displayAttributes.push_back(mPlatform.minorVersion);
displayAttributes.push_back(params.minorVersion);
if (mPlatform.deviceType != EGL_DONT_CARE)
if (params.deviceType != EGL_DONT_CARE)
{
displayAttributes.push_back(EGL_PLATFORM_ANGLE_DEVICE_TYPE_ANGLE);
displayAttributes.push_back(mPlatform.deviceType);
displayAttributes.push_back(params.deviceType);
}
if (mPlatform.presentPath != EGL_DONT_CARE)
if (params.presentPath != EGL_DONT_CARE)
{
const char *extensionString =
static_cast<const char *>(eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS));
@@ -229,30 +145,28 @@ bool EGLWindow::initializeDisplay(OSWindow *osWindow,
}
displayAttributes.push_back(EGL_EXPERIMENTAL_PRESENT_PATH_ANGLE);
displayAttributes.push_back(mPlatform.presentPath);
displayAttributes.push_back(params.presentPath);
}
// Set debug layer settings if requested.
if (mConfigParams.debugLayersEnabled.valid())
if (params.debugLayersEnabled != EGL_DONT_CARE)
{
displayAttributes.push_back(EGL_PLATFORM_ANGLE_DEBUG_LAYERS_ENABLED_ANGLE);
displayAttributes.push_back(mConfigParams.debugLayersEnabled.value() ? EGL_TRUE
: EGL_FALSE);
displayAttributes.push_back(params.debugLayersEnabled);
}
if (mConfigParams.contextVirtualization.valid())
if (params.contextVirtualization != EGL_DONT_CARE)
{
displayAttributes.push_back(EGL_PLATFORM_ANGLE_CONTEXT_VIRTUALIZATION_ANGLE);
displayAttributes.push_back(mConfigParams.contextVirtualization.value() ? EGL_TRUE
: EGL_FALSE);
displayAttributes.push_back(params.contextVirtualization);
}
if (mConfigParams.platformMethods)
if (params.platformMethods)
{
static_assert(sizeof(EGLAttrib) == sizeof(mConfigParams.platformMethods),
static_assert(sizeof(EGLAttrib) == sizeof(params.platformMethods),
"Unexpected pointer size");
displayAttributes.push_back(EGL_PLATFORM_ANGLE_PLATFORM_METHODS_ANGLEX);
displayAttributes.push_back(reinterpret_cast<EGLAttrib>(mConfigParams.platformMethods));
displayAttributes.push_back(reinterpret_cast<EGLAttrib>(params.platformMethods));
}
displayAttributes.push_back(EGL_NONE);
@@ -272,6 +186,7 @@ bool EGLWindow::initializeDisplay(OSWindow *osWindow,
return false;
}
mPlatform = params;
return true;
}
@@ -658,11 +573,9 @@ void GLWindowBase::Delete(GLWindowBase **window)
}
// static
EGLWindow *EGLWindow::New(EGLint glesMajorVersion,
EGLint glesMinorVersion,
const EGLPlatformParameters &platform)
EGLWindow *EGLWindow::New(EGLint glesMajorVersion, EGLint glesMinorVersion)
{
return new EGLWindow(glesMajorVersion, glesMinorVersion, platform);
return new EGLWindow(glesMajorVersion, glesMinorVersion);
}
// static

44
util/EGLWindow.h
View File

@@ -33,13 +33,6 @@ struct ANGLE_UTIL_EXPORT ConfigParameters
void reset();
static bool CanShareDisplay(const ConfigParameters &a, const ConfigParameters &b);
// Display parameters.
Optional<bool> debugLayersEnabled;
Optional<bool> contextVirtualization;
angle::PlatformMethods *platformMethods;
// Surface and Context parameters.
int redBits;
int greenBits;
@@ -76,22 +69,21 @@ class ANGLE_UTIL_EXPORT GLWindowBase : angle::NonCopyable
virtual bool initializeGL(OSWindow *osWindow,
angle::Library *glWindowingLibrary,
const ConfigParameters &config) = 0;
virtual bool isGLInitialized() const = 0;
virtual void swap() = 0;
virtual void destroyGL() = 0;
virtual bool makeCurrent() = 0;
virtual bool hasError() const = 0;
virtual bool setSwapInterval(EGLint swapInterval) = 0;
const EGLPlatformParameters &platformParams,
const ConfigParameters &configParams) = 0;
virtual bool isGLInitialized() const = 0;
virtual void swap() = 0;
virtual void destroyGL() = 0;
virtual bool makeCurrent() = 0;
virtual bool hasError() const = 0;
virtual bool setSwapInterval(EGLint swapInterval) = 0;
bool isMultisample() const { return mConfigParams.multisample; }
bool isDebugEnabled() const { return mConfigParams.debug; }
const angle::PlatformMethods *getPlatformMethods() const
{
return mConfigParams.platformMethods;
}
const angle::PlatformMethods *getPlatformMethods() const { return mPlatform.platformMethods; }
const EGLPlatformParameters &getPlatform() const { return mPlatform; }
const ConfigParameters &getConfigParams() const { return mConfigParams; }
protected:
@@ -100,20 +92,18 @@ class ANGLE_UTIL_EXPORT GLWindowBase : angle::NonCopyable
EGLint mClientMajorVersion;
EGLint mClientMinorVersion;
EGLPlatformParameters mPlatform;
ConfigParameters mConfigParams;
};
class ANGLE_UTIL_EXPORT EGLWindow : public GLWindowBase
{
public:
static EGLWindow *New(EGLint glesMajorVersion,
EGLint glesMinorVersion,
const EGLPlatformParameters &platform);
static EGLWindow *New(EGLint glesMajorVersion, EGLint glesMinorVersion);
static void Delete(EGLWindow **window);
static EGLBoolean FindEGLConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *config);
const EGLPlatformParameters &getPlatform() const { return mPlatform; }
EGLConfig getConfig() const;
EGLDisplay getDisplay() const;
EGLSurface getSurface() const;
@@ -122,7 +112,8 @@ class ANGLE_UTIL_EXPORT EGLWindow : public GLWindowBase
// Internally initializes the Display, Surface and Context.
bool initializeGL(OSWindow *osWindow,
angle::Library *glWindowingLibrary,
const ConfigParameters &params) override;
const EGLPlatformParameters &platformParams,
const ConfigParameters &configParams) override;
bool isGLInitialized() const override;
void swap() override;
@@ -134,7 +125,7 @@ class ANGLE_UTIL_EXPORT EGLWindow : public GLWindowBase
// Only initializes the Display.
bool initializeDisplay(OSWindow *osWindow,
angle::Library *glWindowingLibrary,
const ConfigParameters &params);
const EGLPlatformParameters &params);
// Only initializes the Surface.
bool initializeSurface(OSWindow *osWindow,
@@ -153,9 +144,7 @@ class ANGLE_UTIL_EXPORT EGLWindow : public GLWindowBase
bool isDisplayInitialized() const { return mDisplay != EGL_NO_DISPLAY; }
private:
EGLWindow(EGLint glesMajorVersion,
EGLint glesMinorVersion,
const EGLPlatformParameters &platform);
EGLWindow(EGLint glesMajorVersion, EGLint glesMinorVersion);
~EGLWindow() override;
@@ -166,7 +155,6 @@ class ANGLE_UTIL_EXPORT EGLWindow : public GLWindowBase
EGLint mEGLMajorVersion;
EGLint mEGLMinorVersion;
EGLPlatformParameters mPlatform;
};
ANGLE_UTIL_EXPORT bool CheckExtensionExists(const char *allExtensions, const std::string &extName);

9
util/windows/WGLWindow.cpp
View File

@@ -71,9 +71,9 @@ WGLWindow::~WGLWindow() {}
// Internally initializes GL resources.
bool WGLWindow::initializeGL(OSWindow *osWindow,
angle::Library *glWindowingLibrary,
const ConfigParameters &params)
const EGLPlatformParameters &platformParams,
const ConfigParameters &configParams)
{
mConfigParams = params;
glWindowingLibrary->getAs("wglGetProcAddress", &gCurrentWGLGetProcAddress);
if (!gCurrentWGLGetProcAddress)
@@ -141,7 +141,7 @@ bool WGLWindow::initializeGL(OSWindow *osWindow,
return false;
}
if (mConfigParams.webGLCompatibility.valid() || mConfigParams.robustResourceInit.valid())
if (configParams.webGLCompatibility.valid() || configParams.robustResourceInit.valid())
{
std::cerr << "WGLWindow does not support the requested feature set." << std::endl;
return false;
@@ -172,6 +172,9 @@ bool WGLWindow::initializeGL(OSWindow *osWindow,
return false;
}
mPlatform = platformParams;
mConfigParams = configParams;
angle::LoadGLES(GetProcAddressWithFallback);
return true;
}

3
util/windows/WGLWindow.h
View File

@@ -30,7 +30,8 @@ class ANGLE_UTIL_EXPORT WGLWindow : public GLWindowBase
// Internally initializes GL resources.
bool initializeGL(OSWindow *osWindow,
angle::Library *glWindowingLibrary,
const ConfigParameters &params) override;
const EGLPlatformParameters &platformParams,
const ConfigParameters &configParams) override;
void destroyGL() override;
bool isGLInitialized() const override;