kc3-lang/angle/src/libANGLE/renderer/gl/eagl/WindowSurfaceEAGL.mm

• Show log

  Commit

• Hash : c19b66f6
  Author :
  Date : 2023-04-06T11:30:03
  

  EAGL: Define ANGLE_ENABLE_EAGL in build system
  
  ANGLE_ENABLE_EAGL is a "build system" decision.
  Set this and new variable ANGLE_ENABLE_CGL in BUILD.gn file. This is
  consistent with the other backends.
  
  Remove ANGLE_CPU_ARM64. This was used to do ANGLE_ENABLE_EAGL=TRUE
  when on Catalyst. Instead, let the build system set this.
  For ANGLE/Chrome buildsystem, this is not set, as Catalyst is not
  implemented. For WebKit, this should be set at WebKit build settings.
  
  Replace
   `defined(ANGLE_PLATFORM_MACCATALYST) && defined(ANGLE_CPU_ARM64)`
  with simpler expression: `defined(ANGLE_ENABLE_EAGL)`.
  
  Replace `defined(ANGLE_PLATFORM_MACOS) || defined(ANGLE_PLATFORM_IOS)`
  with simpler expression: `defined(ANGLE_PLATFORM_APPLE)`.
  
  Bug: angleproject:8121
  Change-Id: I3a0bbabb4347ad11f693e3f7c336ff12f66203d7
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4404160
  Commit-Queue: Kimmo Kinnunen <kkinnunen@apple.com>
  Reviewed-by: Dan Glastonbury <djg@apple.com>
  Reviewed-by: Kenneth Russell <kbr@chromium.org>
  

Download

• src/libANGLE/renderer/gl/eagl/WindowSurfaceEAGL.mm

