Name

    ANGLE_shader_pixel_local_storage

Name Strings

    GL_ANGLE_shader_pixel_local_storage
    GL_ANGLE_shader_pixel_local_storage_coherent

Contact

    Chris Dalton (chris 'at' rive.app)

Contributors

    Chris Dalton, Rive
    Kenneth Russell, Google Inc.
    Shahbaz Youssefi, Google Inc.
    Kelsey Gilbert, Mozilla Corp.
    Geoff Lang, Google Inc.
    Kimmo Kinnunen, Apple Inc.
    Contributors to the EXT_shader_pixel_local_storage specification
    Contributors to the ARB_fragment_shader_interlock specification
    Contributors to the INTEL_fragment_shader_ordering specification
    Contributors to the EXT_shader_framebuffer_fetch specification
    Contributors to the ARB_shader_image_load_store specification
    Contributors to the QCOM_tiled_rendering specification
    Contributors to the KHR_blend_equation_advanced specification
    Contributors to the NV_texture_barrier specification
    Contributors to the (Vulkan) EXT_fragment_shader_interlock specification
    Contributors to the (Vulkan) ARM_rasterization_order_attachment_access specification

Status

    Incomplete

Version

    Last Modified Date: Aug 18, 2022
    Author Revision: 1

Number

    OpenGL ES Extension XX

Dependencies

    OpenGL ES 3.0 and GLSL ES 3.00 are required.

    This extension is written against the OpenGL ES 3.0 specification and the
    OpenGL ES Shading Language 3.00 specification.

    This extension interacts with ANGLE_robust_client_memory.

    This extension interacts with ANGLE_request_extension.

    This extension interacts with ANGLE_polygon_mode.

    This extension interacts with ANGLE_provoking_vertex.

    This extension interacts with EXT_blend_func_extended.

    This extension interacts with EXT_clip_control.

    This extension interacts with EXT_clip_cull_distance.

    This extension interacts with EXT_depth_clamp.

    This extension interacts with EXT_draw_buffers_indexed.

    This extension interacts with EXT_polygon_offset_clamp.

    This extension interacts with EXT_texture_cube_map_array.

    This extension interacts with KHR_blend_equation_advanced.

    This extension interacts with KHR_debug.

    This extension interacts with NV_polygon_mode.

    This extension interacts with NV_scissor_exclusive.

    This extension interacts with OES_draw_buffers_indexed.

    This extension interacts with OES_sample_variables.

    This extension interacts with OES_texture_cube_map_array.

    This extension interacts with QCOM_tiled_rendering.

    This extension interacts with OpenGL ES 3.1.

    This extension interacts with OpenGL ES 3.2.

    This extension interacts with GLSL ES 3.10.

Overview

    A major feature missing from WebGL is the ability to access rendering
    results from fragment shaders and perform tasks like programmable blending.
    This is especially desirable on Tile-Based Deferred Rendering (TBDR)
    architectures, as it can be implemented entirely on-chip to achieve maximum
    performance.

    Capabilities in this area vary widely, but it is the case that all major GPU
    vendors, on all major APIs, have some mechanism, direct or indirect, whereby
    a fragment shader can access prior rendering results. The intent of this
    extension is to condense this myriad of hardware and API features into a
    simple interface with straightforward implementation(s) on every graphics
    API.

    Similar to EXT_shader_pixel_local_storage, this extension provides a means
    for fragment shaders to load and store user-defined data associated with the
    pixel being covered. The data is accessed via GLSL built-in functions
    pixelLocalLoadANGLE() and pixelLocalStoreANGLE(). Only the current pixel's
    data can be accessed; data associated with other pixels is not accessible to
    the fragment shader. Pixel local storage persists across all fragment
    invocations and across all draws issued between OpenGL ES API calls
    BeginPixelLocalStorageANGLE() and EndPixelLocalStorageANGLE(), even if the
    application binds different shader programs.

    Applications define custom, formatted planes of pixel local storage data, up
    to an implementation-dependent maximum, using the OpenGL ES API functions
    FramebufferMemorylessPixelLocalStorageANGLE() and
    FramebufferTexturePixelLocalStorageANGLE(). These methods behave similarly
    to FramebufferTextureLayer(). Fragment shaders access a specific local
    storage plane using one of the opaque GLSL types {pixelLocalANGLE,
    ipixelLocalANGLE, upixelLocalANGLE}, which are analogous to samplers or
    images.

    This extension provides two different extension string entries:

        - GL_ANGLE_shader_pixel_local_storage: Provides the new pixel local
          storage functionality, but each pixel may only be touched once in any
          single rendering pass. The command PixelLocalStorageBarrierANGLE() is
          provided to indicate a boundary between passes. Rendering the same
          pixel twice without a barrier can yield incorrect results. However,
          "incorrect" does _not_ mean they can be random, uninitialized, or
          leaked from outside the current draw framebuffer; any artifacts are
          strictly a result of race conditions between overlapping fragment
          invocations involved in the current rendering pass.

        - GL_ANGLE_shader_pixel_local_storage_coherent: Guarantees that pixel
          local storage operations touching the same pixel are invoked
          synchronously and in API primitive order. No barriers are required and
          render passes can emit overlapping fragments.

          Because raster ordering may come at a performance cost on some
          platforms, an application may opt out of coherent pixel local storage
          by using the "noncoherent" layout qualifier on a plane-by-plane basis.
          When using "noncoherent", the former restrictions and barrier
          requirements apply.

    Some implementations may support GL_ANGLE_shader_pixel_local_storage without
    supporting GL_ANGLE_shader_pixel_local_storage_coherent.

    A note on performance: On some platforms, this feature will be polyfilled
    with shader images. While every implementation can be expected to run
    reasonably fast, certain platforms may see some performance degradation at
    times from using pixel local storage instead of the normal raster pipeline.
    As always, benchmark and consider other options before using pixel local
    storage.

IP Status

    No known IP claims.

New Procedures and Functions

    void FramebufferMemorylessPixelLocalStorageANGLE(int plane,
                                                     enum internalformat)

    void FramebufferTexturePixelLocalStorageANGLE(int plane,
                                                  uint backingtexture,
                                                  int level,
                                                  int layer)

    void FramebufferPixelLocalClearValue{f,i,ui}vANGLE(int plane,
                                                       const T value[])

    void BeginPixelLocalStorageANGLE(sizei n, const enum loadops[])

    void EndPixelLocalStorageANGLE(sizei n, const enum storeops[])

    void PixelLocalStorageBarrierANGLE()

    void FramebufferPixelLocalStorageInterruptANGLE()

    void FramebufferPixelLocalStorageRestoreANGLE()

    void GetFramebufferPixelLocalStorageParameter{f,i}vANGLE(int plane,
                                                             enum pname,
                                                             T *params)

    (the following commands are supported only if ANGLE_robust_client_memory is
     supported)

    void GetFramebufferPixelLocalStorageParameter{f,i}vRobustANGLE(int plane,
                                                                   enum pname,
                                                                   GLsizei bufSize,
                                                                   GLsizei *length,
                                                                   T *params)

