1 //
2 // Copyright 2014 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 // FramebufferAttachment.h: Defines the wrapper class gl::FramebufferAttachment, as well as the
8 // objects and related functionality. [OpenGL ES 2.0.24] section 4.4.3 page 108.
9
10 #ifndef LIBANGLE_FRAMEBUFFERATTACHMENT_H_
11 #define LIBANGLE_FRAMEBUFFERATTACHMENT_H_
12
13 #include "angle_gl.h"
14 #include "common/angleutils.h"
15 #include "libANGLE/Error.h"
16 #include "libANGLE/ImageIndex.h"
17 #include "libANGLE/Observer.h"
18 #include "libANGLE/angletypes.h"
19 #include "libANGLE/formatutils.h"
20 #include "libANGLE/renderer/FramebufferAttachmentObjectImpl.h"
21
22 namespace egl
23 {
24 class Surface;
25 }
26
27 namespace rx
28 {
29 // An implementation-specific object associated with an attachment.
30
31 class FramebufferAttachmentRenderTarget : angle::NonCopyable
32 {
33 public:
FramebufferAttachmentRenderTarget()34 FramebufferAttachmentRenderTarget() {}
~FramebufferAttachmentRenderTarget()35 virtual ~FramebufferAttachmentRenderTarget() {}
36 };
37
38 class FramebufferAttachmentObjectImpl;
39 } // namespace rx
40
41 namespace gl
42 {
43 class FramebufferAttachmentObject;
44 class Renderbuffer;
45 class Texture;
46
47 // FramebufferAttachment implements a GL framebuffer attachment.
48 // Attachments are "light" containers, which store pointers to ref-counted GL objects.
49 // We support GL texture (2D/3D/Cube/2D array) and renderbuffer object attachments.
50 // Note: Our old naming scheme used the term "Renderbuffer" for both GL renderbuffers and for
51 // framebuffer attachments, which confused their usage.
52
53 class FramebufferAttachment final
54 {
55 public:
56 FramebufferAttachment();
57
58 FramebufferAttachment(const Context *context,
59 GLenum type,
60 GLenum binding,
61 const ImageIndex &textureIndex,
62 FramebufferAttachmentObject *resource,
63 rx::UniqueSerial framebufferSerial);
64
65 FramebufferAttachment(FramebufferAttachment &&other);
66 FramebufferAttachment &operator=(FramebufferAttachment &&other);
67
68 ~FramebufferAttachment();
69
70 void detach(const Context *context, rx::UniqueSerial framebufferSerial);
71 void attach(const Context *context,
72 GLenum type,
73 GLenum binding,
74 const ImageIndex &textureIndex,
75 FramebufferAttachmentObject *resource,
76 GLsizei numViews,
77 GLuint baseViewIndex,
78 bool isMultiview,
79 GLsizei samples,
80 rx::UniqueSerial framebufferSerial);
81
82 // Helper methods
83 GLuint getRedSize() const;
84 GLuint getGreenSize() const;
85 GLuint getBlueSize() const;
86 GLuint getAlphaSize() const;
87 GLuint getDepthSize() const;
88 GLuint getStencilSize() const;
89 GLenum getComponentType() const;
90 GLenum getColorEncoding() const;
91
isTextureWithId(TextureID textureId)92 bool isTextureWithId(TextureID textureId) const
93 {
94 return mType == GL_TEXTURE && id() == textureId.value;
95 }
isExternalTexture()96 bool isExternalTexture() const
97 {
98 return mType == GL_TEXTURE && getTextureImageIndex().getType() == gl::TextureType::External;
99 }
isRenderbufferWithId(GLuint renderbufferId)100 bool isRenderbufferWithId(GLuint renderbufferId) const
101 {
102 return mType == GL_RENDERBUFFER && id() == renderbufferId;
103 }
104
getBinding()105 GLenum getBinding() const { return mTarget.binding(); }
106 GLuint id() const;
107
108 // These methods are only legal to call on Texture attachments
109 const ImageIndex &getTextureImageIndex() const;
110 TextureTarget cubeMapFace() const;
111 GLint mipLevel() const;
112 GLint layer() const;
113 bool isLayered() const;
114
getNumViews()115 GLsizei getNumViews() const { return mNumViews; }
116
117 bool isMultiview() const;
118 GLint getBaseViewIndex() const;
119
120 bool isRenderToTexture() const;
121 GLsizei getRenderToTextureSamples() const;
122
123 // The size of the underlying resource the attachment points to. The 'depth' value will
124 // correspond to a 3D texture depth or the layer count of a 2D array texture. For Surfaces and
125 // Renderbuffers, it will always be 1.
126 Extents getSize() const;
127 Format getFormat() const;
128 GLsizei getSamples() const;
129 // This will always return the actual sample count of the attachment even if
130 // render_to_texture extension is active on this FBattachment object.
131 GLsizei getResourceSamples() const;
type()132 GLenum type() const { return mType; }
isAttached()133 bool isAttached() const { return mType != GL_NONE; }
134 bool isRenderable(const Context *context) const;
135 bool isYUV() const;
136 // Checks whether the attachment is an external image such as AHB or dmabuf, where
137 // synchronization is done without individually naming the objects that are involved. This
138 // excludes Vulkan images (EXT_external_objects) as they are individually listed during
139 // synchronization.
140 //
141 // This function is used to disable optimizations that involve deferring operations, as there is
142 // no efficient way to perform those deferred operations on sync if the specific objects are
143 // unknown.
144 bool isExternalImageWithoutIndividualSync() const;
145 bool hasFrontBufferUsage() const;
146 bool hasFoveatedRendering() const;
147 const gl::FoveationState *getFoveationState() const;
148
149 Renderbuffer *getRenderbuffer() const;
150 Texture *getTexture() const;
151 const egl::Surface *getSurface() const;
152 FramebufferAttachmentObject *getResource() const;
153 InitState initState() const;
154 angle::Result initializeContents(const Context *context) const;
155 void setInitState(InitState initState) const;
156
157 // "T" must be static_castable from FramebufferAttachmentRenderTarget
158 template <typename T>
getRenderTarget(const Context * context,GLsizei samples,T ** rtOut)159 angle::Result getRenderTarget(const Context *context, GLsizei samples, T **rtOut) const
160 {
161 static_assert(std::is_base_of<rx::FramebufferAttachmentRenderTarget, T>(),
162 "Invalid RenderTarget class.");
163 return getRenderTargetImpl(
164 context, samples, reinterpret_cast<rx::FramebufferAttachmentRenderTarget **>(rtOut));
165 }
166
167 bool operator==(const FramebufferAttachment &other) const;
168 bool operator!=(const FramebufferAttachment &other) const;
169
170 static const GLsizei kDefaultNumViews;
171 static const GLint kDefaultBaseViewIndex;
172 static const GLint kDefaultRenderToTextureSamples;
173
174 private:
175 angle::Result getRenderTargetImpl(const Context *context,
176 GLsizei samples,
177 rx::FramebufferAttachmentRenderTarget **rtOut) const;
178
179 // A framebuffer attachment points to one of three types of resources: Renderbuffers,
180 // Textures and egl::Surface. The "Target" struct indicates which part of the
181 // object an attachment references. For the three types:
182 // - a Renderbuffer has a unique renderable target, and needs no target index
183 // - a Texture has targets for every image and uses an ImageIndex
184 // - a Surface has targets for Color and Depth/Stencil, and uses the attachment binding
185 class Target
186 {
187 public:
188 Target();
189 Target(GLenum binding, const ImageIndex &imageIndex);
190 Target(const Target &other);
191 Target &operator=(const Target &other);
192
binding()193 GLenum binding() const { return mBinding; }
textureIndex()194 const ImageIndex &textureIndex() const { return mTextureIndex; }
195
196 private:
197 GLenum mBinding;
198 ImageIndex mTextureIndex;
199 };
200
201 GLenum mType;
202 Target mTarget;
203 FramebufferAttachmentObject *mResource;
204 GLsizei mNumViews;
205 bool mIsMultiview;
206 GLint mBaseViewIndex;
207 // A single-sampled texture can be attached to a framebuffer either as single-sampled or as
208 // multisampled-render-to-texture. In the latter case, |mRenderToTextureSamples| will contain
209 // the number of samples. For renderbuffers, the number of samples is inherited from the
210 // renderbuffer itself.
211 //
212 // Note that textures cannot change storage between single and multisample once attached to a
213 // framebuffer. Renderbuffers instead can, and caching the number of renderbuffer samples here
214 // can lead to stale data.
215 GLsizei mRenderToTextureSamples;
216 };
217
218 // A base class for objects that FBO Attachments may point to.
219 class FramebufferAttachmentObject : public angle::Subject, public angle::ObserverInterface
220 {
221 public:
222 FramebufferAttachmentObject();
223 ~FramebufferAttachmentObject() override;
224
225 virtual Extents getAttachmentSize(const ImageIndex &imageIndex) const = 0;
226 virtual Format getAttachmentFormat(GLenum binding, const ImageIndex &imageIndex) const = 0;
227 virtual GLsizei getAttachmentSamples(const ImageIndex &imageIndex) const = 0;
228 virtual bool isRenderable(const Context *context,
229 GLenum binding,
230 const ImageIndex &imageIndex) const = 0;
231 virtual bool isYUV() const = 0;
232 virtual bool isExternalImageWithoutIndividualSync() const = 0;
233 virtual bool hasFrontBufferUsage() const = 0;
234 virtual bool hasProtectedContent() const = 0;
235 virtual bool hasFoveatedRendering() const = 0;
236 virtual const gl::FoveationState *getFoveationState() const = 0;
237
238 virtual void onAttach(const Context *context, rx::UniqueSerial framebufferSerial) = 0;
239 virtual void onDetach(const Context *context, rx::UniqueSerial framebufferSerial) = 0;
240 virtual GLuint getId() const = 0;
241
242 // These are used for robust resource initialization.
243 virtual InitState initState(GLenum binding, const ImageIndex &imageIndex) const = 0;
244 virtual void setInitState(GLenum binding,
245 const ImageIndex &imageIndex,
246 InitState initState) = 0;
247
248 angle::Result getAttachmentRenderTarget(const Context *context,
249 GLenum binding,
250 const ImageIndex &imageIndex,
251 GLsizei samples,
252 rx::FramebufferAttachmentRenderTarget **rtOut) const;
253
254 angle::Result initializeContents(const Context *context,
255 GLenum binding,
256 const ImageIndex &imageIndex);
257
258 protected:
259 virtual rx::FramebufferAttachmentObjectImpl *getAttachmentImpl() const = 0;
260 };
261
getTextureImageIndex()262 inline const ImageIndex &FramebufferAttachment::getTextureImageIndex() const
263 {
264 ASSERT(type() == GL_TEXTURE);
265 return mTarget.textureIndex();
266 }
267
getSize()268 inline Extents FramebufferAttachment::getSize() const
269 {
270 ASSERT(mResource);
271 return mResource->getAttachmentSize(mTarget.textureIndex());
272 }
273
getFormat()274 inline Format FramebufferAttachment::getFormat() const
275 {
276 ASSERT(mResource);
277 return mResource->getAttachmentFormat(mTarget.binding(), mTarget.textureIndex());
278 }
279
getSamples()280 inline GLsizei FramebufferAttachment::getSamples() const
281 {
282 return isRenderToTexture() ? getRenderToTextureSamples() : getResourceSamples();
283 }
284
getResourceSamples()285 inline GLsizei FramebufferAttachment::getResourceSamples() const
286 {
287 ASSERT(mResource);
288 return mResource->getAttachmentSamples(mTarget.textureIndex());
289 }
290
getRenderTargetImpl(const Context * context,GLsizei samples,rx::FramebufferAttachmentRenderTarget ** rtOut)291 inline angle::Result FramebufferAttachment::getRenderTargetImpl(
292 const Context *context,
293 GLsizei samples,
294 rx::FramebufferAttachmentRenderTarget **rtOut) const
295 {
296 ASSERT(mResource);
297 return mResource->getAttachmentRenderTarget(context, mTarget.binding(), mTarget.textureIndex(),
298 samples, rtOut);
299 }
300
isRenderable(const Context * context)301 inline bool FramebufferAttachment::isRenderable(const Context *context) const
302 {
303 ASSERT(mResource);
304 return mResource->isRenderable(context, mTarget.binding(), mTarget.textureIndex());
305 }
306
isYUV()307 inline bool FramebufferAttachment::isYUV() const
308 {
309 ASSERT(mResource);
310 return mResource->isYUV();
311 }
312
isExternalImageWithoutIndividualSync()313 inline bool FramebufferAttachment::isExternalImageWithoutIndividualSync() const
314 {
315 ASSERT(mResource);
316 return mResource->isExternalImageWithoutIndividualSync();
317 }
318
hasFrontBufferUsage()319 inline bool FramebufferAttachment::hasFrontBufferUsage() const
320 {
321 ASSERT(mResource);
322 return mResource->hasFrontBufferUsage();
323 }
324
hasFoveatedRendering()325 inline bool FramebufferAttachment::hasFoveatedRendering() const
326 {
327 ASSERT(mResource);
328 return mResource->hasFoveatedRendering();
329 }
330
getFoveationState()331 inline const gl::FoveationState *FramebufferAttachment::getFoveationState() const
332 {
333 ASSERT(mResource);
334 return mResource->getFoveationState();
335 }
336 } // namespace gl
337
338 #endif // LIBANGLE_FRAMEBUFFERATTACHMENT_H_
339