| Flutter Impeller |

Public Types | Public Member Functions | Static Public Member Functions | List of all members
impeller::TextureGLES Class Referencefinal

`#include <texture_gles.h>`

Inheritance diagram for impeller::TextureGLES:

## Public Types
enum class | Type { kTexture , kTextureMultisampled , kRenderBuffer , kRenderBufferMultisampled }
enum class | AttachmentType { kColor0 , kDepth , kStencil }

## Public Member Functions
| TextureGLES (std::shared_ptr< ReactorGLES > reactor, TextureDescriptor desc)
| ~TextureGLES () override
bool | IsValid () const override
std::optional< GLuint > | GetGLHandle () const
bool | Bind () const
bool | GenerateMipmap ()
bool | SetAsFramebufferAttachment (GLenum target, AttachmentType attachment_type) const
Type | GetType () const
bool | IsWrapped () const
void | Leak ()
| Reset the internal texture state so that the reactor will not free the associated handle. More...
std::optional< GLuint > | GetFBO () const
void | MarkContentsInitialized ()
| Indicates that all texture storage has already been allocated and contents initialized. More...
void | MarkSliceInitialized (size_t slice) const
| Indicates that a specific texture slice has been initialized. More...
bool | IsSliceInitialized (size_t slice) const
void | SetFence (HandleGLES fence)
| Attach a sync fence to this texture that will be waited on before encoding a rendering operation that references it. More...
void | SetCachedFBO (HandleGLES fbo)
const HandleGLES & | GetCachedFBO () const
| Retrieve the cached FBO object, or a dead handle if there is no object. More...
std::optional< HandleGLES > | GetSyncFence () const
Type | ComputeTypeForBinding (GLenum target) const
Public Member Functions inherited from impeller::Texture
virtual | ~Texture ()
bool | SetContents (const uint8_t *contents, size_t length, size_t slice=0, bool is_opaque=false)
bool | SetContents (std::shared_ptr< const fml::Mapping > mapping, size_t slice=0, bool is_opaque=false)
bool | IsOpaque () const
size_t | GetMipCount () const
const TextureDescriptor & | GetTextureDescriptor () const
void | SetCoordinateSystem (TextureCoordinateSystem coordinate_system)
TextureCoordinateSystem | GetCoordinateSystem () const
bool | NeedsMipmapGeneration () const

## Static Public Member Functions
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. More...
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 assumed by the reactor. More...
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. It only exists to setup a render pass description. More...
Static Public Member Functions inherited from impeller::BackendCast< TextureGLES, Texture >
static TextureGLES & | Cast (Texture &base)
static const TextureGLES & | Cast (const Texture &base)
static TextureGLES * | Cast (Texture *base)
static const TextureGLES * | Cast (const Texture *base)

## Additional Inherited Members
Protected Member Functions inherited from impeller::Texture
| Texture (TextureDescriptor desc)
Protected Attributes inherited from impeller::Texture
bool | mipmap_generated_ = false

## Detailed Description

Definition at line 18 of file texture_gles.h.

## Member Enumeration Documentation

## ◆ AttachmentType

enum impeller::TextureGLES::AttachmentType
| strong

Enumerator
kColor0 |
kDepth |
kStencil |

Definition at line 92 of file texture_gles.h.

92 {
93 kColor0,
94 kDepth,
95 kStencil,
96 };

## ◆ Type

enum impeller::TextureGLES::Type
| strong

Enumerator
kTexture |
kTextureMultisampled |
kRenderBuffer |
kRenderBufferMultisampled |

Definition at line 21 of file texture_gles.h.

21 {
22 kTexture,
23 kTextureMultisampled,
24 kRenderBuffer,
25 kRenderBufferMultisampled,
26 };
impeller::HandleType::kTexture
@ kTexture
impeller::HandleType::kRenderBuffer
@ kRenderBuffer

## Constructor & Destructor Documentation

## ◆ TextureGLES()

impeller::TextureGLES::TextureGLES | ( | std::shared_ptr< ReactorGLES > | reactor,
|  | TextureDescriptor | desc
| ) |  |

Definition at line 185 of file texture_gles.cc.

