diff options
Diffstat (limited to 'src/3rdparty/angle/src/libANGLE/Surface.cpp')
| -rw-r--r-- | src/3rdparty/angle/src/libANGLE/Surface.cpp | 369 |
1 files changed, 296 insertions, 73 deletions
diff --git a/src/3rdparty/angle/src/libANGLE/Surface.cpp b/src/3rdparty/angle/src/libANGLE/Surface.cpp index b5ed0ff5a6..746da03778 100644 --- a/src/3rdparty/angle/src/libANGLE/Surface.cpp +++ b/src/3rdparty/angle/src/libANGLE/Surface.cpp @@ -10,29 +10,44 @@ #include "libANGLE/Surface.h" -#include "libANGLE/Config.h" -#include "libANGLE/Framebuffer.h" -#include "libANGLE/Texture.h" - #include <EGL/eglext.h> #include <iostream> +#include "libANGLE/Config.h" +#include "libANGLE/Context.h" +#include "libANGLE/Display.h" +#include "libANGLE/Framebuffer.h" +#include "libANGLE/Texture.h" +#include "libANGLE/Thread.h" +#include "libANGLE/formatutils.h" +#include "libANGLE/renderer/EGLImplFactory.h" + namespace egl { -Surface::Surface(rx::SurfaceImpl *impl, - EGLint surfaceType, - const egl::Config *config, - const AttributeMap &attributes) +SurfaceState::SurfaceState(const egl::Config *configIn, const AttributeMap &attributesIn) + : defaultFramebuffer(nullptr), config(configIn), attributes(attributesIn) +{ +} + +Surface::Surface(EGLint surfaceType, const egl::Config *config, const AttributeMap &attributes) : FramebufferAttachmentObject(), - mImplementation(impl), - mDefaultFramebuffer(nullptr), + mState(config, attributes), + mImplementation(nullptr), mCurrentCount(0), mDestroyed(false), mType(surfaceType), - mConfig(config), mPostSubBufferRequested(false), + mLargestPbuffer(false), + mGLColorspace(EGL_GL_COLORSPACE_LINEAR), + mVGAlphaFormat(EGL_VG_ALPHA_FORMAT_NONPRE), + mVGColorspace(EGL_VG_COLORSPACE_sRGB), + mMipmapTexture(false), + mMipmapLevel(0), + mHorizontalResolution(EGL_UNKNOWN), + mVerticalResolution(EGL_UNKNOWN), + mMultisampleResolve(EGL_MULTISAMPLE_RESOLVE_DEFAULT), mFixedSize(false), mFixedWidth(0), mFixedHeight(0), @@ -41,75 +56,135 @@ Surface::Surface(rx::SurfaceImpl *impl, // FIXME: Determine actual pixel aspect ratio mPixelAspectRatio(static_cast<EGLint>(1.0 * EGL_DISPLAY_SCALING)), mRenderBuffer(EGL_BACK_BUFFER), - mSwapBehavior(impl->getSwapBehavior()), + mSwapBehavior(EGL_NONE), mOrientation(0), - mTexture() + mTexture(), + mBackFormat(config->renderTargetFormat), + mDSFormat(config->depthStencilFormat) { mPostSubBufferRequested = (attributes.get(EGL_POST_SUB_BUFFER_SUPPORTED_NV, EGL_FALSE) == EGL_TRUE); mFlexibleSurfaceCompatibilityRequested = (attributes.get(EGL_FLEXIBLE_SURFACE_COMPATIBILITY_SUPPORTED_ANGLE, EGL_FALSE) == EGL_TRUE); + if (mType == EGL_PBUFFER_BIT) + { + mLargestPbuffer = (attributes.get(EGL_LARGEST_PBUFFER, EGL_FALSE) == EGL_TRUE); + } + + mGLColorspace = + static_cast<EGLenum>(attributes.get(EGL_GL_COLORSPACE, EGL_GL_COLORSPACE_LINEAR)); + mVGAlphaFormat = + static_cast<EGLenum>(attributes.get(EGL_VG_ALPHA_FORMAT, EGL_VG_ALPHA_FORMAT_NONPRE)); + mVGColorspace = static_cast<EGLenum>(attributes.get(EGL_VG_COLORSPACE, EGL_VG_COLORSPACE_sRGB)); + mMipmapTexture = (attributes.get(EGL_MIPMAP_TEXTURE, EGL_FALSE) == EGL_TRUE); + mDirectComposition = (attributes.get(EGL_DIRECT_COMPOSITION_ANGLE, EGL_FALSE) == EGL_TRUE); + mRobustResourceInitialization = + (attributes.get(EGL_ROBUST_RESOURCE_INITIALIZATION_ANGLE, EGL_FALSE) == EGL_TRUE); + mFixedSize = (attributes.get(EGL_FIXED_SIZE_ANGLE, EGL_FALSE) == EGL_TRUE); if (mFixedSize) { - mFixedWidth = attributes.get(EGL_WIDTH, 0); - mFixedHeight = attributes.get(EGL_HEIGHT, 0); + mFixedWidth = static_cast<size_t>(attributes.get(EGL_WIDTH, 0)); + mFixedHeight = static_cast<size_t>(attributes.get(EGL_HEIGHT, 0)); } if (mType != EGL_WINDOW_BIT) { - mTextureFormat = attributes.get(EGL_TEXTURE_FORMAT, EGL_NO_TEXTURE); - mTextureTarget = attributes.get(EGL_TEXTURE_TARGET, EGL_NO_TEXTURE); + mTextureFormat = static_cast<EGLenum>(attributes.get(EGL_TEXTURE_FORMAT, EGL_NO_TEXTURE)); + mTextureTarget = static_cast<EGLenum>(attributes.get(EGL_TEXTURE_TARGET, EGL_NO_TEXTURE)); } - mOrientation = attributes.get(EGL_SURFACE_ORIENTATION_ANGLE, 0); - - mDefaultFramebuffer = createDefaultFramebuffer(); - ASSERT(mDefaultFramebuffer != nullptr); + mOrientation = static_cast<EGLint>(attributes.get(EGL_SURFACE_ORIENTATION_ANGLE, 0)); } Surface::~Surface() { +} + +rx::FramebufferAttachmentObjectImpl *Surface::getAttachmentImpl() const +{ + return mImplementation; +} + +Error Surface::destroyImpl(const Display *display) +{ + if (mState.defaultFramebuffer) + { + mState.defaultFramebuffer->destroyDefault(display); + } + if (mImplementation) + { + mImplementation->destroy(display); + } + if (mTexture.get()) { if (mImplementation) { - mImplementation->releaseTexImage(EGL_BACK_BUFFER); + ANGLE_TRY(mImplementation->releaseTexImage(EGL_BACK_BUFFER)); } - mTexture->releaseTexImageFromSurface(); - mTexture.set(nullptr); + auto glErr = mTexture->releaseTexImageFromSurface(display->getProxyContext()); + if (glErr.isError()) + { + return Error(EGL_BAD_SURFACE); + } + mTexture.set(nullptr, nullptr); } - SafeDelete(mDefaultFramebuffer); + if (mState.defaultFramebuffer) + { + mState.defaultFramebuffer->onDestroy(display->getProxyContext()); + } + SafeDelete(mState.defaultFramebuffer); SafeDelete(mImplementation); + + delete this; + return NoError(); +} + +Error Surface::initialize(const Display *display) +{ + ANGLE_TRY(mImplementation->initialize(display)); + + // Initialized here since impl is nullptr in the constructor. + // Must happen after implementation initialize for Android. + mSwapBehavior = mImplementation->getSwapBehavior(); + + // Must happen after implementation initialize for OSX. + mState.defaultFramebuffer = createDefaultFramebuffer(display); + ASSERT(mState.defaultFramebuffer != nullptr); + + return NoError(); } -void Surface::setIsCurrent(bool isCurrent) +Error Surface::setIsCurrent(const gl::Context *context, bool isCurrent) { if (isCurrent) { mCurrentCount++; + return NoError(); } - else + + ASSERT(mCurrentCount > 0); + mCurrentCount--; + if (mCurrentCount == 0 && mDestroyed) { - ASSERT(mCurrentCount > 0); - mCurrentCount--; - if (mCurrentCount == 0 && mDestroyed) - { - delete this; - } + ASSERT(context); + return destroyImpl(context->getCurrentDisplay()); } + return NoError(); } -void Surface::onDestroy() +Error Surface::onDestroy(const Display *display) { mDestroyed = true; if (mCurrentCount == 0) { - delete this; + return destroyImpl(display); } + return NoError(); } EGLint Surface::getType() const @@ -117,14 +192,23 @@ EGLint Surface::getType() const return mType; } -Error Surface::swap() +Error Surface::swap(const gl::Context *context) +{ + return mImplementation->swap(context); +} + +Error Surface::swapWithDamage(const gl::Context *context, EGLint *rects, EGLint n_rects) { - return mImplementation->swap(); + return mImplementation->swapWithDamage(context, rects, n_rects); } -Error Surface::postSubBuffer(EGLint x, EGLint y, EGLint width, EGLint height) +Error Surface::postSubBuffer(const gl::Context *context, + EGLint x, + EGLint y, + EGLint width, + EGLint height) { - return mImplementation->postSubBuffer(x, y, width, height); + return mImplementation->postSubBuffer(context, x, y, width, height); } Error Surface::querySurfacePointerANGLE(EGLint attribute, void **value) @@ -142,9 +226,30 @@ void Surface::setSwapInterval(EGLint interval) mImplementation->setSwapInterval(interval); } +void Surface::setMipmapLevel(EGLint level) +{ + // Level is set but ignored + UNIMPLEMENTED(); + mMipmapLevel = level; +} + +void Surface::setMultisampleResolve(EGLenum resolve) +{ + // Behaviour is set but ignored + UNIMPLEMENTED(); + mMultisampleResolve = resolve; +} + +void Surface::setSwapBehavior(EGLenum behavior) +{ + // Behaviour is set but ignored + UNIMPLEMENTED(); + mSwapBehavior = behavior; +} + const Config *Surface::getConfig() const { - return mConfig; + return mState.config; } EGLint Surface::getPixelAspectRatio() const @@ -172,6 +277,51 @@ EGLenum Surface::getTextureTarget() const return mTextureTarget; } +bool Surface::getLargestPbuffer() const +{ + return mLargestPbuffer; +} + +EGLenum Surface::getGLColorspace() const +{ + return mGLColorspace; +} + +EGLenum Surface::getVGAlphaFormat() const +{ + return mVGAlphaFormat; +} + +EGLenum Surface::getVGColorspace() const +{ + return mVGColorspace; +} + +bool Surface::getMipmapTexture() const +{ + return mMipmapTexture; +} + +EGLint Surface::getMipmapLevel() const +{ + return mMipmapLevel; +} + +EGLint Surface::getHorizontalResolution() const +{ + return mHorizontalResolution; +} + +EGLint Surface::getVerticalResolution() const +{ + return mVerticalResolution; +} + +EGLenum Surface::getMultisampleResolve() const +{ + return mMultisampleResolve; +} + EGLint Surface::isFixedSize() const { return mFixedSize; @@ -187,42 +337,60 @@ EGLint Surface::getHeight() const return mFixedSize ? static_cast<EGLint>(mFixedHeight) : mImplementation->getHeight(); } -Error Surface::bindTexImage(gl::Texture *texture, EGLint buffer) +Error Surface::bindTexImage(const gl::Context *context, gl::Texture *texture, EGLint buffer) { ASSERT(!mTexture.get()); + ANGLE_TRY(mImplementation->bindTexImage(texture, buffer)); + + auto glErr = texture->bindTexImageFromSurface(context, this); + if (glErr.isError()) + { + return Error(EGL_BAD_SURFACE); + } + mTexture.set(context, texture); - texture->bindTexImageFromSurface(this); - mTexture.set(texture); - return mImplementation->bindTexImage(texture, buffer); + return NoError(); } -Error Surface::releaseTexImage(EGLint buffer) +Error Surface::releaseTexImage(const gl::Context *context, EGLint buffer) { + ASSERT(context); + + ANGLE_TRY(mImplementation->releaseTexImage(buffer)); + ASSERT(mTexture.get()); - mTexture->releaseTexImageFromSurface(); - mTexture.set(nullptr); + auto glErr = mTexture->releaseTexImageFromSurface(context); + if (glErr.isError()) + { + return Error(EGL_BAD_SURFACE); + } + mTexture.set(context, nullptr); - return mImplementation->releaseTexImage(buffer); + return NoError(); } -void Surface::releaseTexImageFromTexture() +Error Surface::getSyncValues(EGLuint64KHR *ust, EGLuint64KHR *msc, EGLuint64KHR *sbc) +{ + return mImplementation->getSyncValues(ust, msc, sbc); +} + +void Surface::releaseTexImageFromTexture(const gl::Context *context) { ASSERT(mTexture.get()); - mTexture.set(nullptr); + mTexture.set(context, nullptr); } -gl::Extents Surface::getAttachmentSize(const gl::FramebufferAttachment::Target & /*target*/) const +gl::Extents Surface::getAttachmentSize(const gl::ImageIndex & /*target*/) const { return gl::Extents(getWidth(), getHeight(), 1); } -GLenum Surface::getAttachmentInternalFormat(const gl::FramebufferAttachment::Target &target) const +const gl::Format &Surface::getAttachmentFormat(GLenum binding, const gl::ImageIndex &target) const { - const egl::Config *config = getConfig(); - return (target.binding() == GL_BACK ? config->renderTargetFormat : config->depthStencilFormat); + return (binding == GL_BACK ? mBackFormat : mDSFormat); } -GLsizei Surface::getAttachmentSamples(const gl::FramebufferAttachment::Target &target) const +GLsizei Surface::getAttachmentSamples(const gl::ImageIndex &target) const { return getConfig()->samples; } @@ -233,29 +401,84 @@ GLuint Surface::getId() const return 0; } -gl::Framebuffer *Surface::createDefaultFramebuffer() +gl::Framebuffer *Surface::createDefaultFramebuffer(const Display *display) { - gl::Framebuffer *framebuffer = new gl::Framebuffer(mImplementation); + return new gl::Framebuffer(display, this); +} - GLenum drawBufferState = GL_BACK; - framebuffer->setDrawBuffers(1, &drawBufferState); - framebuffer->setReadBuffer(GL_BACK); +gl::InitState Surface::initState(const gl::ImageIndex & /*imageIndex*/) const +{ + // TODO(jmadill): Lazy surface init. + return gl::InitState::Initialized; +} - framebuffer->setAttachment(GL_FRAMEBUFFER_DEFAULT, GL_BACK, gl::ImageIndex::MakeInvalid(), - this); +void Surface::setInitState(const gl::ImageIndex & /*imageIndex*/, gl::InitState /*initState*/) +{ + // No-op. +} - if (mConfig->depthSize > 0) - { - framebuffer->setAttachment(GL_FRAMEBUFFER_DEFAULT, GL_DEPTH, gl::ImageIndex::MakeInvalid(), - this); - } +WindowSurface::WindowSurface(rx::EGLImplFactory *implFactory, + const egl::Config *config, + EGLNativeWindowType window, + const AttributeMap &attribs) + : Surface(EGL_WINDOW_BIT, config, attribs) +{ + mImplementation = implFactory->createWindowSurface(mState, window, attribs); +} - if (mConfig->stencilSize > 0) - { - framebuffer->setAttachment(GL_FRAMEBUFFER_DEFAULT, GL_STENCIL, - gl::ImageIndex::MakeInvalid(), this); - } +WindowSurface::~WindowSurface() +{ +} - return framebuffer; +PbufferSurface::PbufferSurface(rx::EGLImplFactory *implFactory, + const Config *config, + const AttributeMap &attribs) + : Surface(EGL_PBUFFER_BIT, config, attribs) +{ + mImplementation = implFactory->createPbufferSurface(mState, attribs); +} + +PbufferSurface::PbufferSurface(rx::EGLImplFactory *implFactory, + const Config *config, + EGLenum buftype, + EGLClientBuffer clientBuffer, + const AttributeMap &attribs) + : Surface(EGL_PBUFFER_BIT, config, attribs) +{ + mImplementation = + implFactory->createPbufferFromClientBuffer(mState, buftype, clientBuffer, attribs); } + +PbufferSurface::~PbufferSurface() +{ } + +PixmapSurface::PixmapSurface(rx::EGLImplFactory *implFactory, + const Config *config, + NativePixmapType nativePixmap, + const AttributeMap &attribs) + : Surface(EGL_PIXMAP_BIT, config, attribs) +{ + mImplementation = implFactory->createPixmapSurface(mState, nativePixmap, attribs); +} + +PixmapSurface::~PixmapSurface() +{ +} + +// SurfaceDeleter implementation. + +SurfaceDeleter::SurfaceDeleter(const Display *display) : mDisplay(display) +{ +} + +SurfaceDeleter::~SurfaceDeleter() +{ +} + +void SurfaceDeleter::operator()(Surface *surface) +{ + ANGLE_SWALLOW_ERR(surface->onDestroy(mDisplay)); +} + +} // namespace egl |