#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.

std::optional< GLuint >	GetFBO () const

void	MarkContentsInitialized ()
	Indicates that all texture storage has already been allocated and contents initialized.

void	MarkSliceInitialized (size_t slice) const
	Indicates that a specific texture slice has been initialized.

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.

void	SetCachedFBO (HandleGLES fbo)

const HandleGLES &	GetCachedFBO () const
	Retrieve the cached FBO object, or a dead handle if there is no object.

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.

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.

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.

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 class impeller::TextureGLES::AttachmentType

strong

Enumerator
kColor0
kDepth
kStencil

Definition at line 94 of file texture_gles.h.

                            {
    kColor0,
    kDepth,
    kStencil,
  };

◆ Type

enum class impeller::TextureGLES::Type

strong

Enumerator
kTexture
kTextureMultisampled
kRenderBuffer
kRenderBufferMultisampled

Definition at line 21 of file texture_gles.h.

                  {
    kTexture,
    kTextureMultisampled,
    kRenderBuffer,
    kRenderBufferMultisampled,
  };

Constructor & Destructor Documentation

◆ TextureGLES()

impeller::TextureGLES::TextureGLES	(	std::shared_ptr< ReactorGLES >	reactor,
		TextureDescriptor	desc,
		bool	threadsafe = `false`
	)

Definition at line 191 of file texture_gles.cc.

    : TextureGLES(std::move(reactor),  //
                  desc,                //
                  threadsafe,          //
                  std::nullopt,        //
                  std::nullopt         //
      ) {}

◆ ~TextureGLES()

impeller::TextureGLES::~TextureGLES ( )

override

Definition at line 237 of file texture_gles.cc.

                          {
  reactor_->CollectHandle(handle_);
  if (!cached_fbo_.IsDead()) {
    reactor_->CollectHandle(cached_fbo_);
  }
}

References impeller::HandleGLES::IsDead().

Member Function Documentation

◆ Bind()

bool impeller::TextureGLES::Bind ( ) const

Definition at line 522 of file texture_gles.cc.

                             {
  auto handle = GetGLHandle();
  if (!handle.has_value()) {
    return false;
  }
  const auto& gl = reactor_->GetProcTable();
 
  if (fence_.has_value()) {
    std::optional<GLsync> fence = reactor_->GetGLFence(fence_.value());
    if (fence.has_value()) {
      gl.WaitSync(fence.value(), 0, GL_TIMEOUT_IGNORED);
    }
    reactor_->CollectHandle(fence_.value());
    fence_ = std::nullopt;
  }
 
  switch (type_) {
    case Type::kTexture:
    case Type::kTextureMultisampled: {
      const auto target = ToTextureTarget(GetTextureDescriptor().type);
      if (!target.has_value()) {
        VALIDATION_LOG << "Could not bind texture of this type.";
        return false;
      }
      gl.BindTexture(target.value(), handle.value());
    } break;
    case Type::kRenderBuffer:
    case Type::kRenderBufferMultisampled:
      gl.BindRenderbuffer(GL_RENDERBUFFER, handle.value());
      break;
  }
  InitializeContentsIfNecessary();
  return true;
}

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

Referenced by GenerateMipmap().

◆ ComputeTypeForBinding()

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

Definition at line 416 of file texture_gles.cc.

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

References kTexture, kTextureMultisampled, and target.

Referenced by SetAsFramebufferAttachment(), and impeller::testing::TEST_P().

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

                            {
  return TextureGLES::WrapFBO(std::move(reactor), desc, 0u);
}

References WrapFBO().

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

◆ GenerateMipmap()

bool impeller::TextureGLES::GenerateMipmap ( )

Definition at line 571 of file texture_gles.cc.

                                 {
  if (!IsValid()) {
    return false;
  }
 
  auto type = GetTextureDescriptor().type;
  switch (type) {
    case TextureType::kTexture2D:
      break;
    case TextureType::kTexture2DMultisample:
      VALIDATION_LOG << "Generating mipmaps for multisample textures is not "
                        "supported in the GLES backend.";
      return false;
    case TextureType::kTextureCube:
      break;
    case TextureType::kTextureExternalOES:
      break;
  }
 
  if (!Bind()) {
    return false;
  }
 
  auto handle = GetGLHandle();
  if (!handle.has_value()) {
    return false;
  }
 
  const auto& gl = reactor_->GetProcTable();
  gl.GenerateMipmap(ToTextureType(type));
  mipmap_generated_ = true;
  return true;
}

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

                                                  {
  return cached_fbo_;
}

Referenced by impeller::EncodeCommandsInReactor().

◆ GetFBO()

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

Definition at line 681 of file texture_gles.cc.

                                              {
  return wrapped_fbo_;
}

Referenced by impeller::EncodeCommandsInReactor().

◆ GetGLHandle()

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

Definition at line 515 of file texture_gles.cc.

                                                   {
  if (!IsValid()) {
    return std::nullopt;
  }
  return reactor_->GetGLHandle(handle_);
}

