tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

TextureStorage.h (4500B)

      1 //
      2 // Copyright 2002 The ANGLE Project Authors. All rights reserved.
      3 // Use of this source code is governed by a BSD-style license that can be
      4 // found in the LICENSE file.
      5 //
      6 
      7 // TextureStorage.h: Defines the abstract rx::TextureStorage class.
      8 
      9 #ifndef LIBANGLE_RENDERER_D3D_TEXTURESTORAGE_H_
     10 #define LIBANGLE_RENDERER_D3D_TEXTURESTORAGE_H_
     11 
     12 #include "common/debug.h"
     13 #include "libANGLE/angletypes.h"
     14 
     15 #include <GLES2/gl2.h>
     16 #include <stdint.h>
     17 
     18 namespace gl
     19 {
     20 class Context;
     21 class ImageIndex;
     22 struct Box;
     23 struct PixelUnpackState;
     24 }  // namespace gl
     25 
     26 namespace angle
     27 {
     28 class Subject;
     29 }  // namespace angle
     30 
     31 namespace rx
     32 {
     33 class SwapChainD3D;
     34 class RenderTargetD3D;
     35 class ImageD3D;
     36 
     37 // Dirty bit messages from TextureStorage
     38 constexpr size_t kTextureStorageObserverMessageIndex = 0;
     39 
     40 class TextureStorage : public angle::Subject
     41 {
     42  public:
     43    TextureStorage(const std::string &label) : mKHRDebugLabel(label) {}
     44    ~TextureStorage() override {}
     45 
     46    virtual angle::Result onDestroy(const gl::Context *context);
     47 
     48    virtual int getTopLevel() const                   = 0;
     49    virtual bool isRenderTarget() const               = 0;
     50    virtual bool isUnorderedAccess() const            = 0;
     51    virtual bool isManaged() const                    = 0;
     52    virtual bool supportsNativeMipmapFunction() const = 0;
     53    virtual int getLevelCount() const                 = 0;
     54 
     55    virtual angle::Result findRenderTarget(const gl::Context *context,
     56                                           const gl::ImageIndex &index,
     57                                           GLsizei samples,
     58                                           RenderTargetD3D **outRT) const = 0;
     59    virtual angle::Result getRenderTarget(const gl::Context *context,
     60                                          const gl::ImageIndex &index,
     61                                          GLsizei samples,
     62                                          RenderTargetD3D **outRT)        = 0;
     63    virtual angle::Result generateMipmap(const gl::Context *context,
     64                                         const gl::ImageIndex &sourceIndex,
     65                                         const gl::ImageIndex &destIndex) = 0;
     66 
     67    virtual angle::Result copyToStorage(const gl::Context *context,
     68                                        TextureStorage *destStorage) = 0;
     69    virtual angle::Result setData(const gl::Context *context,
     70                                  const gl::ImageIndex &index,
     71                                  ImageD3D *image,
     72                                  const gl::Box *destBox,
     73                                  GLenum type,
     74                                  const gl::PixelUnpackState &unpack,
     75                                  const uint8_t *pixelData)          = 0;
     76 
     77    // This is a no-op for most implementations of TextureStorage. Some (e.g. TextureStorage11_2D)
     78    // might override it.
     79    virtual angle::Result useLevelZeroWorkaroundTexture(const gl::Context *context,
     80                                                        bool useLevelZeroTexture);
     81 
     82    virtual void invalidateTextures() {}
     83 
     84    // RenderToTexture methods
     85    virtual angle::Result releaseMultisampledTexStorageForLevel(size_t level);
     86    virtual angle::Result resolveTexture(const gl::Context *context);
     87    virtual GLsizei getRenderToTextureSamples() const;
     88 
     89    // Called by outer object when label has changed via KHR_debug extension
     90    void setLabel(const std::string &newLabel);
     91 
     92  protected:
     93    virtual void onLabelUpdate() {}
     94 
     95    const angle::Subject *mSubject;
     96    std::string mKHRDebugLabel;
     97 };
     98 
     99 inline angle::Result TextureStorage::onDestroy(const gl::Context *context)
    100 {
    101    return angle::Result::Continue;
    102 }
    103 
    104 inline angle::Result TextureStorage::useLevelZeroWorkaroundTexture(const gl::Context *context,
    105                                                                   bool useLevelZeroTexture)
    106 {
    107    return angle::Result::Continue;
    108 }
    109 
    110 inline angle::Result TextureStorage::releaseMultisampledTexStorageForLevel(size_t level)
    111 {
    112    return angle::Result::Continue;
    113 }
    114 
    115 inline angle::Result TextureStorage::resolveTexture(const gl::Context *context)
    116 {
    117    return angle::Result::Continue;
    118 }
    119 
    120 inline GLsizei TextureStorage::getRenderToTextureSamples() const
    121 {
    122    return 0;
    123 }
    124 
    125 inline void TextureStorage::setLabel(const std::string &newLabel)
    126 {
    127    mKHRDebugLabel = newLabel;
    128    onLabelUpdate();
    129 }
    130 
    131 using TexStoragePointer = angle::UniqueObjectPointer<TextureStorage, gl::Context>;
    132 
    133 }  // namespace rx
    134 
    135 #endif  // LIBANGLE_RENDERER_D3D_TEXTURESTORAGE_H_