1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
|
//
// 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_
|
