kc3-lang/angle/src/libANGLE/renderer/d3d/EGLImageD3D.cpp

• Show log

  Commit

• Hash : d75dd26c
  Author :
  Date : 2017-04-20T17:01:19
  

  Make ImageSibling inherit from FramebufferAttachment.
  
  Only currently Renderbuffers and Textures can be bound with images.
  This makes the relationship explicit, and also ensures that an image
  sibling can determine if it's been initialized or not, which is
  important for the robust resource init extension with Textures and
  EGLImages.
  
  BUG=angleproject:1635
  
  Change-Id: Ie05319cfbfda50f1497cab3f0b9ca64e1bff8955
  Reviewed-on: https://chromium-review.googlesource.com/469154
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  Reviewed-by: Corentin Wallez <cwallez@chromium.org>
  Commit-Queue: Jamie Madill <jmadill@chromium.org>
  

Download

• src/libANGLE/renderer/d3d/EGLImageD3D.cpp

• //
  // Copyright (c) 2015 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.
  //
  
  // EGLImageD3D.cpp: Implements the rx::EGLImageD3D class, the D3D implementation of EGL images
  
  #include "libANGLE/renderer/d3d/EGLImageD3D.h"
  
  #include "common/debug.h"
  #include "common/utilities.h"
  #include "libANGLE/AttributeMap.h"
  #include "libANGLE/Texture.h"
  #include "libANGLE/renderer/d3d/RenderbufferD3D.h"
  #include "libANGLE/renderer/d3d/RendererD3D.h"
  #include "libANGLE/renderer/d3d/RenderTargetD3D.h"
  #include "libANGLE/renderer/d3d/TextureD3D.h"
  #include "libANGLE/renderer/d3d/TextureStorage.h"
  
  #include <EGL/eglext.h>
  
  namespace rx
  {
  
  EGLImageD3D::EGLImageD3D(const egl::ImageState &state,
                           EGLenum target,
                           const egl::AttributeMap &attribs,
                           RendererD3D *renderer)
      : ImageImpl(state), mRenderer(renderer), mRenderTarget(nullptr)
  {
      ASSERT(renderer != nullptr);
  }
  
  EGLImageD3D::~EGLImageD3D()
  {
      SafeDelete(mRenderTarget);
  }
  
  egl::Error EGLImageD3D::initialize()
  {
      return egl::Error(EGL_SUCCESS);
  }
  
  gl::Error EGLImageD3D::orphan(egl::ImageSibling *sibling)
  {
      if (sibling == mState.source.get())
      {
          ANGLE_TRY(copyToLocalRendertarget());
      }
  
      return gl::NoError();
  }
  
  gl::Error EGLImageD3D::getRenderTarget(RenderTargetD3D **outRT) const
  {
      if (mState.source.get())
      {
          ASSERT(!mRenderTarget);
          FramebufferAttachmentRenderTarget *rt = nullptr;
          ANGLE_TRY(mState.source->getAttachmentRenderTarget(GL_NONE, mState.imageIndex, &rt));
          *outRT = static_cast<RenderTargetD3D *>(rt);
          return gl::NoError();
      }
      else
      {
          ASSERT(mRenderTarget);
          *outRT = mRenderTarget;
          return gl::NoError();
      }
  }
  
  gl::Error EGLImageD3D::copyToLocalRendertarget()
  {
      ASSERT(mState.source.get() != nullptr);
      ASSERT(mRenderTarget == nullptr);
  
      RenderTargetD3D *curRenderTarget = nullptr;
      ANGLE_TRY(getRenderTarget(&curRenderTarget));
  
      // This only currently applies do D3D11, where it invalidates FBOs with this Image attached.
      curRenderTarget->signalDirty();
  
      return mRenderer->createRenderTargetCopy(curRenderTarget, &mRenderTarget);
  }
  }  // namespace rx
  

Download