| 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
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 (GLuint fbo)
GLuint | GetCachedFBO () const
| Retrieve the cached FBO object, or GL_NONE 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 181 of file texture_gles.cc.

183 : TextureGLES(std::move(reactor), //
184 desc, //
185 std::nullopt, //
186 std::nullopt //
187 ) {}
impeller::TextureGLES::TextureGLES
TextureGLES(std::shared_ptr< ReactorGLES > reactor, TextureDescriptor desc)
Definition: texture_gles.cc:181

Referenced by WrapFBO(), and WrapTexture().

## ◆ ~TextureGLES()

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

Definition at line 220 of file texture_gles.cc.

220 {
221 reactor_->CollectHandle(handle_);
222 if (cached_fbo_ != GL_NONE) {
223 reactor_->GetProcTable().DeleteFramebuffers(1, &cached_fbo_);
224 }
225 }

## Member Function Documentation

## ◆ Bind()

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

Definition at line 489 of file texture_gles.cc.

489 {
490 auto handle = GetGLHandle();
491 if (!handle.has_value()) {
492 return false;
493 }
494 const auto& gl = reactor_->GetProcTable();
495
496 if (fence_.has_value()) {
497 std::optional<GLsync> fence = reactor_->GetGLFence(fence_.value());
498 if (fence.has_value()) {
499 gl.WaitSync(fence.value(), 0, GL_TIMEOUT_IGNORED);
500 }
501 reactor_->CollectHandle(fence_.value());
502 fence_ = std::nullopt;
503 }
504
505 switch (type_) {
506 case Type::kTexture:
507 case Type::kTextureMultisampled: {
508 const auto target = ToTextureTarget(GetTextureDescriptor().type);
509 if (!target.has_value()) {
510 VALIDATION_LOG << "Could not bind texture of this type.";
511 return false;
512 }
513 gl.BindTexture(target.value(), handle.value());
514 } break;
515 case Type::kRenderBuffer:
516 case Type::kRenderBufferMultisampled:
517 gl.BindRenderbuffer(GL_RENDERBUFFER, handle.value());
518 break;
519 }
520 InitializeContentsIfNecessary();
521 return true;
522 }
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:482
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:63
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 395 of file texture_gles.cc.

395 {
396 // When binding to a GL_READ_FRAMEBUFFER, any multisampled
397 // textures must be bound as single sampled.
398 if (target == GL_READ_FRAMEBUFFER && type_ == Type::kTextureMultisampled) {
399 return Type::kTexture;
400 }
401 return type_;
402 }

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 175 of file texture_gles.cc.

177 {
178 return TextureGLES::WrapFBO(std::move(reactor), desc, 0u);
179 }
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:143

References WrapFBO().

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

## ◆ GenerateMipmap()

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

Definition at line 538 of file texture_gles.cc.

538 {
539 if (!IsValid()) {
540 return false;
541 }
542
543 auto type = GetTextureDescriptor().type;
544 switch (type) {
545 case TextureType::kTexture2D:
546 break;
547 case TextureType::kTexture2DMultisample:
548 VALIDATION_LOG << "Generating mipmaps for multisample textures is not "
549 "supported in the GLES backend.";
550 return false;
551 case TextureType::kTextureCube:
552 break;
553 case TextureType::kTextureExternalOES:
554 break;
555 }
556
557 if (!Bind()) {
558 return false;
559 }
560
561 auto handle = GetGLHandle();
562 if (!handle.has_value()) {
563 return false;
564 }
565
566 const auto& gl = reactor_->GetProcTable();
567 gl.GenerateMipmap(ToTextureType(type));
568 mipmap_generated_ = true;
569 return true;
570 }
impeller::TextureGLES::Bind
bool Bind() const
Definition: texture_gles.cc:489
impeller::TextureGLES::IsValid
bool IsValid() const override
Definition: texture_gles.cc:228
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()

GLuint impeller::TextureGLES::GetCachedFBO | ( |  | ) | const

Retrieve the cached FBO object, or GL_NONE if there is no object.