187 : TextureGLES(std::move(reactor), //
188 desc, //
189 std::nullopt, //
190 std::nullopt //
191 ) {}
impeller::TextureGLES::TextureGLES
TextureGLES(std::shared_ptr< ReactorGLES > reactor, TextureDescriptor desc)
Definition: texture_gles.cc:185

Referenced by WrapFBO(), and WrapTexture().

## ◆ ~TextureGLES()

impeller::TextureGLES::~TextureGLES | ( |  | ) |
| override

Definition at line 226 of file texture_gles.cc.

226 {
227 reactor_->CollectHandle(handle_);
228 if (!cached_fbo_.IsDead()) {
229 reactor_->CollectHandle(cached_fbo_);
230 }
231 }
impeller::HandleGLES::IsDead
constexpr bool IsDead() const
Determines if the handle is dead.
Definition: handle_gles.h:53

References impeller::HandleGLES::IsDead().

## Member Function Documentation

## ◆ Bind()

bool impeller::TextureGLES::Bind | ( |  | ) | const

Definition at line 511 of file texture_gles.cc.

511 {
512 auto handle = GetGLHandle();
513 if (!handle.has_value()) {
514 return false;
515 }
516 const auto& gl = reactor_->GetProcTable();
517
518 if (fence_.has_value()) {
519 std::optional<GLsync> fence = reactor_->GetGLFence(fence_.value());
520 if (fence.has_value()) {
521 gl.WaitSync(fence.value(), 0, GL_TIMEOUT_IGNORED);
522 }
523 reactor_->CollectHandle(fence_.value());
524 fence_ = std::nullopt;
525 }
526
527 switch (type_) {
528 case Type::kTexture:
529 case Type::kTextureMultisampled: {
530 const auto target = ToTextureTarget(GetTextureDescriptor().type);
531 if (!target.has_value()) {
532 VALIDATION_LOG << "Could not bind texture of this type.";
533 return false;
534 }
535 gl.BindTexture(target.value(), handle.value());
536 } break;
537 case Type::kRenderBuffer:
538 case Type::kRenderBufferMultisampled:
539 gl.BindRenderbuffer(GL_RENDERBUFFER, handle.value());
540 break;
541 }
542 InitializeContentsIfNecessary();
543 return true;
544 }
impeller::TextureGLES::Type::kTexture
@ kTexture
impeller::TextureGLES::Type::kRenderBuffer
@ kRenderBuffer
impeller::TextureGLES::Type::kTextureMultisampled
@ kTextureMultisampled
impeller::TextureGLES::Type::kRenderBufferMultisampled
@ kRenderBufferMultisampled
impeller::TextureGLES::GetGLHandle
std::optional< GLuint > GetGLHandle() const
Definition: texture_gles.cc:504
impeller::Texture::GetTextureDescriptor
const TextureDescriptor & GetTextureDescriptor() const
Definition: texture.cc:57
impeller::ToTextureTarget
constexpr std::optional< GLenum > ToTextureTarget(TextureType type)
Definition: formats_gles.h:185
type
GLenum type
Definition: texture_gles.cc:67
VALIDATION_LOG
#define VALIDATION_LOG
Definition: validation.h:91

References GetGLHandle(), impeller::Texture::GetTextureDescriptor(), kRenderBuffer, kRenderBufferMultisampled, kTexture, kTextureMultisampled, impeller::ToTextureTarget(), type, and VALIDATION_LOG.

Referenced by GenerateMipmap().

## ◆ ComputeTypeForBinding()

TextureGLES::Type impeller::TextureGLES::ComputeTypeForBinding | ( | GLenum | target | ) | const

Definition at line 405 of file texture_gles.cc.

405 {
406 // When binding to a GL_READ_FRAMEBUFFER, any multisampled
407 // textures must be bound as single sampled.
408 if (target == GL_READ_FRAMEBUFFER && type_ == Type::kTextureMultisampled) {
409 return Type::kTexture;
410 }
411 return type_;
412 }

References kTexture, and kTextureMultisampled.

Referenced by SetAsFramebufferAttachment().

## ◆ CreatePlaceholder()

std::shared_ptr< TextureGLES > impeller::TextureGLES::CreatePlaceholder | ( | std::shared_ptr< ReactorGLES > | reactor,
|  | TextureDescriptor | desc
| ) |  |
| static