• //
  // Copyright 2020 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.
  //
  
  // WindowSurfaceEAGL.cpp: EAGL implementation of egl::Surface
  
  #import "libANGLE/renderer/gl/eagl/WindowSurfaceEAGL.h"
  
  #import <QuartzCore/QuartzCore.h>
  
  #import "common/debug.h"
  #import "common/platform.h"
  #import "libANGLE/Context.h"
  #import "libANGLE/renderer/gl/FramebufferGL.h"
  #import "libANGLE/renderer/gl/RendererGL.h"
  #import "libANGLE/renderer/gl/StateManagerGL.h"
  #import "libANGLE/renderer/gl/eagl/DisplayEAGL.h"
  #import "libANGLE/renderer/gl/eagl/FunctionsEAGL.h"
  
  #if defined(ANGLE_PLATFORM_MACCATALYST)
  
  // TODO(dino): Necessary because CAEAGLLayer is not in the public QuartzCore headers in this
  // configuration.
  // TODO(dino): Check that this won't cause an application using ANGLE directly to be flagged
  // for non-public API use on Apple's App Store.
  @interface CAEAGLLayer : CALayer
  @end
  
  #endif
  
  @interface SwapLayerEAGL : CAEAGLLayer {
      EAGLContextObj mDisplayContext;
  
      bool initialized;
      rx::SharedSwapState *mSwapState;
      const rx::FunctionsGL *mFunctions;
  
      GLuint mReadFramebuffer;
  }
  - (id)initWithSharedState:(rx::SharedSwapState *)swapState
                withContext:(EAGLContextObj)displayContext
              withFunctions:(const rx::FunctionsGL *)functions;
  @end
  
  @implementation SwapLayerEAGL
  - (id)initWithSharedState:(rx::SharedSwapState *)swapState
                withContext:(EAGLContextObj)displayContext
              withFunctions:(const rx::FunctionsGL *)functions
  {
      self = [super init];
      if (self != nil)
      {
          mDisplayContext = displayContext;
  
          initialized = false;
          mSwapState  = swapState;
          mFunctions  = functions;
  
          [self setFrame:CGRectMake(0, 0, mSwapState->textures[0].width,
                                    mSwapState->textures[0].height)];
      }
      return self;
  }
  
  - (void)display
  {
      pthread_mutex_lock(&mSwapState->mutex);
      {
          if (mSwapState->lastRendered->swapId > mSwapState->beingPresented->swapId)
          {
              std::swap(mSwapState->lastRendered, mSwapState->beingPresented);
          }
      }
      pthread_mutex_unlock(&mSwapState->mutex);
  
      [getEAGLContextClass() setCurrentContext:mDisplayContext];
  
      if (!initialized)
      {
          initialized = true;
  
          mFunctions->genFramebuffers(1, &mReadFramebuffer);
      }
  
      const auto &texture = *mSwapState->beingPresented;
  
      if ([self frame].size.width != texture.width || [self frame].size.height != texture.height)
      {
          [self setFrame:CGRectMake(0, 0, texture.width, texture.height)];
  
          // TODO(anglebug.com/4275): If this continues to remain an EAGLLayer, then this is
          // where we'd probably want to create the renderbuffer storage.
          [self setNeedsDisplay];
      }
  
      // TODO(cwallez) support 2.1 contexts too that don't have blitFramebuffer nor the
      // GL_DRAW_FRAMEBUFFER_BINDING query
      GLint drawFBO;
      mFunctions->getIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &drawFBO);
  
      mFunctions->bindFramebuffer(GL_FRAMEBUFFER, mReadFramebuffer);
      mFunctions->framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
                                       texture.texture, 0);
  
      mFunctions->bindFramebuffer(GL_READ_FRAMEBUFFER, mReadFramebuffer);
      mFunctions->bindFramebuffer(GL_DRAW_FRAMEBUFFER, drawFBO);
      mFunctions->blitFramebuffer(0, 0, texture.width, texture.height, 0, 0, texture.width,
                                  texture.height, GL_COLOR_BUFFER_BIT, GL_NEAREST);
  
      mFunctions->bindRenderbuffer(GL_RENDERBUFFER, texture.texture);
      [mDisplayContext presentRenderbuffer:GL_RENDERBUFFER];
      [getEAGLContextClass() setCurrentContext:nil];
  }
  @end
  
  namespace rx
  {
  
  WindowSurfaceEAGL::WindowSurfaceEAGL(const egl::SurfaceState &state,
                                       RendererGL *renderer,
                                       EGLNativeWindowType layer,
                                       EAGLContextObj context)
      : SurfaceGL(state),
        mSwapLayer(nil),
        mCurrentSwapId(0),
        mLayer((__bridge CALayer *)layer),
        mContext(context),
        mFunctions(renderer->getFunctions()),
        mStateManager(renderer->getStateManager()),
        mDSRenderbuffer(0),
        mFramebufferID(0)
  {
      pthread_mutex_init(&mSwapState.mutex, nullptr);
  }
  
  WindowSurfaceEAGL::~WindowSurfaceEAGL()
  {
      pthread_mutex_destroy(&mSwapState.mutex);
  
      if (mFramebufferID != 0)
      {
          mStateManager->deleteFramebuffer(mFramebufferID);
          mFramebufferID = 0;
      }
  
      if (mDSRenderbuffer != 0)
      {
          mFunctions->deleteRenderbuffers(1, &mDSRenderbuffer);
          mDSRenderbuffer = 0;
      }
  
      if (mSwapLayer != nil)
      {
          [mSwapLayer removeFromSuperlayer];
          mSwapLayer = nil;
      }
  
      for (size_t i = 0; i < ArraySize(mSwapState.textures); ++i)
      {
          if (mSwapState.textures[i].texture != 0)
          {
              mFunctions->deleteTextures(1, &mSwapState.textures[i].texture);
              mSwapState.textures[i].texture = 0;
          }
      }
  }
  
  egl::Error WindowSurfaceEAGL::initialize(const egl::Display *display)
  {
      unsigned width  = getWidth();
      unsigned height = getHeight();
  
      for (size_t i = 0; i < ArraySize(mSwapState.textures); ++i)
      {
          mFunctions->genTextures(1, &mSwapState.textures[i].texture);
          mStateManager->bindTexture(gl::TextureType::_2D, mSwapState.textures[i].texture);
          mFunctions->texImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA,
                                 GL_UNSIGNED_BYTE, nullptr);
          mSwapState.textures[i].width  = width;
          mSwapState.textures[i].height = height;
          mSwapState.textures[i].swapId = 0;
      }
      mSwapState.beingRendered  = &mSwapState.textures[0];
      mSwapState.lastRendered   = &mSwapState.textures[1];
      mSwapState.beingPresented = &mSwapState.textures[2];
  
      mSwapLayer = [[SwapLayerEAGL alloc] initWithSharedState:&mSwapState
                                                  withContext:mContext
                                                withFunctions:mFunctions];
      [mLayer addSublayer:mSwapLayer];
      [mSwapLayer setContentsScale:[mLayer contentsScale]];
  
      mFunctions->genRenderbuffers(1, &mDSRenderbuffer);
      mStateManager->bindRenderbuffer(GL_RENDERBUFFER, mDSRenderbuffer);
      mFunctions->renderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, width, height);
  
      return egl::Error(EGL_SUCCESS);
  }
  
  egl::Error WindowSurfaceEAGL::makeCurrent(const gl::Context *context)
  {
      return egl::Error(EGL_SUCCESS);
  }
  
  egl::Error WindowSurfaceEAGL::swap(const gl::Context *context)
  {
      const FunctionsGL *functions = GetFunctionsGL(context);
      StateManagerGL *stateManager = GetStateManagerGL(context);
  
      functions->flush();
      mSwapState.beingRendered->swapId = ++mCurrentSwapId;
  
      pthread_mutex_lock(&mSwapState.mutex);
      {
          std::swap(mSwapState.beingRendered, mSwapState.lastRendered);
      }
      pthread_mutex_unlock(&mSwapState.mutex);
  
      unsigned width  = getWidth();
      unsigned height = getHeight();
      auto &texture   = *mSwapState.beingRendered;
  
      if (texture.width != width || texture.height != height)
      {
          stateManager->bindTexture(gl::TextureType::_2D, texture.texture);
          functions->texImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA,
                                GL_UNSIGNED_BYTE, nullptr);
  
          stateManager->bindRenderbuffer(GL_RENDERBUFFER, mDSRenderbuffer);
          functions->renderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, width, height);
  
          texture.width  = width;
          texture.height = height;
      }
  
      ASSERT(mFramebufferID ==
             GetImplAs<FramebufferGL>(context->getFramebuffer({0}))->getFramebufferID());
      stateManager->bindFramebuffer(GL_FRAMEBUFFER, mFramebufferID);
      functions->framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
                                      mSwapState.beingRendered->texture, 0);
  
      return egl::Error(EGL_SUCCESS);
  }
  
  egl::Error WindowSurfaceEAGL::postSubBuffer(const gl::Context *context,
                                              EGLint x,
                                              EGLint y,
                                              EGLint width,
                                              EGLint height)
  {
      UNIMPLEMENTED();
      return egl::Error(EGL_SUCCESS);
  }
  
  egl::Error WindowSurfaceEAGL::querySurfacePointerANGLE(EGLint attribute, void **value)
  {
      UNIMPLEMENTED();
      return egl::Error(EGL_SUCCESS);
  }
  
  egl::Error WindowSurfaceEAGL::bindTexImage(const gl::Context *context,
                                             gl::Texture *texture,
                                             EGLint buffer)
  {
      UNIMPLEMENTED();
      return egl::Error(EGL_SUCCESS);
  }
  
  egl::Error WindowSurfaceEAGL::releaseTexImage(const gl::Context *context, EGLint buffer)
  {
      UNIMPLEMENTED();
      return egl::Error(EGL_SUCCESS);
  }
  
  void WindowSurfaceEAGL::setSwapInterval(EGLint interval)
  {
      // TODO(cwallez) investigate implementing swap intervals other than 0
  }
  
  EGLint WindowSurfaceEAGL::getWidth() const
  {
      return static_cast<EGLint>(CGRectGetWidth([mLayer frame]) * [mLayer contentsScale]);
  }
  
  EGLint WindowSurfaceEAGL::getHeight() const
  {
      return static_cast<EGLint>(CGRectGetHeight([mLayer frame]) * [mLayer contentsScale]);
  }
  
  EGLint WindowSurfaceEAGL::isPostSubBufferSupported() const
  {
      UNIMPLEMENTED();
      return EGL_FALSE;
  }
  
  EGLint WindowSurfaceEAGL::getSwapBehavior() const
  {
      return EGL_BUFFER_DESTROYED;
  }
  
  egl::Error WindowSurfaceEAGL::attachToFramebuffer(const gl::Context *context,
                                                    gl::Framebuffer *framebuffer)
  {
      FramebufferGL *framebufferGL = GetImplAs<FramebufferGL>(framebuffer);
      ASSERT(framebufferGL->getFramebufferID() == 0);
      if (mFramebufferID == 0)
      {
          GLuint framebufferID = 0;
          mFunctions->genFramebuffers(1, &framebufferID);
          mStateManager->bindFramebuffer(GL_FRAMEBUFFER, framebufferID);
          mFunctions->framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
                                           mSwapState.beingRendered->texture, 0);
          mFunctions->framebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT,
                                              GL_RENDERBUFFER, mDSRenderbuffer);
          mFramebufferID = framebufferID;
      }
      framebufferGL->setFramebufferID(mFramebufferID);
      return egl::NoError();
  }
  
  egl::Error WindowSurfaceEAGL::detachFromFramebuffer(const gl::Context *context,
                                                      gl::Framebuffer *framebuffer)
  {
      FramebufferGL *framebufferGL = GetImplAs<FramebufferGL>(framebuffer);
      ASSERT(framebufferGL->getFramebufferID() == mFramebufferID);
      framebufferGL->setFramebufferID(0);
      return egl::NoError();
  }
  
  }  // namespace rx
  

Download