Definition at line 666 of file texture_gles.cc.

666 {
667 return cached_fbo_;
668 }

Referenced by impeller::EncodeCommandsInReactor().

## ◆ GetFBO()

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

Definition at line 648 of file texture_gles.cc.

648 {
649 return wrapped_fbo_;
650 }

Referenced by impeller::EncodeCommandsInReactor().

## ◆ GetGLHandle()

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

Definition at line 482 of file texture_gles.cc.

482 {
483 if (!IsValid()) {
484 return std::nullopt;
485 }
486 return reactor_->GetGLHandle(handle_);
487 }

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 658 of file texture_gles.cc.

658 {
659 return fence_;
660 }

## ◆ GetType()

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

Definition at line 572 of file texture_gles.cc.

572 {
573 return type_;
574 }

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

## ◆ IsSliceInitialized()

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

Definition at line 534 of file texture_gles.cc.

534 {
535 return slices_initialized_[slice];
536 }

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

## ◆ IsValid()

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

Implements impeller::Texture.

Definition at line 228 of file texture_gles.cc.

228 {
229 return is_valid_;
230 }

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

## ◆ IsWrapped()

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

Definition at line 644 of file texture_gles.cc.

644 {
645 return is_wrapped_;
646 }

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

## ◆ 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 524 of file texture_gles.cc.

524 {
525 for (size_t i = 0; i < slices_initialized_.size(); i++) {
526 slices_initialized_[i] = true;
527 }
528 }

## ◆ 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 530 of file texture_gles.cc.

530 {
531 slices_initialized_[slice] = true;
532 }

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

## ◆ SetAsFramebufferAttachment()

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

Definition at line 587 of file texture_gles.cc.

589 {
590 if (!IsValid()) {
591 return false;
592 }
593 InitializeContentsIfNecessary();
594 auto handle = GetGLHandle();
595 if (!handle.has_value()) {
596 return false;
597 }
598 const auto& gl = reactor_->GetProcTable();
599
600 switch (ComputeTypeForBinding(target)) {
601 case Type::kTexture:
602 gl.FramebufferTexture2D(target, // target
603 ToAttachmentType(attachment_type), // attachment
604 GL_TEXTURE_2D, // textarget
605 handle.value(), // texture
606 0 // level
607 );
608 break;
609 case Type::kTextureMultisampled:
610 gl.FramebufferTexture2DMultisampleEXT(
611 target, // target
612 ToAttachmentType(attachment_type), // attachment
613 GL_TEXTURE_2D, // textarget
614 handle.value(), // texture
615 0, // level
616 4 // samples
617 );
618 break;
619 case Type::kRenderBuffer:
620 case Type::kRenderBufferMultisampled:
621 gl.FramebufferRenderbuffer(
622 target, // target
623 ToAttachmentType(attachment_type), // attachment
624 GL_RENDERBUFFER, // render-buffer target
625 handle.value() // render-buffer
626 );
627 break;
628 }
629
630 return true;
631 }
impeller::TextureGLES::ComputeTypeForBinding
Type ComputeTypeForBinding(GLenum target) const
Definition: texture_gles.cc:395
impeller::ToAttachmentType
static GLenum ToAttachmentType(TextureGLES::AttachmentType point)
Definition: texture_gles.cc:576

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

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

## ◆ SetCachedFBO()

void impeller::TextureGLES::SetCachedFBO | ( | GLuint | 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 662 of file texture_gles.cc.

662 {
663 cached_fbo_ = fbo;
664 }

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 652 of file texture_gles.cc.

652 {
653 FML_DCHECK(!fence_.has_value());
654 fence_ = fence;
655 }

## ◆ 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 143 of file texture_gles.cc.

146 {
147 auto texture = std::shared_ptr<TextureGLES>(
148 new TextureGLES(std::move(reactor), desc, fbo, std::nullopt));
149 if (!texture->IsValid()) {
150 return nullptr;
151 }
152 return texture;
153 }

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 155 of file texture_gles.cc.

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

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