Create a "texture" that is never expected to be bound/unbound explicitly or initialized in any way. It only exists to setup a render pass description.

Parameters

  [in] | reactor | The reactor
  [in] | desc | The description

Returns
  If a texture placeholder could be created.

Definition at line 179 of file texture_gles.cc.

181 {
182 return TextureGLES::WrapFBO(std::move(reactor), desc, 0u);
183 }
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:147

References WrapFBO().

Referenced by impeller::SurfaceGLES::WrapFBO().

## ◆ GenerateMipmap()

bool impeller::TextureGLES::GenerateMipmap | ( |  | ) |

Definition at line 560 of file texture_gles.cc.

560 {
561 if (!IsValid()) {
562 return false;
563 }
564
565 auto type = GetTextureDescriptor().type;
566 switch (type) {
567 case TextureType::kTexture2D:
568 break;
569 case TextureType::kTexture2DMultisample:
570 VALIDATION_LOG << "Generating mipmaps for multisample textures is not "
571 "supported in the GLES backend.";
572 return false;
573 case TextureType::kTextureCube:
574 break;
575 case TextureType::kTextureExternalOES:
576 break;
577 }
578
579 if (!Bind()) {
580 return false;
581 }
582
583 auto handle = GetGLHandle();
584 if (!handle.has_value()) {
585 return false;
586 }
587
588 const auto& gl = reactor_->GetProcTable();
589 gl.GenerateMipmap(ToTextureType(type));
590 mipmap_generated_ = true;
591 return true;
592 }
impeller::TextureGLES::Bind
bool Bind() const
Definition: texture_gles.cc:511
impeller::TextureGLES::IsValid
bool IsValid() const override
Definition: texture_gles.cc:238
impeller::Texture::mipmap_generated_
bool mipmap_generated_
Definition: texture.h:79
impeller::ToTextureType
constexpr GLenum ToTextureType(TextureType type)
Definition: formats_gles.h:171
impeller::TextureType::kTextureExternalOES
@ kTextureExternalOES
impeller::TextureType::kTexture2DMultisample
@ kTexture2DMultisample
impeller::TextureType::kTexture2D
@ kTexture2D
impeller::TextureType::kTextureCube
@ kTextureCube
impeller::TextureDescriptor::type
TextureType type
Definition: texture_descriptor.h:40

References Bind(), GetGLHandle(), impeller::Texture::GetTextureDescriptor(), IsValid(), impeller::kTexture2D, impeller::kTexture2DMultisample, impeller::kTextureCube, impeller::kTextureExternalOES, impeller::Texture::mipmap_generated_, impeller::ToTextureType(), impeller::TextureDescriptor::type, type, and VALIDATION_LOG.

## ◆ GetCachedFBO()

const HandleGLES & impeller::TextureGLES::GetCachedFBO | ( |  | ) | const

Retrieve the cached FBO object, or a dead handle if there is no object.

Definition at line 688 of file texture_gles.cc.

688 {
689 return cached_fbo_;
690 }

Referenced by impeller::EncodeCommandsInReactor().

## ◆ GetFBO()

std::optional< GLuint > impeller::TextureGLES::GetFBO | ( |  | ) | const

Definition at line 670 of file texture_gles.cc.

670 {
671 return wrapped_fbo_;
672 }

Referenced by impeller::EncodeCommandsInReactor().

## ◆ GetGLHandle()

std::optional< GLuint > impeller::TextureGLES::GetGLHandle | ( |  | ) | const

Definition at line 504 of file texture_gles.cc.

504 {
505 if (!IsValid()) {
506 return std::nullopt;
507 }
508 return reactor_->GetGLHandle(handle_);
509 }

References IsValid().

Referenced by Bind(), impeller::ConfigureFBO(), impeller::BlitCopyBufferToTextureCommandGLES::Encode(), GenerateMipmap(), impeller::interop::ImpellerTextureGetOpenGLHandle(), and SetAsFramebufferAttachment().

## ◆ GetSyncFence()

std::optional< HandleGLES > impeller::TextureGLES::GetSyncFence | ( |  | ) | const

Definition at line 680 of file texture_gles.cc.

