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

bool	IsValid () const override

std::optional< GLuint >	GetGLHandle () const

bool	Bind ()

bool	GenerateMipmap ()

bool	SetAsFramebufferAttachment (GLenum target, AttachmentType attachment_type, uint32_t mip_level=0, uint32_t slice=0)

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.

void	SetCachedFBOSubresource (uint32_t mip_level, uint32_t slice)
	Records the subresource the cached FBO is currently bound to.

bool	CachedFBOMatchesSubresource (uint32_t mip_level, uint32_t slice) const

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

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 20 of file texture_gles.h.

Member Enumeration Documentation

◆ AttachmentType

enum class impeller::TextureGLES::AttachmentType

strong

Enumerator
kColor0
kDepth
kStencil

Definition at line 93 of file texture_gles.h.

                            {
    kColor0,
    kDepth,
    kStencil,
  };

◆ Type

enum class impeller::TextureGLES::Type

strong

Enumerator
kTexture
kTextureMultisampled
kRenderBuffer
kRenderBufferMultisampled

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

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

Member Function Documentation

◆ Bind()

bool impeller::TextureGLES::Bind ( )

Definition at line 532 of file texture_gles.cc.

                       {
  auto handle = GetGLHandle();
  if (!handle.has_value()) {
    return false;
  }
  const auto& gl = reactor_->GetProcTable();
 
  if (fence_.IsValid()) {
    std::optional<GLsync> fence = reactor_->GetGLFence(fence_.Get());
    if (fence.has_value()) {
      gl.WaitSync(fence.value(), 0, GL_TIMEOUT_IGNORED);
    }
    fence_.Reset();
  }
 
  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 impeller::UniqueHandleGLES::Get(), GetGLHandle(), impeller::Texture::GetTextureDescriptor(), impeller::UniqueHandleGLES::IsValid(), kRenderBuffer, kRenderBufferMultisampled, kTexture, kTextureMultisampled, impeller::UniqueHandleGLES::Reset(), target, impeller::ToTextureTarget(), type, and VALIDATION_LOG.

Referenced by GenerateMipmap().

◆ CachedFBOMatchesSubresource()

bool impeller::TextureGLES::CachedFBOMatchesSubresource	(	uint32_t	mip_level,
		uint32_t	slice
	)		const

Whether the cached FBO is currently bound to (mip_level, slice). When false, the FBO must be re-attached before use.

Definition at line 782 of file texture_gles.cc.

                                                                    {
  return cached_fbo_mip_level_ == mip_level && cached_fbo_slice_ == slice;
}

Referenced by impeller::EncodeCommandsInReactor().

◆ ComputeTypeForBinding()

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

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

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

References reactor, and WrapFBO().

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

◆ GenerateMipmap()

bool impeller::TextureGLES::GenerateMipmap ( )

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

                                                  {
  return cached_fbo_.Get();
}

References impeller::UniqueHandleGLES::Get().

Referenced by impeller::EncodeCommandsInReactor().

◆ GetFBO()

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

Definition at line 755 of file texture_gles.cc.

                                              {
  return wrapped_fbo_;
}

Referenced by impeller::EncodeCommandsInReactor().

◆ GetGLHandle()

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

Definition at line 525 of file texture_gles.cc.

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

References impeller::UniqueHandleGLES::Get(), and 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 765 of file texture_gles.cc.

                                                        {
  return fence_.IsValid() ? std::optional(fence_.Get()) : std::nullopt;
}

References impeller::UniqueHandleGLES::Get(), and impeller::UniqueHandleGLES::IsValid().

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

◆ GetType()

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

Definition at line 631 of file texture_gles.cc.

                                           {
  return type_;
}

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

◆ IsSliceInitialized()

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

Definition at line 576 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 588 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 184 of file texture_gles.cc.

                                {
  return is_valid_;
}

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

◆ IsWrapped()

bool impeller::TextureGLES::IsWrapped ( ) const

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

                       {
  handle_.Release();
}

References impeller::UniqueHandleGLES::Release().

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 566 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 572 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 580 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,
		uint32_t	mip_level = `0`,
		uint32_t	slice = `0`
	)

Definition at line 688 of file texture_gles.cc.

                                                             {
  if (!IsValid()) {
    return false;
  }
  InitializeContentsIfNecessary();
  const auto& gl = reactor_->GetProcTable();
  if (mip_level > 0 &&
      !gl.GetCapabilities()->SupportsFramebufferRenderMipmap()) {
    VALIDATION_LOG << "Rendering into a non-zero mip level is not supported on "
                      "the GLES backend.";
    return false;
  }
  if (!EnsureSliceMipLevelStorage(slice, mip_level)) {
    return false;
  }
  auto handle = GetGLHandle();
  if (!handle.has_value()) {
    return false;
  }
  const GLint level = static_cast<GLint>(mip_level);
 
  switch (ComputeTypeForBinding(target)) {
    case Type::kTexture: {
      // Cube maps attach a specific face; 2D textures attach the 2D target.
      GLenum textarget =
          GetTextureDescriptor().type == TextureType::kTextureCube
              ? GL_TEXTURE_CUBE_MAP_POSITIVE_X + slice
              : GL_TEXTURE_2D;
      gl.FramebufferTexture2D(target,                             // target
                              ToAttachmentType(attachment_type),  // attachment
                              textarget,                          // textarget
                              handle.value(),                     // texture
                              level                               // level
      );
      break;
    }
    case Type::kTextureMultisampled:
      gl.FramebufferTexture2DMultisampleEXT(
          target,                             // target
          ToAttachmentType(attachment_type),  // attachment
          GL_TEXTURE_2D,                      // textarget
          handle.value(),                     // texture
          level,                              // 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(), impeller::Texture::GetTextureDescriptor(), IsValid(), kRenderBuffer, kRenderBufferMultisampled, kTexture, impeller::kTextureCube, kTextureMultisampled, target, impeller::ToAttachmentType(), impeller::TextureDescriptor::type, and VALIDATION_LOG.

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

                                             {
  cached_fbo_ = UniqueHandleGLES(reactor_, fbo);
}

Referenced by impeller::EncodeCommandsInReactor().

◆ SetCachedFBOSubresource()

void impeller::TextureGLES::SetCachedFBOSubresource	(	uint32_t	mip_level,
		uint32_t	slice
	)

Records the subresource the cached FBO is currently bound to.

Definition at line 777 of file texture_gles.cc.

                                                                            {
  cached_fbo_mip_level_ = mip_level;
  cached_fbo_slice_ = slice;
}

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

                                           {
  FML_DCHECK(!fence_.IsValid());
  fence_ = UniqueHandleGLES(reactor_, fence);
}

References FML_DCHECK, and impeller::UniqueHandleGLES::IsValid().

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

◆ 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 95 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 reactor, and 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 107 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, reactor, 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()

Member Function Documentation

◆ Bind()

◆ CachedFBOMatchesSubresource()

◆ ComputeTypeForBinding()

◆ CreatePlaceholder()

◆ GenerateMipmap()

◆ GetCachedFBO()

◆ GetFBO()

◆ GetGLHandle()

◆ GetSyncFence()

◆ GetType()

◆ IsSliceInitialized()

◆ IsSliceMipLevelInitialized()

◆ IsValid()

◆ IsWrapped()

◆ Leak()

◆ MarkContentsInitialized()

◆ MarkSliceInitialized()

◆ MarkSliceMipLevelInitialized()

◆ SetAsFramebufferAttachment()

◆ SetCachedFBO()

◆ SetCachedFBOSubresource()

◆ SetFence()

◆ WrapFBO()

◆ WrapTexture()