#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 ()

bool	GenerateMipmap ()

bool	SetAsFramebufferAttachment (GLenum target, AttachmentType attachment_type)

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)
	Indicates that a specific texture slice has been initialized.

bool	IsSliceInitialized (size_t slice) const

void	MarkSliceMipLevelInitialized (size_t slice, size_t mip_level)
	Indicates that storage for `mip_level` of `slice` has been allocated by a `glTexImage2D` call (or equivalent).

bool	IsSliceMipLevelInitialized (size_t slice, size_t mip_level) 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 19 of file texture_gles.h.

Member Enumeration Documentation

◆ AttachmentType

enum class impeller::TextureGLES::AttachmentType

strong

Enumerator
kColor0
kDepth
kStencil

Definition at line 95 of file texture_gles.h.

                            {
    kColor0,
    kDepth,
    kStencil,
  };

◆ Type

enum class impeller::TextureGLES::Type

strong

Enumerator
kTexture
kTextureMultisampled
kRenderBuffer
kRenderBufferMultisampled

Definition at line 22 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 116 of file texture_gles.cc.

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

◆ ~TextureGLES()

impeller::TextureGLES::~TextureGLES ( )

override

Definition at line 161 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 ( )

Definition at line 490 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 346 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 110 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 556 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 683 of file texture_gles.cc.

                                                  {
  return cached_fbo_;
}

Referenced by impeller::EncodeCommandsInReactor().

◆ GetFBO()

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

Definition at line 665 of file texture_gles.cc.

                                              {
  return wrapped_fbo_;
}

Referenced by impeller::EncodeCommandsInReactor().

◆ GetGLHandle()

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

Definition at line 483 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 675 of file texture_gles.cc.

                                                        {
  return fence_;
}

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

◆ GetType()

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

Definition at line 590 of file texture_gles.cc.

                                           {
  return type_;
}

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

◆ IsSliceInitialized()

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

Definition at line 535 of file texture_gles.cc.

                                                       {
  return IsSliceMipLevelInitialized(slice, 0);
}

References IsSliceMipLevelInitialized().

◆ IsSliceMipLevelInitialized()

bool impeller::TextureGLES::IsSliceMipLevelInitialized	(	size_t	slice,
		size_t	mip_level
	)		const

Definition at line 547 of file texture_gles.cc.

                                                                     {
  if (slice >= slice_mip_initialized_.size() ||
      mip_level >= kMaxTrackedMipLevels) {
    return false;
  }
  return slice_mip_initialized_[slice].test(mip_level);
}

Referenced by impeller::BlitCopyBufferToTextureCommandGLES::Encode(), and IsSliceInitialized().

◆ IsValid()

bool impeller::TextureGLES::IsValid ( ) const

overridevirtual

Implements impeller::Texture.

Definition at line 173 of file texture_gles.cc.

                                {
  return is_valid_;
}

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

◆ IsWrapped()

bool impeller::TextureGLES::IsWrapped ( ) const

Definition at line 661 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 168 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 525 of file texture_gles.cc.

                                          {
  for (auto& slice_mips : slice_mip_initialized_) {
    slice_mips.set();
  }
}

◆ MarkSliceInitialized()

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

Indicates that a specific texture slice has been initialized.

Parameters

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

Definition at line 531 of file texture_gles.cc.

                                                   {
  MarkSliceMipLevelInitialized(slice, 0);
}

References MarkSliceMipLevelInitialized().

◆ MarkSliceMipLevelInitialized()

void impeller::TextureGLES::MarkSliceMipLevelInitialized	(	size_t	slice,
		size_t	mip_level
	)

Indicates that storage for mip_level of slice has been allocated by a glTexImage2D call (or equivalent).

GLES raises GL_INVALID_OPERATION when glTexSubImage2D targets a level that has not been previously defined, so every per-level upload must check this first and allocate on demand.

Parameters

[in]	slice	The slice (cubemap face for cubemaps, otherwise always 0).
[in]	mip_level	The mip level whose storage was allocated.

Definition at line 539 of file texture_gles.cc.

                                                                             {
  if (slice >= slice_mip_initialized_.size() ||
      mip_level >= kMaxTrackedMipLevels) {
    return;
  }
  slice_mip_initialized_[slice].set(mip_level);
}

Referenced by impeller::BlitCopyBufferToTextureCommandGLES::Encode(), and MarkSliceInitialized().

◆ SetAsFramebufferAttachment()

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

Definition at line 605 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 679 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 669 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 78 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(), 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 90 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 Skwasm::DlWimpImageFromTexture::GetImpellerTexture(), impeller::interop::ImpellerTextureCreateWithOpenGLTextureHandleNew(), and impeller::testing::TEST_P().

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()

◆ IsSliceMipLevelInitialized()

◆ IsValid()

◆ IsWrapped()

◆ Leak()

◆ MarkContentsInitialized()

◆ MarkSliceInitialized()

◆ MarkSliceMipLevelInitialized()

◆ SetAsFramebufferAttachment()

◆ SetCachedFBO()

◆ SetFence()

◆ WrapFBO()

◆ WrapTexture()