tor-browser

PixelLocalStorage.h (7251B)

---

//
// Copyright 2022 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.
//

// PixelLocalStorage.h: Defines the renderer-agnostic container classes
// gl::PixelLocalStorage and gl::PixelLocalStoragePlane for
// ANGLE_shader_pixel_local_storage.

#ifndef LIBANGLE_PIXEL_LOCAL_STORAGE_H_
#define LIBANGLE_PIXEL_LOCAL_STORAGE_H_

#include "angle_gl.h"
#include "libANGLE/ImageIndex.h"
#include "libANGLE/angletypes.h"

namespace gl
{

class Context;
class Texture;

// Holds the configuration of an ANGLE_shader_pixel_local_storage plane.
//
// Unlike normal framebuffer attachments, pixel local storage planes don't take effect until the
// application calls glBeginPixelLocalStorageANGLE, and the manner in which they take effect is
// highly dependent on the backend implementation. A PixelLocalStoragePlane is just a plain data
// description what to set up later once PLS is enabled.
class PixelLocalStoragePlane : angle::NonCopyable
{
 public:
   ~PixelLocalStoragePlane();

   // Called when the context is lost or destroyed. Causes this class to clear its GL object
   // handles.
   void onContextObjectsLost();

   // Called when the owning framebuffer is being destroyed. Causes this class to release its
   // texture object reference.
   void onFramebufferDestroyed(const Context *);

   void deinitialize(Context *);
   void setMemoryless(Context *, GLenum internalformat);
   void setTextureBacked(Context *, Texture *, int level, int layer);

   bool isDeinitialized() const { return mInternalformat == GL_NONE; }

   // Returns true if the texture ID bound to this plane has been deleted.
   //
   // [ANGLE_shader_pixel_local_storage] Section 4.4.2.X "Configuring Pixel Local Storage
   // on a Framebuffer": When a texture object is deleted, any pixel local storage plane to
   // which it was bound is automatically converted to a memoryless plane of matching
   // internalformat.
   bool isTextureIDDeleted(const Context *) const;

   bool isMemoryless() const
   {
       // isMemoryless() should be false if the plane is deinitialized.
       ASSERT(!(isDeinitialized() && mMemoryless));
       return mMemoryless;
   }

   GLenum getInternalformat() const { return mInternalformat; }

   // Implements glGetIntegeri_v() for GL_PIXEL_LOCAL_FORMAT_ANGLE,
   // GL_PIXEL_LOCAL_TEXTURE_NAME_ANGLE, GL_PIXEL_LOCAL_TEXTURE_LEVEL_ANGLE, and
   // GL_PIXEL_LOCAL_TEXTURE_LAYER_ANGLE
   GLint getIntegeri(const Context *, GLenum target, GLuint index) const;

   // If this plane is texture backed, stores the bound texture image's {width, height, 0} to
   // Extents and returns true. Otherwise returns false, meaning the plane is either deinitialized
   // or memoryless.
   bool getTextureImageExtents(const Context *, Extents *extents) const;

   // Attaches this plane to the specified color attachment point on the current draw framebuffer.
   void attachToDrawFramebuffer(Context *, Extents plsExtents, GLenum colorAttachment);

   // Clears the draw buffer at 0-based index 'drawbuffer' on the current framebuffer. Reads the
   // clear value from 'data' if 'loadop' is GL_CLEAR_ANGLE, otherwise clears to zero.
   //
   // 'data' is interpereted as either 4 GLfloats, 4 GLints, or 4 GLuints, depending on
   // mInternalFormat.
   //
   // The context must internally disable the scissor test before calling this method, since the
   // intention is to clear the entire surface.
   void performLoadOperationClear(Context *, GLint drawbuffer, GLenum loadop, const void *data);

   // Binds this PLS plane to a texture image unit for image load/store shader operations.
   void bindToImage(Context *, Extents plsExtents, GLuint unit, bool needsR32Packing);

 private:
   // Ensures we have an internal backing texture for memoryless planes. In GL, we need a backing
   // texture even if the plane is memoryless; glInvalidateFramebuffer() will ideally prevent the
   // driver from writing out data where possible.
   void ensureBackingIfMemoryless(Context *, Extents plsSize);

   GLenum mInternalformat = GL_NONE;  // GL_NONE if this plane is in a deinitialized state.
   bool mMemoryless       = false;
   TextureID mMemorylessTextureID{};  // We own memoryless backing textures and must delete them.
   ImageIndex mTextureImageIndex;
   Texture *mTextureRef = nullptr;
};

// Manages a collection of PixelLocalStoragePlanes and applies them to ANGLE's GL state.
//
// The main magic of ANGLE_shader_pixel_local_storage happens inside shaders, so we just emulate the
// client API on top of ANGLE's OpenGL ES API for simplicity.
class PixelLocalStorage
{
 public:
   static std::unique_ptr<PixelLocalStorage> Make(const Context *);

   PixelLocalStorage();
   virtual ~PixelLocalStorage();

   // Called when the owning framebuffer is being destroyed.
   void onFramebufferDestroyed(const Context *);

   // Deletes any GL objects that have been allocated for pixel local storage. These can't be
   // cleaned up in the destructor because they require a non-const Context object.
   void deleteContextObjects(Context *);

   const PixelLocalStoragePlane &getPlane(GLint plane) const
   {
       ASSERT(0 <= plane && plane < IMPLEMENTATION_MAX_PIXEL_LOCAL_STORAGE_PLANES);
       return mPlanes[plane];
   }

   PixelLocalStoragePlane &getPlane(GLint plane)
   {
       ASSERT(0 <= plane && plane < IMPLEMENTATION_MAX_PIXEL_LOCAL_STORAGE_PLANES);
       return mPlanes[plane];
   }

   // ANGLE_shader_pixel_local_storage API.
   void deinitialize(Context *context, GLint plane) { mPlanes[plane].deinitialize(context); }
   void setMemoryless(Context *context, GLint plane, GLenum internalformat)
   {
       mPlanes[plane].setMemoryless(context, internalformat);
   }
   void setTextureBacked(Context *context, GLint plane, Texture *tex, int level, int layer)
   {
       mPlanes[plane].setTextureBacked(context, tex, level, layer);
   }
   void begin(Context *, GLsizei n, const GLenum loadops[], const void *cleardata);
   void end(Context *);
   void barrier(Context *);

 protected:
   // Called when the context is lost or destroyed. Causes the subclass to clear its GL object
   // handles.
   virtual void onContextObjectsLost() = 0;

   // Called when the framebuffer is being destroyed. Causes the subclass to delete its frontend GL
   // object handles.
   virtual void onDeleteContextObjects(Context *) = 0;

   // ANGLE_shader_pixel_local_storage API.
   virtual void onBegin(Context *,
                        GLsizei n,
                        const GLenum loadops[],
                        const char *cleardata,
                        Extents plsSize)                     = 0;
   virtual void onEnd(Context *, GLsizei numActivePLSPlanes) = 0;
   virtual void onBarrier(Context *)                         = 0;

 private:
   std::array<PixelLocalStoragePlane, IMPLEMENTATION_MAX_PIXEL_LOCAL_STORAGE_PLANES> mPlanes;

   // "n" from the last call to begin(), or 0 if pixel local storage is not active.
   GLsizei mNumActivePLSPlanes = 0;
};

}  // namespace gl

#endif  // LIBANGLE_PIXEL_LOCAL_STORAGE_H_