| 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, bool threadsafe=false)
| ~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 94 of file texture_gles.h.

94 {
95 kColor0,
96 kDepth,
97 kStencil,
98 };

## ◆ 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,
|  | bool | threadsafe = `false`
| ) |  |

Definition at line 185 of file texture_gles.cc.

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

Referenced by WrapFBO(), and WrapTexture().

## ◆ ~TextureGLES()

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

Definition at line 231 of file texture_gles.cc.

231 {
232 reactor_->CollectHandle(handle_);
233 if (!cached_fbo_.IsDead()) {
234 reactor_->CollectHandle(cached_fbo_);
235 }
236 }
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 515 of file texture_gles.cc.

515 {
516 auto handle = GetGLHandle();
517 if (!handle.has_value()) {
518 return false;
519 }
520 const auto& gl = reactor_->GetProcTable();
521
522 if (fence_.has_value()) {
523 std::optional<GLsync> fence = reactor_->GetGLFence(fence_.value());
524 if (fence.has_value()) {
525 gl.WaitSync(fence.value(), 0, GL_TIMEOUT_IGNORED);
526 }
527 reactor_->CollectHandle(fence_.value());
528 fence_ = std::nullopt;
529 }
530
531 switch (type_) {
532 case Type::kTexture:
533 case Type::kTextureMultisampled: {
534 const auto target = ToTextureTarget(GetTextureDescriptor().type);
535 if (!target.has_value()) {
536 VALIDATION_LOG << "Could not bind texture of this type.";
537 return false;
538 }
539 gl.BindTexture(target.value(), handle.value());
540 } break;
541 case Type::kRenderBuffer:
542 case Type::kRenderBufferMultisampled:
543 gl.BindRenderbuffer(GL_RENDERBUFFER, handle.value());
544 break;
545 }
546 InitializeContentsIfNecessary();
547 return true;
548 }
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:508
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 409 of file texture_gles.cc.

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

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

564 {
565 if (!IsValid()) {
566 return false;
567 }
568
569 auto type = GetTextureDescriptor().type;
570 switch (type) {
571 case TextureType::kTexture2D:
572 break;
573 case TextureType::kTexture2DMultisample:
574 VALIDATION_LOG << "Generating mipmaps for multisample textures is not "
575 "supported in the GLES backend.";
576 return false;
577 case TextureType::kTextureCube:
578 break;
579 case TextureType::kTextureExternalOES:
580 break;
581 }
582
583 if (!Bind()) {
584 return false;
585 }
586
587 auto handle = GetGLHandle();
588 if (!handle.has_value()) {
589 return false;
590 }
591
592 const auto& gl = reactor_->GetProcTable();
593 gl.GenerateMipmap(ToTextureType(type));
594 mipmap_generated_ = true;
595 return true;
596 }
impeller::TextureGLES::Bind
bool Bind() const
Definition: texture_gles.cc:515
impeller::TextureGLES::IsValid
bool IsValid() const override
Definition: texture_gles.cc:243
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 692 of file texture_gles.cc.

692 {
693 return cached_fbo_;
694 }

Referenced by impeller::EncodeCommandsInReactor().

## ◆ GetFBO()

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

Definition at line 674 of file texture_gles.cc.

674 {
675 return wrapped_fbo_;
676 }

Referenced by impeller::EncodeCommandsInReactor().

## ◆ GetGLHandle()

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

Definition at line 508 of file texture_gles.cc.

508 {
509 if (!IsValid()) {
510 return std::nullopt;
511 }
512 return reactor_->GetGLHandle(handle_);
513 }

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

684 {
685 return fence_;
686 }

## ◆ GetType()

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

Definition at line 598 of file texture_gles.cc.

598 {
599 return type_;
600 }

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

## ◆ IsSliceInitialized()

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

Definition at line 560 of file texture_gles.cc.

560 {
561 return slices_initialized_[slice];
562 }

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

## ◆ IsValid()

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

Implements impeller::Texture.

Definition at line 243 of file texture_gles.cc.

243 {
244 return is_valid_;
245 }

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

## ◆ IsWrapped()

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

Definition at line 670 of file texture_gles.cc.

670 {
671 return is_wrapped_;
672 }

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

238 {
239 handle_ = HandleGLES::DeadHandle();
240 }
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 550 of file texture_gles.cc.

550 {
551 for (size_t i = 0; i < slices_initialized_.size(); i++) {
552 slices_initialized_[i] = true;
553 }
554 }

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

556 {
557 slices_initialized_[slice] = true;
558 }

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

## ◆ SetAsFramebufferAttachment()

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

Definition at line 613 of file texture_gles.cc.

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

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

688 {
689 cached_fbo_ = fbo;
690 }

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

678 {
679 FML_DCHECK(!fence_.has_value());
680 fence_ = fence;
681 }

## ◆ 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, false, 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>(new TextureGLES(
172 std::move(reactor), desc, false, 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