| Flutter Impeller |

texture_gles.h
Go to the documentation of this file.
1 // Copyright 2013 The Flutter Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #ifndef FLUTTER_IMPELLER_RENDERER_BACKEND_GLES_TEXTURE_GLES_H_
6 #define FLUTTER_IMPELLER_RENDERER_BACKEND_GLES_TEXTURE_GLES_H_
7
8 #include <bitset>
9
10 #include "fml/logging.h"
11 #include "impeller/base/backend_cast.h"
12 #include "impeller/core/texture.h"
13 #include "impeller/renderer/backend/gles/handle_gles.h"
14 #include "impeller/renderer/backend/gles/reactor_gles.h"
15
16 namespace impeller {
17
18 class TextureGLES final : public Texture,
19 public BackendCast<TextureGLES, Texture> {
20 public:
21 enum class Type {
22 kTexture,
23 kTextureMultisampled,
24 kRenderBuffer,
25 kRenderBufferMultisampled,
26 };
27
28 //----------------------------------------------------------------------------
29 /// @brief Create a texture by wrapping an external framebuffer object
30 /// whose lifecycle is owned by the caller.
31 ///
32 /// This is useful for creating a render target for the default
33 /// window managed framebuffer.
34 ///
35 /// @param[in] reactor The reactor
36 /// @param[in] desc The description
37 /// @param[in] fbo The fbo
38 ///
39 /// @return If a texture representation of the framebuffer could be
40 /// created.
41 ///
42 static std::shared_ptr<TextureGLES> WrapFBO(
43 std::shared_ptr<ReactorGLES> reactor,
44 TextureDescriptor desc,
45 GLuint fbo);
46
47 //----------------------------------------------------------------------------
48 /// @brief Create a texture by wrapping an external OpenGL texture
49 /// handle. Ownership of the texture handle is assumed by the
50 /// reactor.
51 ///
52 /// @param[in] reactor The reactor
53 /// @param[in] desc The description
54 /// @param[in] external_handle The external handle
55 ///
56 /// @return If a texture representation of the framebuffer could be
57 /// created.
58 ///
59 static std::shared_ptr<TextureGLES> WrapTexture(
60 std::shared_ptr<ReactorGLES> reactor,
61 TextureDescriptor desc,
62 HandleGLES external_handle);
63
64 //----------------------------------------------------------------------------
65 /// @brief Create a "texture" that is never expected to be bound/unbound
66 /// explicitly or initialized in any way. It only exists to setup
67 /// a render pass description.
68 ///
69 /// @param[in] reactor The reactor
70 /// @param[in] desc The description
71 ///
72 /// @return If a texture placeholder could be created.
73 ///
74 static std::shared_ptr<TextureGLES> CreatePlaceholder(
75 std::shared_ptr<ReactorGLES> reactor,
76 TextureDescriptor desc);
77
78 TextureGLES(std::shared_ptr<ReactorGLES> reactor, TextureDescriptor desc);
79
80 // |Texture|
81 ~TextureGLES() override;
82
83 // |Texture|
84 bool IsValid() const override;
85
86 std::optional<GLuint> GetGLHandle() const;
87
88 [[nodiscard]] bool Bind() const;
89
90 [[nodiscard]] bool GenerateMipmap();
91
92 enum class AttachmentType {
93 kColor0,
94 kDepth,
95 kStencil,
96 };
97 [[nodiscard]] bool SetAsFramebufferAttachment(
98 GLenum target,
99 AttachmentType attachment_type) const;
100
101 Type GetType() const;
102
103 bool IsWrapped() const;
104
105 std::optional<GLuint> GetFBO() const;
106
107 //----------------------------------------------------------------------------
108 /// @brief Indicates that all texture storage has already been allocated
109 /// and contents initialized.
110 ///
111 /// This is similar to calling `MarkSliceInitialized` with all
112 /// slices.
113 ///
114 /// @see MarkSliceInitialized.
115 ///
116 void MarkContentsInitialized();
117
118 //----------------------------------------------------------------------------
119 /// @brief Indicates that a specific texture slice has been initialized.
120 ///
121 /// @param[in] slice The slice to mark as being initialized.
122 ///
123 void MarkSliceInitialized(size_t slice) const;
124
125 bool IsSliceInitialized(size_t slice) const;
126
127 //----------------------------------------------------------------------------
128 /// @brief Attach a sync fence to this texture that will be waited on
129 /// before encoding a rendering operation that references it.
130 ///
131 /// @param[in] fence A handle to a sync fence.
132 ///
133 void SetFence(HandleGLES fence);
134
135 /// Store the FBO object for recycling in the 2D renderer.
136 ///
137 /// The color0 texture used by the 2D renderer will use this texture
138 /// object to store the associated FBO the first time it is used.
139 void SetCachedFBO(HandleGLES fbo);
140
141 /// Retrieve the cached FBO object, or a dead handle if there is no object.
142 const HandleGLES& GetCachedFBO() const;
143
144 // Visible for testing.
145 std::optional<HandleGLES> GetSyncFence() const;
146
147 // visible for testing
148 Type ComputeTypeForBinding(GLenum target) const;
149
150 private:
151 std::shared_ptr<ReactorGLES> reactor_;
152 const Type type_;
153 HandleGLES handle_;
154 mutable std::optional<HandleGLES> fence_ = std::nullopt;
155 mutable std::bitset<6> slices_initialized_ = 0;
156 const bool is_wrapped_;
157 const std::optional<GLuint> wrapped_fbo_;
158 HandleGLES cached_fbo_ = HandleGLES::DeadHandle();
159 bool is_valid_ = false;
160
161 TextureGLES(std::shared_ptr<ReactorGLES> reactor,
162 TextureDescriptor desc,
163 std::optional<GLuint> fbo,
164 std::optional<HandleGLES> external_handle);
165
166 // |Texture|
167 void SetLabel(std::string_view label) override;
168
169 // |Texture|
170 void SetLabel(std::string_view label, std::string_view trailing) override;
171
172 // |Texture|
173 bool OnSetContents(const uint8_t* contents,
174 size_t length,
175 size_t slice) override;
176
177 // |Texture|
178 bool OnSetContents(std::shared_ptr<const fml::Mapping> mapping,
179 size_t slice) override;
180
181 // |Texture|
182 ISize GetSize() const override;
183
184 // |Texture|
185 Scalar GetYCoordScale() const override;
186
187 void InitializeContentsIfNecessary() const;
188
189 TextureGLES(const TextureGLES&) = delete;
190
191 TextureGLES& operator=(const TextureGLES&) = delete;
192 };
193
194 } // namespace impeller
195
196 #endif // FLUTTER_IMPELLER_RENDERER_BACKEND_GLES_TEXTURE_GLES_H_
backend_cast.h
impeller::BackendCast
Definition: backend_cast.h:11
impeller::HandleGLES
Represents a handle to an underlying OpenGL object. Unlike OpenGL object handles, these handles can b...
Definition: handle_gles.h:37
impeller::HandleGLES::DeadHandle
static HandleGLES DeadHandle()
Creates a dead handle.
Definition: handle_gles.h:44
impeller::TextureGLES
Definition: texture_gles.h:19
impeller::TextureGLES::WrapFBO
static std::shared_ptr< TextureGLES > WrapFBO(std::shared_ptr< ReactorGLES > reactor, TextureDescriptor desc, GLuint fbo)
Create a texture by wrapping an external framebuffer object whose lifecycle is owned by the caller.
Definition: texture_gles.cc:146
impeller::TextureGLES::MarkContentsInitialized
void MarkContentsInitialized()
Indicates that all texture storage has already been allocated and contents initialized.
Definition: texture_gles.cc:541
impeller::TextureGLES::GetCachedFBO
const HandleGLES & GetCachedFBO() const
Retrieve the cached FBO object, or a dead handle if there is no object.
Definition: texture_gles.cc:683
impeller::TextureGLES::GetSyncFence
std::optional< HandleGLES > GetSyncFence() const
Definition: texture_gles.cc:675
impeller::TextureGLES::IsSliceInitialized
bool IsSliceInitialized(size_t slice) const
Definition: texture_gles.cc:551
impeller::TextureGLES::Bind
bool Bind() const
Definition: texture_gles.cc:506
impeller::TextureGLES::Type
Type
Definition: texture_gles.h:21
impeller::TextureGLES::Type::kTexture
@ kTexture
impeller::TextureGLES::Type::kRenderBuffer
@ kRenderBuffer
impeller::TextureGLES::Type::kTextureMultisampled
@ kTextureMultisampled
impeller::TextureGLES::Type::kRenderBufferMultisampled
@ kRenderBufferMultisampled
impeller::TextureGLES::IsValid
bool IsValid() const override
Definition: texture_gles.cc:233
impeller::TextureGLES::SetFence
void SetFence(HandleGLES fence)
Attach a sync fence to this texture that will be waited on before encoding a rendering operation that...
Definition: texture_gles.cc:669
impeller::TextureGLES::AttachmentType
AttachmentType
Definition: texture_gles.h:92
impeller::TextureGLES::AttachmentType::kStencil
@ kStencil
impeller::TextureGLES::AttachmentType::kDepth
@ kDepth
impeller::TextureGLES::AttachmentType::kColor0
@ kColor0
impeller::TextureGLES::GetType
Type GetType() const
Definition: texture_gles.cc:589
impeller::TextureGLES::SetCachedFBO
void SetCachedFBO(HandleGLES fbo)
Definition: texture_gles.cc:679
impeller::TextureGLES::SetAsFramebufferAttachment
bool SetAsFramebufferAttachment(GLenum target, AttachmentType attachment_type) const
Definition: texture_gles.cc:604
impeller::TextureGLES::CreatePlaceholder
static std::shared_ptr< TextureGLES > CreatePlaceholder(std::shared_ptr< ReactorGLES > reactor, TextureDescriptor desc)
Create a "texture" that is never expected to be bound/unbound explicitly or initialized in any way....
Definition: texture_gles.cc:178
impeller::TextureGLES::TextureGLES
TextureGLES(std::shared_ptr< ReactorGLES > reactor, TextureDescriptor desc)
Definition: texture_gles.cc:184
impeller::TextureGLES::GetFBO
std::optional< GLuint > GetFBO() const
Definition: texture_gles.cc:665
impeller::TextureGLES::ComputeTypeForBinding
Type ComputeTypeForBinding(GLenum target) const
Definition: texture_gles.cc:400
impeller::TextureGLES::MarkSliceInitialized
void MarkSliceInitialized(size_t slice) const
Indicates that a specific texture slice has been initialized.
Definition: texture_gles.cc:547
impeller::TextureGLES::GenerateMipmap
bool GenerateMipmap()
Definition: texture_gles.cc:555
impeller::TextureGLES::GetGLHandle
std::optional< GLuint > GetGLHandle() const
Definition: texture_gles.cc:499
impeller::TextureGLES::~TextureGLES
~TextureGLES() override
Definition: texture_gles.cc:225
impeller::TextureGLES::WrapTexture
static std::shared_ptr< TextureGLES > WrapTexture(std::shared_ptr< ReactorGLES > reactor, TextureDescriptor desc, HandleGLES external_handle)
Create a texture by wrapping an external OpenGL texture handle. Ownership of the texture handle is as...
Definition: texture_gles.cc:158
impeller::TextureGLES::IsWrapped
bool IsWrapped() const
Definition: texture_gles.cc:661
impeller::Texture
Definition: texture.h:17
texture.h
handle_gles.h
impeller
Definition: allocation.cc:12
impeller::Scalar
float Scalar
Definition: scalar.h:18
reactor_gles.h
impeller::TSize
Definition: size.h:25
impeller::TextureDescriptor
A lightweight object that describes the attributes of a texture that can then used an allocator to cr...
Definition: texture_descriptor.h:38