kc3-lang/angle/src/libANGLE/renderer/d3d/TextureStorage.h

• Show log

  Commit

• Hash : 888081d5
  Author :
  Date : 2018-02-27T00:24:46
  

  D3D11: Refactor dependent Framebuffer state changes.
  
  Previously, when a state change would cause a Texture to
  recreate its storage specific to D3D11, we would use a
  dependent notification from RenderTarget11 to Framebuffer11
  to re-check internal dirty bits. In this new method, we
  instead set dirty bits on the gl::Frambuffer directly. This
  also means we use fewer internal objects for these
  notifications, because we share the same structures between
  the D3D11 back-end notifications and the top-level notifications
  we use for Robust init and Framebuffer completeness.
  
  This also allows us to get rid of one "if" that we check on
  every draw call in D3D11.
  
  This also introduces a dirty bits guard concept - a shadow
  set of dirty bits that is checked in dependent state changes
  to ensure that extra bits aren't set inside syncState.
  
  This also implements Framebuffer dirty bits for the D3D9
  back-end. This has the side effect of cleaning up the
  "null colorbuffer" D3D9 workaround.
  
  Bug: angleproject:2372
  Change-Id: Ie346d39030f4f6df583d735685b0babea4e745a8
  Reviewed-on: https://chromium-review.googlesource.com/936691
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Commit-Queue: Jamie Madill <jmadill@chromium.org>
  

Download

• src/libANGLE/renderer/d3d/TextureStorage.h

• //
  // Copyright (c) 2002-2013 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.
  //
  
  // TextureStorage.h: Defines the abstract rx::TextureStorage class.
  
  #ifndef LIBANGLE_RENDERER_D3D_TEXTURESTORAGE_H_
  #define LIBANGLE_RENDERER_D3D_TEXTURESTORAGE_H_
  
  #include "common/debug.h"
  #include "libANGLE/angletypes.h"
  
  #include <GLES2/gl2.h>
  #include <stdint.h>
  
  namespace gl
  {
  class Context;
  struct ImageIndex;
  struct Box;
  struct PixelUnpackState;
  }  // namespace gl
  
  namespace angle
  {
  class Subject;
  }  // namespace angle
  
  namespace rx
  {
  class SwapChainD3D;
  class RenderTargetD3D;
  class ImageD3D;
  
  class TextureStorage : angle::NonCopyable
  {
    public:
      TextureStorage() : mSubject(nullptr) {}
      virtual ~TextureStorage() {}
  
      virtual gl::Error onDestroy(const gl::Context *context);
  
      virtual int getTopLevel() const = 0;
      virtual bool isRenderTarget() const = 0;
      virtual bool isManaged() const = 0;
      virtual bool supportsNativeMipmapFunction() const = 0;
      virtual int getLevelCount() const = 0;
  
      virtual gl::Error getRenderTarget(const gl::Context *context,
                                        const gl::ImageIndex &index,
                                        RenderTargetD3D **outRT) = 0;
      virtual gl::Error generateMipmap(const gl::Context *context,
                                       const gl::ImageIndex &sourceIndex,
                                       const gl::ImageIndex &destIndex) = 0;
  
      virtual gl::Error copyToStorage(const gl::Context *context, TextureStorage *destStorage) = 0;
      virtual gl::Error setData(const gl::Context *context,
                                const gl::ImageIndex &index,
                                ImageD3D *image,
                                const gl::Box *destBox,
                                GLenum type,
                                const gl::PixelUnpackState &unpack,
                                const uint8_t *pixelData) = 0;
  
      // This is a no-op for most implementations of TextureStorage. Some (e.g. TextureStorage11_2D) might override it.
      virtual gl::Error useLevelZeroWorkaroundTexture(const gl::Context *context,
                                                      bool useLevelZeroTexture);
  
      // Only used for D3D11.
      void setSubject(const angle::Subject *subject);
  
    protected:
      const angle::Subject *mSubject;
  };
  
  inline gl::Error TextureStorage::onDestroy(const gl::Context *context)
  {
      return gl::NoError();
  }
  
  inline gl::Error TextureStorage::useLevelZeroWorkaroundTexture(const gl::Context *context,
                                                                 bool useLevelZeroTexture)
  {
      return gl::NoError();
  }
  
  inline void TextureStorage::setSubject(const angle::Subject *subject)
  {
      mSubject = subject;
  }
  
  using TexStoragePointer = angle::UniqueObjectPointer<TextureStorage, gl::Context>;
  
  }  // namespace rx
  
  #endif // LIBANGLE_RENDERER_D3D_TEXTURESTORAGE_H_
  

Download