References IsValid().

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

◆ GetSyncFence()

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

Definition at line 691 of file texture_gles.cc.

                                                        {
  return fence_;
}

Referenced by impeller::testing::TEST_P().

◆ GetType()

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

Definition at line 605 of file texture_gles.cc.

                                           {
  return type_;
}

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

◆ IsSliceInitialized()

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

Definition at line 567 of file texture_gles.cc.

                                                       {
  return slices_initialized_[slice];
}

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

◆ IsValid()

bool impeller::TextureGLES::IsValid ( ) const

overridevirtual

Implements impeller::Texture.

Definition at line 249 of file texture_gles.cc.

                                {
  return is_valid_;
}

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

◆ IsWrapped()

bool impeller::TextureGLES::IsWrapped ( ) const

Definition at line 677 of file texture_gles.cc.

                                  {
  return is_wrapped_;
}

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

                       {
  handle_ = HandleGLES::DeadHandle();
}

References impeller::HandleGLES::DeadHandle().

Referenced by impeller::testing::TEST_P().

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

                                          {
  for (size_t i = 0; i < slices_initialized_.size(); i++) {
    slices_initialized_[i] = true;
  }
}

References i.

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

                                                         {
  slices_initialized_[slice] = true;
}

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

◆ SetAsFramebufferAttachment()

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

Definition at line 620 of file texture_gles.cc.

                                          {
  if (!IsValid()) {
    return false;
  }
  InitializeContentsIfNecessary();
  auto handle = GetGLHandle();
  if (!handle.has_value()) {
    return false;
  }
  const auto& gl = reactor_->GetProcTable();
 
  switch (ComputeTypeForBinding(target)) {
    case Type::kTexture:
      gl.FramebufferTexture2D(target,                             // target
                              ToAttachmentType(attachment_type),  // attachment
                              GL_TEXTURE_2D,                      // textarget
                              handle.value(),                     // texture
                              0                                   // level
      );
      break;
    case Type::kTextureMultisampled:
      gl.FramebufferTexture2DMultisampleEXT(
          target,                             // target
          ToAttachmentType(attachment_type),  // attachment
          GL_TEXTURE_2D,                      // textarget
          handle.value(),                     // texture
          0,                                  // level
          4                                   // samples
      );
      break;
    case Type::kRenderBuffer:
    case Type::kRenderBufferMultisampled:
      gl.FramebufferRenderbuffer(
          target,                             // target
          ToAttachmentType(attachment_type),  // attachment
          GL_RENDERBUFFER,                    // render-buffer target
          handle.value()                      // render-buffer
      );
      break;
  }
 
  return true;
}

References ComputeTypeForBinding(), GetGLHandle(), IsValid(), kRenderBuffer, kRenderBufferMultisampled, kTexture, kTextureMultisampled, target, 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 695 of file texture_gles.cc.

                                             {
  cached_fbo_ = fbo;
}

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

                                           {
  FML_DCHECK(!fence_.has_value());
  fence_ = fence;
}

References FML_DCHECK.

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

                {
  auto texture = std::shared_ptr<TextureGLES>(
      new TextureGLES(std::move(reactor), desc, false, fbo, std::nullopt));
  if (!texture->IsValid()) {
    return nullptr;
  }
  return texture;
}

References texture.

Referenced by CreatePlaceholder(), MakeRenderTargetFromBackingStoreImpeller(), impeller::testing::TEST_P(), 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 165 of file texture_gles.cc.

                                {
  if (external_handle.IsDead()) {
    VALIDATION_LOG << "Cannot wrap a dead handle.";
    return nullptr;
  }
  if (external_handle.GetType() != HandleType::kTexture) {
    VALIDATION_LOG << "Cannot wrap a non-texture handle.";
    return nullptr;
  }
  auto texture = std::shared_ptr<TextureGLES>(new TextureGLES(
      std::move(reactor), desc, false, std::nullopt, external_handle));
  if (!texture->IsValid()) {
    return nullptr;
  }
  return texture;
}

References impeller::HandleGLES::GetType(), impeller::HandleGLES::IsDead(), impeller::kTexture, texture, 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

Public Types

Public Member Functions

Static Public Member Functions

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ AttachmentType

◆ Type

Constructor & Destructor Documentation

◆ TextureGLES()

◆ ~TextureGLES()

Member Function Documentation

◆ Bind()

◆ ComputeTypeForBinding()

◆ CreatePlaceholder()

◆ GenerateMipmap()

◆ GetCachedFBO()

◆ GetFBO()

◆ GetGLHandle()

◆ GetSyncFence()

◆ GetType()

◆ IsSliceInitialized()

◆ IsValid()

◆ IsWrapped()

◆ Leak()

◆ MarkContentsInitialized()

◆ MarkSliceInitialized()

◆ SetAsFramebufferAttachment()

◆ SetCachedFBO()

◆ SetFence()

◆ WrapFBO()

◆ WrapTexture()