New Tokens

    Accepted by the <pname> parameter of GetIntegerv():

        MAX_PIXEL_LOCAL_STORAGE_PLANES_ANGLE                              0x96E0
        MAX_COMBINED_DRAW_BUFFERS_AND_PIXEL_LOCAL_STORAGE_PLANES_ANGLE    0x96E1
        PIXEL_LOCAL_STORAGE_ACTIVE_PLANES_ANGLE                           0x96E2

    Accepted as array elements in the <loadops> parameter of
    BeginPixelLocalStorageANGLE():

        LOAD_OP_ZERO_ANGLE                                                0x96E3
        LOAD_OP_CLEAR_ANGLE                                               0x96E4
        LOAD_OP_LOAD_ANGLE                                                0x96E5

    Accepted as array elements in the <storeops> parameter of
    EndPixelLocalStorageANGLE():

        STORE_OP_STORE_ANGLE                                              0x96E6

    Accepted by the <pname> parameter of
    GetFramebufferPixelLocalStorageParameter{f,i}vANGLE() and
    GetFramebufferPixelLocalStorageParameter{f,i}vRobustANGLE():

        PIXEL_LOCAL_FORMAT_ANGLE                                          0x96E7
        PIXEL_LOCAL_TEXTURE_NAME_ANGLE                                    0x96E8
        PIXEL_LOCAL_TEXTURE_LEVEL_ANGLE                                   0x96E9
        PIXEL_LOCAL_TEXTURE_LAYER_ANGLE                                   0x96EA
        PIXEL_LOCAL_CLEAR_VALUE_FLOAT_ANGLE                               0x96EB
        PIXEL_LOCAL_CLEAR_VALUE_INT_ANGLE                                 0x96EC
        PIXEL_LOCAL_CLEAR_VALUE_UNSIGNED_INT_ANGLE                        0x96ED

New GLSL Opaque Types

    pixelLocalANGLE
    ipixelLocalANGLE
    upixelLocalANGLE

New GLSL Built-in Functions

    gvec4 pixelLocalLoadANGLE(gpixelLocalANGLE)
    void pixelLocalStoreANGLE(gpixelLocalANGLE, gvec4 value)