680 {
681 return fence_;
682 }

## ◆ GetType()

TextureGLES::Type impeller::TextureGLES::GetType | ( |  | ) | const

Definition at line 594 of file texture_gles.cc.

594 {
595 return type_;
596 }

Referenced by impeller::BlitCopyBufferToTextureCommandGLES::Encode().

## ◆ IsSliceInitialized()

bool impeller::TextureGLES::IsSliceInitialized | ( | size_t | slice | ) | const

Definition at line 556 of file texture_gles.cc.

556 {
557 return slices_initialized_[slice];
558 }

Referenced by impeller::BlitCopyBufferToTextureCommandGLES::Encode().

## ◆ IsValid()

bool impeller::TextureGLES::IsValid | ( |  | ) | const
| override virtual

Implements impeller::Texture.

Definition at line 238 of file texture_gles.cc.

238 {
239 return is_valid_;
240 }

Referenced by GenerateMipmap(), GetGLHandle(), and SetAsFramebufferAttachment().

## ◆ IsWrapped()

bool impeller::TextureGLES::IsWrapped | ( |  | ) | const

Definition at line 666 of file texture_gles.cc.

666 {
667 return is_wrapped_;
668 }

Referenced by impeller::ConfigureFBO(), impeller::BlitCopyBufferToTextureCommandGLES::Encode(), and impeller::EncodeCommandsInReactor().

## ◆ Leak()

void impeller::TextureGLES::Leak | ( |  | ) |

Reset the internal texture state so that the reactor will not free the associated handle.

Definition at line 233 of file texture_gles.cc.

233 {
234 handle_ = HandleGLES::DeadHandle();
235 }
impeller::HandleGLES::DeadHandle
static HandleGLES DeadHandle()
Creates a dead handle.
Definition: handle_gles.h:44

References impeller::HandleGLES::DeadHandle().

## ◆ MarkContentsInitialized()

void impeller::TextureGLES::MarkContentsInitialized | ( |  | ) |

Indicates that all texture storage has already been allocated and contents initialized.

This is similar to calling `MarkSliceInitialized` with all slices.

See also
  MarkSliceInitialized.

Definition at line 546 of file texture_gles.cc.

546 {
547 for (size_t i = 0; i < slices_initialized_.size(); i++) {
548 slices_initialized_[i] = true;
549 }
550 }

## ◆ MarkSliceInitialized()

void impeller::TextureGLES::MarkSliceInitialized | ( | size_t | slice | ) | const

Indicates that a specific texture slice has been initialized.

Parameters

  [in] | slice | The slice to mark as being initialized.

Definition at line 552 of file texture_gles.cc.

552 {
553 slices_initialized_[slice] = true;
554 }

Referenced by impeller::BlitCopyBufferToTextureCommandGLES::Encode().

## ◆ SetAsFramebufferAttachment()

bool impeller::TextureGLES::SetAsFramebufferAttachment | ( | GLenum | target,
|  | AttachmentType | attachment_type
| ) |  | const

Definition at line 609 of file texture_gles.cc.

611 {
612 if (!IsValid()) {
613 return false;
614 }
615 InitializeContentsIfNecessary();
616 auto handle = GetGLHandle();
617 if (!handle.has_value()) {
618 return false;
619 }
620 const auto& gl = reactor_->GetProcTable();
621
622 switch (ComputeTypeForBinding(target)) {
623 case Type::kTexture:
624 gl.FramebufferTexture2D(target, // target
625 ToAttachmentType(attachment_type), // attachment
626 GL_TEXTURE_2D, // textarget
627 handle.value(), // texture
628 0 // level
629 );
630 break;
631 case Type::kTextureMultisampled:
632 gl.FramebufferTexture2DMultisampleEXT(
633 target, // target
634 ToAttachmentType(attachment_type), // attachment
635 GL_TEXTURE_2D, // textarget
636 handle.value(), // texture
637 0, // level
638 4 // samples
639 );
640 break;
641 case Type::kRenderBuffer:
642 case Type::kRenderBufferMultisampled:
643 gl.FramebufferRenderbuffer(
644 target, // target
645 ToAttachmentType(attachment_type), // attachment
646 GL_RENDERBUFFER, // render-buffer target
647 handle.value() // render-buffer
648 );
649 break;
650 }
651
652 return true;
653 }
impeller::TextureGLES::ComputeTypeForBinding
Type ComputeTypeForBinding(GLenum target) const
Definition: texture_gles.cc:405
impeller::ToAttachmentType
static GLenum ToAttachmentType(TextureGLES::AttachmentType point)
Definition: texture_gles.cc:598

References ComputeTypeForBinding(), GetGLHandle(), IsValid(), kRenderBuffer, kRenderBufferMultisampled, kTexture, kTextureMultisampled, and impeller::ToAttachmentType().

Referenced by impeller::ConfigureFBO(), and impeller::EncodeCommandsInReactor().

## ◆ SetCachedFBO()

void impeller::TextureGLES::SetCachedFBO | ( | HandleGLES | fbo | ) |

Store the FBO object for recycling in the 2D renderer.

The color0 texture used by the 2D renderer will use this texture object to store the associated FBO the first time it is used.

Definition at line 684 of file texture_gles.cc.

684 {
685 cached_fbo_ = fbo;
686 }

Referenced by impeller::EncodeCommandsInReactor().

## ◆ SetFence()

void impeller::TextureGLES::SetFence | ( | HandleGLES | fence | ) |

Attach a sync fence to this texture that will be waited on before encoding a rendering operation that references it.

Parameters

  [in] | fence | A handle to a sync fence.

Definition at line 674 of file texture_gles.cc.

674 {
675 FML_DCHECK(!fence_.has_value());
676 fence_ = fence;
677 }

## ◆ WrapFBO()

std::shared_ptr< TextureGLES > impeller::TextureGLES::WrapFBO | ( | std::shared_ptr< ReactorGLES > | reactor,
|  | TextureDescriptor | desc,
|  | GLuint | fbo
| ) |  |
| static

Create a texture by wrapping an external framebuffer object whose lifecycle is owned by the caller.

This is useful for creating a render target for the default window managed framebuffer.

Parameters

  [in] | reactor | The reactor
  [in] | desc | The description
  [in] | fbo | The fbo

Returns
  If a texture representation of the framebuffer could be created.

Definition at line 147 of file texture_gles.cc.

150 {
151 auto texture = std::shared_ptr<TextureGLES>(
152 new TextureGLES(std::move(reactor), desc, fbo, std::nullopt));
153 if (!texture->IsValid()) {
154 return nullptr;
155 }
156 return texture;
157 }

References TextureGLES().

Referenced by CreatePlaceholder(), and impeller::SurfaceGLES::WrapFBO().

## ◆ WrapTexture()

std::shared_ptr< TextureGLES > impeller::TextureGLES::WrapTexture | ( | std::shared_ptr< ReactorGLES > | reactor,
|  | TextureDescriptor | desc,
|  | HandleGLES | external_handle
| ) |  |
| static

Create a texture by wrapping an external OpenGL texture handle. Ownership of the texture handle is assumed by the reactor.

Parameters

  [in] | reactor | The reactor
  [in] | desc | The description
  [in] | external_handle | The external handle

Returns
  If a texture representation of the framebuffer could be created.

Definition at line 159 of file texture_gles.cc.

162 {
163 if (external_handle.IsDead()) {
164 VALIDATION_LOG << "Cannot wrap a dead handle.";
165 return nullptr;
166 }
167 if (external_handle.GetType() != HandleType::kTexture) {
168 VALIDATION_LOG << "Cannot wrap a non-texture handle.";
169 return nullptr;
170 }
171 auto texture = std::shared_ptr<TextureGLES>(
172 new TextureGLES(std::move(reactor), desc, std::nullopt, external_handle));
173 if (!texture->IsValid()) {
174 return nullptr;
175 }
176 return texture;
177 }

References impeller::HandleGLES::GetType(), impeller::HandleGLES::IsDead(), impeller::kTexture, TextureGLES(), and VALIDATION_LOG.

Referenced by impeller::interop::ImpellerTextureCreateWithOpenGLTextureHandleNew().

The documentation for this class was generated from the following files:

- impeller/renderer/backend/gles/texture_gles.h
- impeller/renderer/backend/gles/texture_gles.cc