Additions to the OpenGL ES Specification, Version 3.0.6

  Modify Chapter 2 "OpenGL ES Operation"

  (Insert a new numbered section before 2.14 "Asynchronous Queries".)

  Section 2.X "Pixel Local Storage"

    Pixel local storage provides a means for fragment shaders to load and store
    user-defined data associated with the pixel being covered. Pixel local
    storage is configured on a framebuffer as described in Section 4.4.2.X
    "Configuring Pixel Local Storage on a Framebuffer". Fragment shaders may
    access pixel local storage data as described in OpenGL ES Shading Language
    Specification.

    Pixel local storage is activated and deactivated for the current draw
    framebuffer using the commands:

      void BeginPixelLocalStorageANGLE(sizei n, const enum loadops[])

      void EndPixelLocalStorageANGLE(sizei n, const enum storeops[])

    Parameters:

      * <n> specifies the length of the <loadops> or <storeops> array.

      * <loadops> specifies an array of <n> pixel local storage "Load
                  Operations", whose ith element describes the Load Operation to
                  perform on the ith pixel local storage plane. Supported Load
                  Operations are listed in Table X.1. Load Operations are
                  performed on the entire area of each plane, irrespective of
                  scissor or viewport state.

        Load Operation           Description
        -----------------------------------------------------------------------
        LOAD_OP_ZERO_ANGLE       Clear all components of the pixel local storage
                                 plane to 0. This is recommended over
                                 LOAD_OP_CLEAR_ANGLE, as it is more likely to be
                                 performant on all implementations.
                                 This clear is executed regardless of
                                 RASTERIZER_DISCARD state.

        LOAD_OP_CLEAR_ANGLE      Clear the pixel local storage plane to its
                                 framebuffer's ith clear value of corresponding
                                 type. Pixel local clear values are specified
                                 with
                                 FramebufferPixelLocalClearValue{f,i,ui}vANGLE(),
                                 as described in section 4.4.2.Y "Pixel Local
                                 Clear State". If the magnitude of any component
                                 of the clear value is too large to be
                                 represented in the plane's internalformat, it
                                 is clamped.
                                 This clear is executed regardless of
                                 RASTERIZER_DISCARD state.

        LOAD_OP_LOAD_ANGLE       Load the contents of the bound texture image
                                 into pixel local storage. This Load Operation
                                 is only valid for pixel local storage planes
                                 that have a texture binding. Texture bindings
                                 are established with
                                 FramebufferTexturePixelLocalStorageANGLE() as
                                 described in section 4.4.2.X "Configuring Pixel
                                 Local Storage on a Framebuffer".

        DONT_CARE                Leave the initial contents of the pixel local
                                 storage plane undefined, favoring speed, and
                                 with the caveat that they are _not_ leaked from
                                 outside the current draw framebuffer.

        Table X.1: Pixel local storage Load Operations.

      * <storeops> specifies an array of <n> pixel local storage "Store
                   Operations", whose ith element describes the Store Operation
                   to perform on the backing texture of the ith pixel local
                   storage plane. The store operation is ignored if its plane is
                   memoryless. Supported Store Operations are listed in Table
                   X.2.

        Store Operation         Description
        -----------------------------------------------------------------------
        STORE_OP_STORE_ANGLE    Update the the bound texture image to reflect
                                the pixel local storage contents.

        DONT_CARE               Leave the bound texture image contents
                                undefined, with the caveat that they are either
                                unchanged, or not leaked from outside the
                                current draw framebuffer.

        Table X.2: Pixel local storage Store Operations.

    Errors generated by BeginPixelLocalStorageANGLE():

      * INVALID_FRAMEBUFFER_OPERATION is generated if the default framebuffer
        object name 0 is bound to DRAW_FRAMEBUFFER.

      * INVALID_FRAMEBUFFER_OPERATION is generated if pixel local storage on the
        draw framebuffer is in an interrupted state. (See section 2.X.2
        "Interrupting Pixel Local Storage")

      * INVALID_OPERATION is generated if
        PIXEL_LOCAL_STORAGE_ACTIVE_PLANES_ANGLE is nonzero.

      * INVALID_OPERATION is generated if the value of SAMPLE_BUFFERS is 1
        (i.e., if rendering to a multisampled framebuffer).

      * INVALID_OPERATION is generated if DITHER is enabled.

      * INVALID_OPERATION is generated if TRANSFORM_FEEDBACK_ACTIVE is TRUE.

      * INVALID_OPERATION is generated if QCOM_tiled_rendering is active.

      * INVALID_OPERATION is generated if BLEND_DST_ALPHA, BLEND_DST_RGB,
        BLEND_SRC_ALPHA, or BLEND_SRC_RGB, for any draw buffer, is a blend
        function requiring the secondary color input, as specified in
        EXT_blend_func_extended (SRC1_COLOR_EXT, ONE_MINUS_SRC1_COLOR_EXT,
        SRC1_ALPHA_EXT, ONE_MINUS_SRC1_ALPHA_EXT).

      * INVALID_OPERATION is generated if BLEND_EQUATION_RGB and/or
        BLEND_EQUATION_ALPHA is an advanced blend equation defined in
        KHR_blend_equation_advanced.

      * INVALID_VALUE is generated if
        <n> < 1 or <n> > MAX_PIXEL_LOCAL_STORAGE_PLANES_ANGLE.

      * INVALID_FRAMEBUFFER_OPERATION is generated if the draw framebuffer has
        an image attached to any color attachment point on or after:

          COLOR_ATTACHMENT0 +
          MAX_COMBINED_DRAW_BUFFERS_AND_PIXEL_LOCAL_STORAGE_PLANES_ANGLE - <n>

      * INVALID_VALUE is generated if <loadops> is NULL.

      * INVALID_ENUM is generated if <loadops>[0..<n>-1] is not one of the Load
        Operations enumerated in Table X.1.

      * INVALID_OPERATION is generated if a pixel local storage plane at index
        [0..<n>-1] is in a deinitialized state.

      * INVALID_OPERATION is generated if <loadops>[0..<n>-1] is
        LOAD_OP_LOAD_ANGLE and the pixel local storage plane at that same index
        is memoryless.

      * INVALID_OPERATION is generated if all enabled, texture-backed pixel
        local storage planes do not have the same width and height.

      * INVALID_OPERATION is generated if the draw framebuffer has other
        attachments, and its enabled, texture-backed pixel local storage planes
        do not have identical dimensions with the rendering area.

        (The rendering area is defined in section 4.4.1 "Binding and Managing
        Framebuffer Objects" as the intersection of rectangles having a lower
        left of [0, 0] and an upper right of [width, height] for each
        attachment.)

      * INVALID_OPERATION is generated if the draw framebuffer has no
        attachments and no enabled, texture-backed pixel local storage planes.

      * INVALID_OPERATION is generated if, for any enabled backing texture, the
        mipmap level bound to pixel local storage is outside the effective
        base/max range of that texture.

      * INVALID_OPERATION is generated if a single texture slice is bound to
        more than one active pixel local storage plane.

      * INVALID_OPERATION is generated if a single texture slice is
        simultaneously bound to an active pixel local storage plane and attached
        to an enabled drawbuffer.

    Errors generated by EndPixelLocalStorageANGLE():

      * INVALID_FRAMEBUFFER_OPERATION is generated if pixel local storage on the
        draw framebuffer is in an interrupted state. (See section 2.X.2
        "Interrupting Pixel Local Storage")

      * INVALID_OPERATION is generated if
        PIXEL_LOCAL_STORAGE_ACTIVE_PLANES_ANGLE is zero.

      * INVALID_VALUE is generated if
        <n> != PIXEL_LOCAL_STORAGE_ACTIVE_PLANES_ANGLE.

      * INVALID_ENUM is generated if
        <storeops>[0..PIXEL_LOCAL_STORAGE_ACTIVE_PLANES_ANGLE-1] is not one of
        the Store Operations enumerated in Table X.2.

    A successful call to BeginPixelLocalStorageANGLE() has the following side
    effects:

      * Pixel local storage planes indexed in the range [0..<n>-1] are fully
        activated, initialized and available for fragment shaders to read and
        write.

      * PIXEL_LOCAL_STORAGE_ACTIVE_PLANES_ANGLE is updated to equal <n>.

      * OpenGL ES 3.1, implementation-dependent: FRAMEBUFFER_DEFAULT_WIDTH and
        FRAMEBUFFER_DEFAULT_HEIGHT may reflect the dimensions of the pixel local
        storage planes, instead of their original values. This will last until
        pixel local storage ends.

    Pixel local storage data will persist across all fragment invocations and
    across all draws issued until the application calls
    EndPixelLocalStorageANGLE(), or until a command is issued that implicitly
    destroys the active render pass.

    When a command destroys the active render pass, it is as if
    EndPixelLocalStorageANGLE() had been called with
    <n>=PIXEL_LOCAL_STORAGE_ACTIVE_PLANES_ANGLE and <storeops> of
    STORE_OP_STORE_ANGLE. These commands are defined as:

      * Commands that modify the framebuffer in any way, or change any
        framebuffer binding.

        e.g., BindFramebuffer, DeleteTextures/DeleteRenderbuffers (if
        destroying an object attached to the draw framebuffer), DrawBuffers,
        FramebufferTexture*, FramebufferRenderbuffer, FramebufferParameteri,
        FramebufferMemorylessPixelLocalStorageANGLE, etc.

      * Commands that transfer pixels in or out of the framebuffer.

        e.g., ReadPixels, BlitFramebuffer, CopyTexImage2D, CopyTexSubImage*,
        etc.

      * Commands that invalidate tiled memory.

        e.g., DiscardFramebufferEXT, InvalidateFramebuffer,
        InvalidateSubFramebuffer, etc.

      * BeginTransformFeedback
      * StartTilingQCOM

    In order to guarantee that pixel local storage contents remain valid,
    additional restrictions go into effect while
    PIXEL_LOCAL_STORAGE_ACTIVE_PLANES_ANGLE is nonzero:

      * INVALID_OPERATION is generated by calls that would modify an active
        pixel local storage backing texture.

        e.g., TexSubImage*, TexParameter*, GenerateMipmap,
        InvalidateTextureANGLE, etc.

      * INVALID_OPERATION is generated by Enable(), Disable() if <cap> is not
        one of: BLEND, CULL_FACE, DEBUG_OUTPUT, DEBUG_OUTPUT_SYNCHRONOUS,
        DEPTH_CLAMP_EXT, DEPTH_TEST, POLYGON_OFFSET_POINT_NV,
        POLYGON_OFFSET_LINE_NV, POLYGON_OFFSET_LINE_ANGLE, POLYGON_OFFSET_FILL,
        PRIMITIVE_RESTART_FIXED_INDEX, RASTERIZER_DISCARD, SCISSOR_TEST,
        SCISSOR_TEST_EXCLUSIVE_NV, STENCIL_TEST, CLIP_DISTANCE[0..7]_EXT

      * INVALID_OPERATION is generated by Enablei*(), Disablei*() if <cap> is
        not one of: BLEND, SCISSOR_TEST, SCISSOR_TEST_EXCLUSIVE_NV

      * INVALID_OPERATION is generated by BlendFunc*() if <srcRGB>, <dstRGB>,
        <srcAlpha>, or <dstAlpha> is a blend function requiring the secondary
        color input, as specified in EXT_blend_func_extended (SRC1_COLOR_EXT,
        ONE_MINUS_SRC1_COLOR_EXT, SRC1_ALPHA_EXT, ONE_MINUS_SRC1_ALPHA_EXT).

      * INVALID_OPERATION is generated by BlendEquation*() if <mode> is one of
        the advanced blend equations defined in KHR_blend_equation_advanced.

      * INVALID_OPERATION is generated if a draw is issued with a fragment
        shader that has a pixel local uniform bound to an inactive pixel local
        storage plane.

      * INVALID_OPERATION is generated if a draw is issued with a fragment
        shader that does _not_ have a pixel local uniform bound to an _active_
        pixel local storage plane (i.e., the fragment shader must declare
        uniforms bound to every single active pixel local storage plane).

        This is because many backend implementations need to account for every
        active pixel local storage plane, even if the application code does not
        access it during a particular shader invocation.

      * INVALID_OPERATION is generated if a draw is issued with a fragment
        shader that has a pixel local storage uniform whose format layout
        qualifier does not identically match the internalformat of its
        associated pixel local storage plane on the current draw framebuffer, as
        enumerated in Table X.3.

      * INVALID_OPERATION is generated if a draw is issued while either of the
        following two constraints are violated:

        (a) If the fragment shader declares index zero output, then attachment
        zero must be present, and have a compatible numeric type.

        (b) If attachment zero is present, it must be enabled.

    Because of the "implementation-dependent" clause of the framebuffer
    completeness test, and because a pixel local storage implementation may add
    additional attachments to the underlying framebuffer object, it is strongly
    advised that an application also check to see if the framebuffer is complete
    after BeginPixelLocalStorageANGLE() and prior to rendering. (See section
    4.4.4.2 "Whole Framebuffer Completeness".)

    If BeginPixelLocalStorageANGLE() generates an error,
    PIXEL_LOCAL_STORAGE_ACTIVE_PLANES_ANGLE is not modified, and a balancing
    call to EndPixelLocalStorageANGLE() may therefore also generate an error.

    When PIXEL_LOCAL_STORAGE_ACTIVE_PLANES_ANGLE is zero, any draw issued with a
    fragment shader that declares pixel local storage uniforms generates an
    INVALID_FRAMEBUFFER_OPERATION error.

  Section 2.X.1 "Non-coherent Pixel Local Storage"

    When GL_ANGLE_shader_pixel_local_storage_coherent is _not_ supported, or
    when accessing planes that use the "noncoherent" layout qualifier,
    applications must split their rendering of pixel local storage into separate
    passes, none of which touch an individual pixel more than once. The command:

      void PixelLocalStorageBarrierANGLE()

    Errors:

      * INVALID_FRAMEBUFFER_OPERATION is generated if pixel local storage on the
        draw framebuffer is in an interrupted state. (See section 2.X.2
        "Interrupting Pixel Local Storage")

      * INVALID_OPERATION is generated if
        PIXEL_LOCAL_STORAGE_ACTIVE_PLANES_ANGLE is zero.

    delimits a boundary between distinct, non-self-overlapping rendering passes.
    Pixel local storage loads issued after the barrier will reflect stores
    issued prior to the barrier, and stores issued after the barrier will not
    execute until all accesses initiated prior to the barrier are complete.

    Rendering to the same pixel more than once without a barrier in between can
    yield incorrect results in pixel local storage, however, "incorrect" does
    _not_ mean they can be random, uninitialized, or leaked from outside the
    current draw framebuffer. Any artifacts are strictly a result of race
    conditions between overlapping fragment invocations involved in the current
    rendering pass.

  Section 2.X.2 "Interrupting Pixel Local Storage"

    An application may need to interrupt a pixel local storage rendering pass.
    One example of this may be a browser implementing WebGL. The command:

      void FramebufferPixelLocalStorageInterruptANGLE()

    Errors:

      * INVALID_FRAMEBUFFER_OPERATION is generated if the current interrupt
        count on the draw framebuffer is equal to 255.

    Increments an interrupt counter on the current draw framebuffer. When the
    counter increments from 0 to 1, and PIXEL_LOCAL_STORAGE_ACTIVE_PLANES_ANGLE
    is nonzero, this command also ends pixel local storage using
    STORE_OP_STORE_ANGLE for every plane. The contents of any memoryless planes
    are lost. The counter value cannot be incremented greater than 255. This
    command is ignored when the default framebuffer object name 0 is bound. When
    a framebuffer's pixel local storage interupt counter is nonzero, it is
    considered to be in an "interrupted" state.

    The command:

      void FramebufferPixelLocalStorageRestoreANGLE()

    Errors:

      * INVALID_FRAMEBUFFER_OPERATION is generated if pixel local storage on the
        draw framebuffer is not in an interrupted state.

    Decrements the pixel local storage interrupt counter on the current draw
    framebuffer. When the counter decrements from 1 to 0, and
    PIXEL_LOCAL_STORAGE_ACTIVE_PLANES_ANGLE was nonzero at the time this
    framebuffer entered an interrupted state, the command also begins pixel
    local storage using LOAD_OP_LOAD_ANGLE for texture backed planes and
    DONT_CARE for memoryless planes. The number of planes activated is equal to
    the value of PIXEL_LOCAL_STORAGE_ACTIVE_PLANES_ANGLE at the time this
    framebuffer entered an interrupted state. This command is ignored when the
    default framebuffer object name 0 is bound.

  Modify Section 3.8.10.3 "Rendering Feedback Loops"

  (Modify the second bullet point)

    * The texture is attached to one of the attachment points or active pixel
      local storage planes, A, of framebuffer object F

  Modify Section 4.4.2 "Attaching Images to Framebuffer Objects"

  (Add a new paragraph to 4.4.2.3 "Attaching Renderbuffer Images to a
   Framebuffer".)

    If a renderbuffer object is deleted while its image is attached to the
    currently bound draw framebuffer, and pixel local storage is active, then it
    is as if EndPixelLocalStorageANGLE() had been called with
    <n>=PIXEL_LOCAL_STORAGE_ACTIVE_PLANES_ANGLE and <storeops> of
    STORE_OP_STORE_ANGLE.

  (Add a new paragraph to 4.4.2.4 "Attaching Texture Images to a Framebuffer".)

    If a texture object is deleted while its image is attached to the currently
    bound draw framebuffer, and pixel local storage is active, then it is as if
    EndPixelLocalStorageANGLE() had been called with
    <n>=PIXEL_LOCAL_STORAGE_ACTIVE_PLANES_ANGLE and <storeops> of
    STORE_OP_STORE_ANGLE.

  (Insert two new numbered section after 4.4.2.4 "Attaching Texture Images to a
   Framebuffer".)

  Section 4.4.2.X "Configuring Pixel Local Storage on a Framebuffer"

    The GL provides an array of configurable pixel local storage planes on
    framebuffer objects. These planes are numbered beginning with zero, with the
    total number of pixel local storage planes provided given by the
    implementation-dependent constant MAX_PIXEL_LOCAL_STORAGE_PLANES_ANGLE.
    Fragment shaders may access pixel local storage data as described in OpenGL
    ES Shading Language Specification. Initially, pixel local storage planes are
    in a deinitialized state and are unusable.

    A memoryless pixel local storage plane may be established on the current
    draw framebuffer by calling:

      void FramebufferMemorylessPixelLocalStorageANGLE(int plane,
                                                       enum internalformat)

    Parameters:

      * <plane> identifies the pixel local storage plane index.

      * <internalformat> selects the data format, as enumerated in Table X.3.

        internalformat   Clear Value Type   Pixel Local Type   format qualifier
        -----------------------------------------------------------------------
        RGBA8            FLOAT              pixelLocalANGLE    rgba8
        RGBA8I           INT                ipixelLocalANGLE   rgba8i
        RGBA8UI          UNSIGNED_INT       upixelLocalANGLE   rgba8ui
        R32F             FLOAT              pixelLocalANGLE    r32f
        R32I             INT                ipixelLocalANGLE   r32i
        R32UI            UNSIGNED_INT       upixelLocalANGLE   r32ui

        Table X.3: Supported pixel local storage internalformats, with the Clear
        Value Type used by BeginPixelLocalStorageANGLE(), and their required
        corresponding GLSL Pixel Local Type and format layout qualifier.

        Note that all pixel local storage formats consume exactly 4 bytes of
        storage.

    Errors:

      * INVALID_FRAMEBUFFER_OPERATION is generated if the default framebuffer
        object name 0 is bound to DRAW_FRAMEBUFFER.

      * INVALID_FRAMEBUFFER_OPERATION is generated if pixel local storage on the
        draw framebuffer is in an interrupted state. (See section 2.X.2
        "Interrupting Pixel Local Storage")

      * INVALID_OPERATION is generated if
        PIXEL_LOCAL_STORAGE_ACTIVE_PLANES_ANGLE is nonzero.

      * INVALID_VALUE is generated if
        <plane> < 0 or <plane> >= MAX_PIXEL_LOCAL_STORAGE_PLANES_ANGLE.

      * INVALID_ENUM is generated if <internalformat> is not one of the
        acceptable values in Table X.3, or NONE.

      * INVALID_OPERATION is generated if <internalformat> is not NONE and not
        color-renderable.

    If <internalformat> is NONE, the pixel local storage plane at index <plane>
    is deinitialized and any internal storage is released.

    Otherwise, this call establishes a formatted plane of pixel local storage
    data at index <plane>, accessible exclusively to fragment shaders, whose
    liftetime will be scoped between calls to BeginPixelLocalStorageANGLE() and
    EndPixelLocalStorageANGLE(). The pixel local storage plane is "memoryless"
    from the application's perspective; its contents are cleared upon calling
    BeginPixelLocalStorageANGLE(), and its contents are lost after the
    application calls EndPixelLocalStorageANGLE(). The implementation will make
    a best effort to store this data exclusively in high performance local
    caches, e.g., tiled memory, but accessing the data may still result in
    memory transactions on some platforms.

    Additionally, the GL supports binding a layer of an immutable texture object
    to pixel local storage. In this scenario, the pixel local storage data is
    not lost upon calling EndPixelLocalStorageANGLE(), but rather, will be
    stored in the given texture image. Such behavior is useful for applications
    such as blending in the fragment shader, where the application renders to
    pixel local storage instead of a color attachment.

    When a texture image is bound to pixel local storage, the application may
    also choose to initialize the pixel local storage plane using its bound
    texture image contents during BeginPixelLocalStorageANGLE(), by passing Load
    Operation LOAD_OP_LOAD_ANGLE.

    An immutable texture layer image may be bound to a pixel local storage plane
    on the current draw framebuffer by calling:

      void FramebufferTexturePixelLocalStorageANGLE(int plane,
                                                    uint backingtexture,
                                                    int level,
                                                    int layer)

    Parameters:

      * <plane> identifies the pixel local storage plane index.

      * <backingtexture> specifies the name of an existing immutable texture
                         object to bind.

      * <level> selectes the mipmap level to bind.

      * <layer> specifies the texture layer to bind:

        - Zero if <backingtexture> is a TEXTURE_2D
        - The array index to bind if <backingtexture> is a TEXTURE_2D_ARRAY
        - The cube map face index to bind if <backingtexture> is a
          TEXTURE_CUBE_MAP; indices zero to five correspond to the following
          cube map faces: +X, -X, +Y, -Y, +Z, -Z
        - The cube map array layer-face index to bind if <backingtexture> is a
          TEXTURE_CUBE_MAP_ARRAY_EXT, TEXTURE_CUBE_MAP_ARRAY_OES, or
          TEXTURE_CUBE_MAP_ARRAY

    Errors:

      * INVALID_FRAMEBUFFER_OPERATION is generated if the default framebuffer
        object name 0 is bound to DRAW_FRAMEBUFFER.

      * INVALID_FRAMEBUFFER_OPERATION is generated if pixel local storage on the
        draw framebuffer is in an interrupted state. (See section 2.X.2
        "Interrupting Pixel Local Storage")

      * INVALID_OPERATION is generated if
        PIXEL_LOCAL_STORAGE_ACTIVE_PLANES_ANGLE is nonzero.

      * INVALID_VALUE is generated if
        <plane> < 0 or <plane> >= MAX_PIXEL_LOCAL_STORAGE_PLANES_ANGLE.

      * INVALID_OPERATION is generated if <backingtexture> is not the name of an
        existing immutable texture object, or zero.

      * INVALID_OPERATION is generated if <backingtexture> is nonzero and not of
        type TEXTURE_2D, TEXTURE_2D_ARRAY, TEXTURE_CUBE_MAP,
        TEXTURE_CUBE_MAP_ARRAY_EXT, TEXTURE_CUBE_MAP_ARRAY_OES, or
        TEXTURE_CUBE_MAP_ARRAY.

      * INVALID_VALUE is generated if <backingtexture> is nonzero and
        <level> < 0.

      * INVALID_VALUE is generated if <backingtexture> is nonzero and
        <level> >= the immutable number of mipmap levels in <backingtexture>.

      * INVALID_VALUE is generated if <backingtexture> is nonzero and
        <layer> < 0.

      * INVALID_VALUE is generated if <backingtexture> is nonzero and
        <layer> >= the immutable number of texture layers in <backingtexture>.

      * INVALID_ENUM is generated if <backingtexture> is nonzero and its
        internalformat is not one of the acceptable values in Table X.3.

      * INVALID_OPERATION is generated if <backingtexture> is nonzero and its
        internalformat is not color-renderable.

    If <backingtexture> is 0, <level> and <layer> are ignored and the pixel
    local storage plane <plane> is deinitialized.

    Otherwise, this call establishes a formatted plane of pixel local storage
    data at index <plane>, whose contents are bound to the given texture layer
    image.

    When a texture object is deleted, any pixel local storage plane to which it
    is bound is automatically deinitialized.

    If a texture object is deleted while its image is bound to a pixel local
    storage plane on the currently bound draw framebuffer, and pixel local
    storage is active, then it is as if EndPixelLocalStorageANGLE() had been
    called with <n>=PIXEL_LOCAL_STORAGE_ACTIVE_PLANES_ANGLE and <storeops> of
    STORE_OP_STORE_ANGLE.

  Section 4.4.2.Y "Pixel Local Clear State"

    Each pixel local storage plane on a framebuffer has state for three separate
    clear values: a 4-component vector of type FLOAT, INT, and UNSIGNED_INT.
    When the Load Operation LOAD_OP_CLEAR_ANGLE is executed, a pixel local
    storage plane is cleared to the value whose type corresponds to its
    internalformat. (See Table X.3.) Clear values are set with the commands:

      void FramebufferPixelLocalClearValuefvANGLE(int plane,
                                                  const float value[])

      void FramebufferPixelLocalClearValueivANGLE(int plane,
                                                  const int value[])

      void FramebufferPixelLocalClearValueuivANGLE(int plane,
                                                   const uint value[])

    Parameters:

      * <plane> identifies the pixel local storage plane index.

      * <value> specifies the new 4-component clear value.

    Description:

      Sets the clear value state of specific type for a plane of pixel local
      storage on the current draw framebuffer.

    Errors:

      * INVALID_FRAMEBUFFER_OPERATION is generated if the default framebuffer
        object name 0 is bound to DRAW_FRAMEBUFFER.

      * INVALID_FRAMEBUFFER_OPERATION is generated if pixel local storage on the
        draw framebuffer is in an interrupted state. (See section 2.X.2
        "Interrupting Pixel Local Storage")

      * INVALID_VALUE is generated if
        <plane> < 0 or <plane> >= MAX_PIXEL_LOCAL_STORAGE_PLANES_ANGLE.

  Modify Section 6.1 "Querying GL State"

  (Insert a new numbered section after 6.1.14 "Renderbuffer Object Queries".)

  Section 6.1.X "Pixel Local Storage Queries"

    The application may query the state of a pixel local storage plane on the
    current draw famebuffer using the commands:

      void GetFramebufferPixelLocalStorageParameterfvANGLE(int plane,
                                                           enum pname,
                                                           GLfloat *params)

      void GetFramebufferPixelLocalStorageParameterivANGLE(int plane,
                                                           enum pname,
                                                           GLint *params)

    Parameters:

      * <plane> identifies the pixel local storage plane index.

      * <pname> specifies the parameter of the plane to query.

      * <params> receives the value(s) for parameter <pname> of the pixel local
        storage plane at index <plane>. When an error is generated, nothing is
        written to <params>.

    Description:

      * If <pname> is PIXEL_LOCAL_FORMAT_ANGLE, <params> will contain the
        internalformat of the plane from Table X.3, or NONE if the selected
        pixel local storage plane is in a deinitialized state.

      * If <pname> is PIXEL_LOCAL_TEXTURE_NAME_ANGLE, <params> will contain the
        name of the immutable texture object which contains the image bound to
        the plane, or 0 if the plane is memoryless or deinitialized.

        Note that when the texture object bound to a plane is deleted, the plane
        is automatically converted to memoryless. See section 4.4.2.X
        "Configuring Pixel Local Storage on a Framebuffer".

      * If <pname> is PIXEL_LOCAL_TEXTURE_LEVEL_ANGLE, <params> will contain the
        mipmap level of the bound texture object, or 0 if the plane is
        memoryless or deinitialized.

      * If <pname> is PIXEL_LOCAL_TEXTURE_LAYER_ANGLE, <params> will contain the
        layer of the bound texture object, or 0 if the plane is memoryless or
        deinitialized.

      * If <pname> is PIXEL_LOCAL_CLEAR_VALUE_FLOAT_ANGLE,
        PIXEL_LOCAL_CLEAR_VALUE_INT_ANGLE, or
        PIXEL_LOCAL_CLEAR_VALUE_UNSIGNED_INT_ANGLE, <params> will contain 4
        values: the 4 color components of the clear value of corresponding type.

    Errors:

      * INVALID_FRAMEBUFFER_OPERATION is generated if the default framebuffer
        object name 0 is bound to DRAW_FRAMEBUFFER.

      * INVALID_VALUE is generated if
        <plane> < 0 or <plane> >= MAX_PIXEL_LOCAL_STORAGE_PLANES_ANGLE.

      * INVALID_ENUM is generated if <pname> is not in Table 6.Y.

      * INVALID_VALUE is generated if <params> is NULL.

    If ANGLE_robust_client_memory is supported, the alternative query commands
    may also be used:

      void GetFramebufferPixelLocalStorageParameterfvRobustANGLE(int plane,
                                                                 enum pname,
                                                                 GLsizei bufSize,
                                                                 GLsizei *length,
                                                                 GLfloat *params)

      void GetFramebufferPixelLocalStorageParameterivRobustANGLE(int plane,
                                                                 enum pname,
                                                                 GLsizei bufSize,
                                                                 GLsizei *length,
                                                                 GLint *params)

    Additional Parameters:

      * <bufSize> indicates the maximum number of values that can be written to
        <params>.

      * <length> may be NULL. If not NULL, it receives the number of values
        written to <params>. When an error is generated, nothing is written to
        <length>.

    Additional Errors:

      * INVALID_OPERATION is generated if <bufSize> is not large enough to
        receive the requested parameter.


  Modify Section 6.1 "State Tables"

  (Insert two new numbered tables.)

                                                          Minimum
    Get Value                          Type  Get Command    Value       Sec.
    ------------------------------------------------------------------------
    MAX_PIXEL_LOCAL_STORAGE-
    _PLANES_ANGLE                       Z+   GetIntegerv      4      4.4.2.X

    MAX_COMBINED_DRAW_BUFFERS_AND-
    _PIXEL_LOCAL_STORAGE_PLANES_ANGLE   Z+   GetIntegerv      4          2.X

    Table 6.X: Impementation Dependent Pixel Local Storage Limits

                                                                Initial
    Get Value                  Type  Get Command                 Value    Sec.
    --------------------------------------------------------------------------
    PIXEL_LOCAL_STORAGE-
    _ACTIVE_PLANES_ANGLE        Z+   GetIntegerv                   0       2.X

    PIXEL_LOCAL_FORMAT-              GetFramebufferPixelLocal-
    _ANGLE                      Z+   StorageParameterivANGLE     NONE    6.1.X

    PIXEL_LOCAL_TEXTURE-             GetFramebufferPixelLocal-
    _NAME_ANGLE                 Z+   StorageParameterivANGLE       0     6.1.X

    PIXEL_LOCAL_TEXTURE-             GetFramebufferPixelLocal-
    _LEVEL_ANGLE                Z+   StorageParameterivANGLE       0     6.1.X

    PIXEL_LOCAL_TEXTURE-             GetFramebufferPixelLocal-
    _LAYER_ANGLE                Z    StorageParameterivANGLE       0     6.1.X

    PIXEL_LOCAL_CLEAR-               GetFramebufferPixelLocal-
    _VALUE_FLOAT_ANGLE         4*R   StorageParameterfvANGLE    0,0,0,0  6.1.X

    PIXEL_LOCAL_CLEAR-               GetFramebufferPixelLocal-
    _VALUE_INT_ANGLE           4*Z   StorageParameterivANGLE    0,0,0,0  6.1.X

    PIXEL_LOCAL_CLEAR_VALUE-         GetFramebufferPixelLocal-
    _UNSIGNED_INT_ANGLE        4*Z+  StorageParameterivANGLE    0,0,0,0  6.1.X

    Table 6.Y: Pixel Local Storage State


Interactions with the ANGLE_request_extension specification

    When either ANGLE_shader_pixel_local_storage or
    ANGLE_shader_pixel_local_storage_coherent is enabled, the following
    extensions are all implicitly enabled, if supported:

      * OES_draw_buffers_indexed
      * EXT_draw_buffers_indexed
      * EXT_shader_framebuffer_fetch_non_coherent
      * ANGLE_shader_pixel_local_storage_coherent
      * ANGLE_shader_pixel_local_storage

Interactions with ANGLE_provoking_vertex, ANGLE_polygon_mode,
EXT_blend_func_extended, EXT_clip_control, EXT_clip_cull_distance,
EXT_depth_clamp, EXT_draw_buffers_indexed, EXT_polygon_offset_clamp,
EXT_texture_cube_map_array, KHR_blend_equation_advanced, KHR_debug,
NV_polygon_mode, NV_scissor_exclusive, OES_draw_buffers_indexed,
OES_texture_cube_map_array

    If any of these extensions is not supported, ignore the applicable
    references to the extension itself, and to BlendEquationSeparatei*,
    BlendEquationi*, BlendFuncSeparatei*, BlendFunci*, ColorMaski*,
    DebugMessageCallback*, DebugMessageControl*, DebugMessageInsert*, Disablei*,
    ClipControlEXT, Enablei*, ObjectLabel*, PolygonMode*, PolygonOffsetClampEXT,
    ProvokingVertexANGLE, ObjectPtrLabel*, PopDebugGroup*, PushDebugGroup*,
    DEBUG_OUTPUT, DEBUG_OUTPUT_SYNCHRONOUS, SCISSOR_TEST_EXCLUSIVE_NV,
    CLIP_DISTANCE[0..7]_EXT, POLYGON_OFFSET_POINT_NV, POLYGON_OFFSET_LINE_NV,
    POLYGON_OFFSET_LINE_ANGLE, TEXTURE_CUBE_MAP_ARRAY_EXT,
    TEXTURE_CUBE_MAP_ARRAY_OES symbols.

Interactions with OpenGL ES 3.1

  Modify Section 8.22 "Texture Image Loads and Stores"

  (Modify the final paragraph.)

  Add active pixel local storage planes to the list of resource types that count
  against MAX_COMBINED_SHADER_OUTPUT_RESOURCES.

Interactions with OpenGL ES 3.2

  If OpenGL ES 3.2 is not supported, ignore all references to the
  TEXTURE_CUBE_MAP_ARRAY symbol.

Additions to the OpenGL ES Shading Language Specification, Version 3.00

    Including the following line in a fragment shader controls the language
    features described in this extension:

      #extension GL_ANGLE_shader_pixel_local_storage : <behavior>

    Where <behavior> is as specified in section 3.5.

    Whether or not the application relies on the "_coherent" extension string
    from the OpenGL ES API side, the language features described in this section
    are identical, and fragment shaders should only enable
    GL_ANGLE_shader_pixel_local_storage.

  Modify Section 4.1 "Basic Types"

    (Add the following new types.)

    Pixel Local Types (opaque)

      * pixelLocalANGLE
          a handle for accessing floating-point pixel local storage data

      * ipixelLocalANGLE
          a handle for accessing integer pixel local storage data

      * upixelLocalANGLE
          a handle for accessing unsigned integer pixel local storage data

  Modify Section 4.1.7 "Opaque Types"

  (Insert a new numbered section after 4.1.7.1 "Samplers".)

  Section 4.1.7.X "Pixel Local Storage"

    Pixel local types (e.g. pixelLocalANGLE) are opaque types. They are handles
    for accessing user-defined data that is associated with the pixel being
    covered. They are used with the built-in functions described in section 8.X
    "Pixel Local Storage Functions".

    In addition to the limitations already imposed on opaque types, pixel local
    types are subject to additional constraints:

      * They cannot be aggregated in arrays.

      * As uniforms, they must be declared at global scope; they cannot be
        declared in structs or interface blocks.

      * As uniforms, they are not visible to the OpenGL ES API and cannot be
        accessed via GetUniformLocation() or GetActiveUniform(). (This
        facilitates backends that are implemented entirely in-shader, e.g.,
        EXT_shader_pixel_local_storage.)

      * As uniforms, they must declare "binding" and "format" layout qualifiers,
        as described in section 4.3.8.X "Pixel Local Storage Layout Qualifiers".

      * As function arguments, they cannot have layout qualifiers. Any function
        that accepts pixel local type(s) as arguments is inlined by the compiler,
        and the bindings and formats are determined at the call site.

      * They cannot be aliased; it is a compile-time error to declare two pixel
        local uniforms with duplicate binding layout qualifiers.

      * They can only be declared in a fragment shader.

    Fragment shaders that declare pixel local storage uniforms are subject to
    additional shader-wide restrictions as well:

      * discard is illegal

          When polyfilled with shader images, pixel local storage requires
          early_fragment_tests, which causes discard to interact differently
          with the depth and stencil tests.

          In order to ensure identical behavior across all backends (some of
          which may not have access to early_fragment_tests), we disallow
          discard if pixel local storage uniforms have been declared.

      * return from main() is illegal

          ARB_fragment_shader_interlock functions cannot be called within flow
          control, which includes any code that might execute after a return
          statement. To keep things simple, and since these "interlock" calls
          are automatically generated by the compiler inside of main(), we
          disallow return from main() if pixel local storage uniforms have been
          declared.

      * assignment to gl_FragDepth(EXT) or gl_SampleMask is illegal

          When polyfilled with shader images, pixel local storage requires
          early_fragment_tests, which causes assignments to gl_FragDepth(EXT)
          and gl_SampleMask to be ignored.

          In order to ensure identical behavior across all backends, we disallow
          assignment to these values if pixel local storage uniforms have been
          declared.

      * EXT_blend_func_extended: nonzero values of the <index> layout qualifier
        are illegal

          Nonzero <index> values may restrict the number of draw buffers, which
          can invalidate a PLS implementation.

      * EXT_blend_func_extended: multiple unassigned fragment output locations
        are illegal

          Since PLS may use additional internal fragment outputs, we ban all
          implicit fragment output assignments while PLS is in use.

      * KHR_blend_equation_advanced: "blend_support" layout qualifiers are
        illegal

          KHR_blend_equation_advanced is incompatible with multiple draw
          buffers, which is a required feature for many PLS implementations.

  Modify Section 4.3.8 "Layout Qualifiers"

  (Insert a new numbered section after 4.3.8.3 "Uniform Block Layout
   Qualifiers")

  Section 4.3.8.X "Pixel Local Storage Layout Qualifiers"

    The layout qualifier identifiers for pixel local storage types are:

      layout-qualifier-id
        binding = <integer-constant>
        <format>
        noncoherent

    Acceptable identifiers for <format> are enumerated in Table X.3.

    It is a compile-time error to declare a pixel local storage uniform that
    does not specify both the binding and format layout qualifiers, or to
    specify a format layout qualifier on any type other than that format's
    corresponding "Pixel Local Type", as enumerated in Table X.3.

    If noncoherent is specified, any raster ordering guarantees are relaxed when
    accessing the given plane, and the application is always responsible to
    issue PixelLocalStorageBarrierANGLE() commands between overlapping
    fragments.

  Modify Section 8 "Built-in Functions"

  (Insert a new numbered section after 8.9 "Fragment Processing Functions".)

  Section 8.X "Pixel Local Storage Functions"

    The built-in functions defined in this section accept pixel local storage
    handles (abbreviated as "PLS handles") in order to load and store data
    associated with the pixel being covered.

    A reference to a specific PLS plane is established by indexing into the
    current draw framebuffer's PLS planes using the PLS handle's "binding"
    layout qualifier. If any PLS handle references an inactive PLS plane, or a
    PLS plane whose internalformat does not match the handle's format, the
    shader does not execute and a draw-time error is generated in the OpenGL ES
    API instead.

    Syntax:

      vec4 pixelLocalLoadANGLE(pixelLocalANGLE handle)
      ivec4 pixelLocalLoadANGLE(ipixelLocalANGLE handle)
      uvec4 pixelLocalLoadANGLE(upixelLocalANGLE handle)

    Description:

      Reads the current pixel's data from the PLS plane referenced by <handle>.

    Syntax:

      void pixelLocalStoreANGLE(pixelLocalANGLE handle, vec4 value)
      void pixelLocalStoreANGLE(ipixelLocalANGLE handle, ivec4 value)
      void pixelLocalStoreANGLE(upixelLocalANGLE handle, uvec4 value)

    Description:

      Replaces the current pixel's data with <value> in the PLS plane referenced
      by <handle>. If the magnitude of <value> is too large to be represented in
      the PLS format, it is clamped.

  Modify Section 9 "Shading Language Grammar"

    (Add the following tokens to the lexical analysis.)

    PIXELLOCALANGLE IPIXELLOCALANGLE UPIXELLOCALANGLE


Interactions with GLSL ES 3.10

    If GLSL ES 3.10 is supported, pixel local storage and images cannot be used
    in the same shader; it is a compile time error for a shader to declare both
    image uniforms and pixel local storage uniforms.


Issues

    (1) EXT_shader_pixel_local_storage has a clause that PLS contents become
    undefined if an application causes color data to be flushed to the
    framebuffer. Can we use this extension and still guarantee the security of
    WebGL?

      RESOLVED: We have confirmation that all mobile vendors guarantee there's
      no data leaked from outside the render pass. There can be data leaked from
      normal framebuffer attachments to PLS planes, but said attachments
      themselves are not shared between WebGL contexts, so should not be a
      security concern.

      Imagination gave the caveat that we must also initialize PLS data up front
      in order to not get left-over data from a previous render pass, but this
      is exactly what our API is designed to do via load operations. If
      EXT_shader_pixel_local_storage2 is supported, we can clear PLS using
      ClearPixelLocalStorageuiEXT(). Otherwise, we can clear or load PLS data
      from a texture by issuing a fullscreen draw.

      Additionally, if the browser uses virtual contexts and wishes to interrupt
      a PLS render pass, it must be sure to internally call
      FramebufferPixelLocalStorageInterruptANGLE() before handing off control to
      the other virtual context, and FramebufferPixelLocalStorageRestoreANGLE()
      again before returning control.

    (2) Depending on the implementation, <loadops> of LOAD_OP_ZERO_ANGLE and
    LOAD_OP_LOAD_ANGLE can have very different performance characteristics.
    Would a <loadop> of DONT_CARE, which makes the PLS contents undefined, be
    acceptable in WebGL?

      RESOLVED: From a security standpoint, the crucial aspect is that the data
      doesn't come from another context, and that needs to be specified. Similar
      decisions have been made previously in performance-critical areas of the
      spec.

    (3) Should we support the ability to enable/disable pixel local storage
    planes on an individual basis? (e.g., "LOAD_OP_DISABLE_ANGLE".)

      RESOLVED: No. Some implementations need to reserve color attachments for
      internal use. Allowing any combination of planes to be enabled or disabled
      would make this specification unnecessarily complex. Furthermore, browsers
      implementing WebGL will need the ability to interrupt pixel local storage
      rendering passes, which would also be more complicated if we were to
      support enabling and disabling planes individually.

    (4) Should we support binding cube map layers to pixel local storage?

      RESOLVED: Yes. Cube map and cube map array layers use the same binding
      semantics as 2D array layers.

    (5) Can we support transform feedback?

      RESOLVED: No. Transform feedback can lead to render pass breaks in the
      Vulkan backend.

    (6) Should feedback loops between sampled textures and pixel local storage
    planes generate errors?

      RESOLVED: No. Follow the language for feedback loops between framebuffer
      attachments and sampled textures. Rendering results are undefined. Layered
      APIs such as WebGL make this case an error.
