texture_gles.cc

Go to the documentation of this file.

// Copyright 2013 The Flutter Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
 
#include "impeller/renderer/backend/gles/texture_gles.h"
 
#include <format>
#include <optional>
#include <utility>
 
#include "flutter/fml/logging.h"
#include "flutter/fml/mapping.h"
#include "flutter/fml/trace_event.h"
#include "impeller/base/allocation.h"
#include "impeller/base/validation.h"
#include "impeller/core/formats.h"
#include "impeller/core/texture_descriptor.h"
#include "impeller/renderer/backend/gles/formats_gles.h"
 
namespace impeller {
 
namespace {
static bool IsDepthStencilFormat(PixelFormat format) {
  switch (format) {
    case PixelFormat::kS8UInt:
    case PixelFormat::kD24UnormS8Uint:
    case PixelFormat::kD32FloatS8UInt:
      return true;
    case PixelFormat::kUnknown:
    case PixelFormat::kA8UNormInt:
    case PixelFormat::kR8UNormInt:
    case PixelFormat::kR8G8UNormInt:
    case PixelFormat::kR8G8B8A8UNormInt:
    case PixelFormat::kR8G8B8A8UNormIntSRGB:
    case PixelFormat::kB8G8R8A8UNormInt:
    case PixelFormat::kB8G8R8A8UNormIntSRGB:
    case PixelFormat::kR32G32B32A32Float:
    case PixelFormat::kR16G16B16A16Float:
    case PixelFormat::kB10G10R10XR:
    case PixelFormat::kB10G10R10XRSRGB:
    case PixelFormat::kB10G10R10A10XR:
    case PixelFormat::kR32Float:
    case PixelFormat::kBC1RGBAUNormInt:
    case PixelFormat::kBC1RGBAUNormIntSRGB:
    case PixelFormat::kBC3RGBAUNormInt:
    case PixelFormat::kBC3RGBAUNormIntSRGB:
    case PixelFormat::kBC5RGUNormInt:
    case PixelFormat::kBC7RGBAUNormInt:
    case PixelFormat::kBC7RGBAUNormIntSRGB:
    case PixelFormat::kETC2RGB8UNormInt:
    case PixelFormat::kETC2RGB8UNormIntSRGB:
    case PixelFormat::kETC2RGBA8UNormInt:
    case PixelFormat::kETC2RGBA8UNormIntSRGB:
    case PixelFormat::kASTC4x4LDR:
    case PixelFormat::kASTC4x4LDRSRGB:
    case PixelFormat::kASTC8x8LDR:
    case PixelFormat::kASTC8x8LDRSRGB:
    case PixelFormat::kASTC4x4HDR:
    case PixelFormat::kASTC8x8HDR:
      return false;
  }
  FML_UNREACHABLE();
}
 
static TextureGLES::Type GetTextureTypeFromDescriptor(
    const TextureDescriptor& desc,
    const std::shared_ptr<const CapabilitiesGLES>& capabilities) {
  const auto usage = static_cast<TextureUsageMask>(desc.usage);
  const auto render_target = TextureUsage::kRenderTarget;
  const auto is_msaa = desc.sample_count == SampleCount::kCount4;
  if (usage == render_target && IsDepthStencilFormat(desc.format)) {
    return is_msaa ? TextureGLES::Type::kRenderBufferMultisampled
                   : TextureGLES::Type::kRenderBuffer;
  }
  return is_msaa ? (capabilities->SupportsImplicitResolvingMSAA()
                        ? TextureGLES::Type::kTextureMultisampled
                        : TextureGLES::Type::kRenderBufferMultisampled)
                 : TextureGLES::Type::kTexture;
}
 
}  // namespace
 
HandleType ToHandleType(TextureGLES::Type type) {
  switch (type) {
    case TextureGLES::Type::kTexture:
    case TextureGLES::Type::kTextureMultisampled:
      return HandleType::kTexture;
    case TextureGLES::Type::kRenderBuffer:
    case TextureGLES::Type::kRenderBufferMultisampled:
      return HandleType::kRenderBuffer;
  }
  FML_UNREACHABLE();
}
 
std::shared_ptr<TextureGLES> TextureGLES::WrapFBO(
    std::shared_ptr<ReactorGLES> reactor,
    TextureDescriptor desc,
    GLuint fbo) {
  auto texture = std::shared_ptr<TextureGLES>(
      new TextureGLES(std::move(reactor), desc, false, fbo, std::nullopt));
  if (!texture->IsValid()) {
    return nullptr;
  }
  return texture;
}
 
std::shared_ptr<TextureGLES> TextureGLES::WrapTexture(
    std::shared_ptr<ReactorGLES> reactor,
    TextureDescriptor desc,
    HandleGLES external_handle) {
  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;
}
 
std::shared_ptr<TextureGLES> TextureGLES::CreatePlaceholder(
    std::shared_ptr<ReactorGLES> reactor,
    TextureDescriptor desc) {
  return TextureGLES::WrapFBO(std::move(reactor), desc, 0u);
}
 
TextureGLES::TextureGLES(std::shared_ptr<ReactorGLES> reactor,
                         TextureDescriptor desc,
                         bool threadsafe)
    : TextureGLES(std::move(reactor),  //
                  desc,                //
                  threadsafe,          //
                  std::nullopt,        //
                  std::nullopt         //
      ) {}
 
TextureGLES::TextureGLES(std::shared_ptr<ReactorGLES> reactor,
                         TextureDescriptor desc,
                         bool threadsafe,
                         std::optional<GLuint> fbo,
                         std::optional<HandleGLES> external_handle)
    : Texture(desc),
      reactor_(std::move(reactor)),
      type_(GetTextureTypeFromDescriptor(
          GetTextureDescriptor(),
          reactor_->GetProcTable().GetCapabilities())),
      handle_(
          external_handle.has_value()
              ? UniqueHandleGLES(reactor_, external_handle.value())
              : (threadsafe
                     ? UniqueHandleGLES(reactor_, ToHandleType(type_))
                     : UniqueHandleGLES::MakeUntracked(reactor_,
                                                       ToHandleType(type_)))),
      is_wrapped_(fbo.has_value() || external_handle.has_value()),
      wrapped_fbo_(fbo) {
  // Ensure the texture descriptor itself is valid.
  if (!GetTextureDescriptor().IsValid()) {
    return;
  }
  // Ensure the texture doesn't exceed device capabilities.
  const auto tex_size = GetTextureDescriptor().size;
  const auto max_size =
      reactor_->GetProcTable().GetCapabilities()->max_texture_size;
  if (tex_size.Max(max_size) != max_size) {
    VALIDATION_LOG << "Texture of size " << tex_size
                   << " would exceed max supported size of " << max_size << ".";
    return;
  }
 
  is_valid_ = true;
}
 
void TextureGLES::Leak() {
  handle_.Release();
}
 
// |Texture|
bool TextureGLES::IsValid() const {
  return is_valid_;
}
 
// |Texture|
void TextureGLES::SetLabel(std::string_view label) {
#ifdef IMPELLER_DEBUG
  reactor_->SetDebugLabel(handle_.Get(), label);
#endif  // IMPELLER_DEBUG
}
 
// |Texture|
void TextureGLES::SetLabel(std::string_view label, std::string_view trailing) {
#ifdef IMPELLER_DEBUG
  if (reactor_->CanSetDebugLabels()) {
    reactor_->SetDebugLabel(handle_.Get(),
                            std::format("{} {}", label, trailing));
  }
#endif  // IMPELLER_DEBUG
}
 
// |Texture|
bool TextureGLES::OnSetContents(const uint8_t* contents,
                                size_t length,
                                size_t slice) {
  return OnSetContents(CreateMappingWithCopy(contents, Bytes{length}), slice);
}
 
// |Texture|
bool TextureGLES::OnSetContents(std::shared_ptr<const fml::Mapping> mapping,
                                size_t slice) {
  if (!mapping) {
    return false;
  }
 
  if (mapping->GetSize() == 0u) {
    return true;
  }
 
  if (mapping->GetMapping() == nullptr) {
    return false;
  }
 
  if (GetType() != Type::kTexture) {
    VALIDATION_LOG << "Incorrect texture usage flags for setting contents on "
                      "this texture object.";
    return false;
  }
 
  if (is_wrapped_) {
    VALIDATION_LOG << "Cannot set the contents of a wrapped texture.";
    return false;
  }
 
  const auto& tex_descriptor = GetTextureDescriptor();
 
  if (tex_descriptor.size.IsEmpty()) {
    return true;
  }
 
  if (!tex_descriptor.IsValid() ||
      mapping->GetSize() < tex_descriptor.GetByteSizeOfBaseMipLevel()) {
    return false;
  }
 
  GLenum texture_type;
  GLenum texture_target;
  switch (tex_descriptor.type) {
    case TextureType::kTexture2D:
      texture_type = GL_TEXTURE_2D;
      texture_target = GL_TEXTURE_2D;
      break;
    case TextureType::kTexture2DMultisample:
      VALIDATION_LOG << "Multisample texture uploading is not supported for "
                        "the OpenGLES backend.";
      return false;
    case TextureType::kTextureCube:
      texture_type = GL_TEXTURE_CUBE_MAP;
      texture_target = GL_TEXTURE_CUBE_MAP_POSITIVE_X + slice;
      break;
    case TextureType::kTextureExternalOES:
      texture_type = GL_TEXTURE_EXTERNAL_OES;
      texture_target = GL_TEXTURE_EXTERNAL_OES;
      break;
  }
 
  std::optional<PixelFormatGLES> gles_format =
      ToPixelFormatGLES(tex_descriptor.format,
                        /*supports_bgra=*/
                        reactor_->GetProcTable().GetDescription()->HasExtension(
                            "GL_EXT_texture_format_BGRA8888"));
  if (!gles_format.has_value()) {
    VALIDATION_LOG << "Invalid texture format.";
    return false;
  }
 
  ReactorGLES::Operation texture_upload =
      [handle = handle_.Get(),                                   //
       mapping,                                                  //
       format = gles_format.value(),                             //
       size = tex_descriptor.size,                               //
       image_size = tex_descriptor.GetByteSizeOfBaseMipLevel(),  //
       texture_type,                                             //
       texture_target                                            //
  ](const auto& reactor) {
        auto gl_handle = reactor.GetGLHandle(handle);
        if (!gl_handle.has_value()) {
          VALIDATION_LOG << "Texture was collected before it could be uploaded "
                            "to the GPU.";
          return;
        }
        const auto& gl = reactor.GetProcTable();
        gl.BindTexture(texture_type, gl_handle.value());
        const GLvoid* tex_data = nullptr;
        if (mapping) {
          tex_data = mapping->GetMapping();
        }
 
        {
          TRACE_EVENT1("impeller", "TexImage2DUpload", "Bytes",
                       std::to_string(mapping->GetSize()).c_str());
          gl.PixelStorei(GL_UNPACK_ALIGNMENT, 1);
          if (format.is_compressed) {
            gl.CompressedTexImage2D(texture_target,          // target
                                    0u,                      // LOD level
                                    format.internal_format,  // internal format
                                    size.width,              // width
                                    size.height,             // height
                                    0u,                      // border
                                    image_size,              // image size
                                    tex_data);               // data
          } else {
            gl.TexImage2D(texture_target,          // target
                          0u,                      // LOD level
                          format.internal_format,  // internal format
                          size.width,              // width
                          size.height,             // height
                          0u,                      // border
                          format.external_format,  // format
                          format.type,             // type
                          tex_data);               // data
          }
        }
      };
 
  const bool added = reactor_->AddOperation(texture_upload);
  if (added) {
    MarkSliceMipLevelInitialized(slice, 0);
  }
  return added;
}
 
// |Texture|
ISize TextureGLES::GetSize() const {
  return GetTextureDescriptor().size;
}
 
static std::optional<GLenum> ToRenderBufferFormat(PixelFormat format) {
  switch (format) {
    case PixelFormat::kB8G8R8A8UNormInt:
    case PixelFormat::kR8G8B8A8UNormInt:
      return GL_RGBA8;
    case PixelFormat::kR32G32B32A32Float:
      return GL_RGBA32F;
    case PixelFormat::kR16G16B16A16Float:
      return GL_RGBA16F;
    case PixelFormat::kS8UInt:
      return GL_STENCIL_INDEX8;
    case PixelFormat::kD24UnormS8Uint:
      return GL_DEPTH24_STENCIL8;
    case PixelFormat::kD32FloatS8UInt:
      return GL_DEPTH32F_STENCIL8;
    case PixelFormat::kUnknown:
    case PixelFormat::kA8UNormInt:
    case PixelFormat::kR8UNormInt:
    case PixelFormat::kR8G8UNormInt:
    case PixelFormat::kR8G8B8A8UNormIntSRGB:
    case PixelFormat::kB8G8R8A8UNormIntSRGB:
    case PixelFormat::kB10G10R10XRSRGB:
    case PixelFormat::kB10G10R10XR:
    case PixelFormat::kB10G10R10A10XR:
    case PixelFormat::kR32Float:
    case PixelFormat::kBC1RGBAUNormInt:
    case PixelFormat::kBC1RGBAUNormIntSRGB:
    case PixelFormat::kBC3RGBAUNormInt:
    case PixelFormat::kBC3RGBAUNormIntSRGB:
    case PixelFormat::kBC5RGUNormInt:
    case PixelFormat::kBC7RGBAUNormInt:
    case PixelFormat::kBC7RGBAUNormIntSRGB:
    case PixelFormat::kETC2RGB8UNormInt:
    case PixelFormat::kETC2RGB8UNormIntSRGB:
    case PixelFormat::kETC2RGBA8UNormInt:
    case PixelFormat::kETC2RGBA8UNormIntSRGB:
    case PixelFormat::kASTC4x4LDR:
    case PixelFormat::kASTC4x4LDRSRGB:
    case PixelFormat::kASTC8x8LDR:
    case PixelFormat::kASTC8x8LDRSRGB:
    case PixelFormat::kASTC4x4HDR:
    case PixelFormat::kASTC8x8HDR:
      return std::nullopt;
  }
  FML_UNREACHABLE();
}
 
TextureGLES::Type TextureGLES::ComputeTypeForBinding(GLenum target) const {
  // 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_;
}
 
void TextureGLES::InitializeContentsIfNecessary() {
  if (!IsValid() || IsSliceMipLevelInitialized(0, 0)) {
    return;
  }
 
  if (is_wrapped_) {
    // Storage is owned externally; mark it covered so we don't re-enter.
    MarkContentsInitialized();
    return;
  }
 
  auto size = GetSize();
 
  if (size.IsEmpty()) {
    MarkContentsInitialized();
    return;
  }
 
  const auto& gl = reactor_->GetProcTable();
  std::optional<GLuint> handle = reactor_->GetGLHandle(handle_.Get());
  if (!handle.has_value()) {
    VALIDATION_LOG << "Could not initialize the contents of texture.";
    return;
  }
 
  switch (type_) {
    case Type::kTexture:
    case Type::kTextureMultisampled: {
      const auto& desc = GetTextureDescriptor();
      std::optional<PixelFormatGLES> gles_format = ToPixelFormatGLES(
          desc.format,
          /*supports_bgra=*/
          reactor_->GetProcTable().GetDescription()->HasExtension(
              "GL_EXT_texture_format_BGRA8888"));
      if (!gles_format.has_value()) {
        VALIDATION_LOG << "Invalid format for texture image.";
        return;
      }
      TRACE_EVENT0("impeller", "TexImage2DInitialization");
      if (desc.type == TextureType::kTextureCube) {
        // Cubemap handles must be bound to GL_TEXTURE_CUBE_MAP and each face
        // target must be defined independently before sampling. Allocate the
        // base mip level for every face here so the cubemap is sample-ready
        // even before any face has been uploaded; non-zero mip levels are
        // still allocated lazily on first per-level write in the blit path.
        gl.BindTexture(GL_TEXTURE_CUBE_MAP, handle.value());
        for (size_t face = 0; face < 6; ++face) {
          gl.TexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X + face,  // target
                        0u,                                     // LOD level
                        gles_format->internal_format,           // internal
                        size.width,                             // width
                        size.height,                            // height
                        0u,                                     // border
                        gles_format->external_format,           // format
                        gles_format->type,                      // type
                        nullptr                                 // data
          );
          MarkSliceMipLevelInitialized(face, 0);
        }
      } else {
        // 2D / multisampled. External-OES textures are always wrapped, so
        // they returned at the is_wrapped_ check above. Only the base mip
        // is allocated here. `glGenerateMipmap` (used by the snapshot
        // pipeline) implicitly allocates and fills the rest, and per-level
        // uploads from the blit path allocate non-zero levels lazily on
        // first write.
        gl.BindTexture(GL_TEXTURE_2D, handle.value());
        gl.TexImage2D(GL_TEXTURE_2D,                 // target
                      0u,                            // LOD level
                      gles_format->internal_format,  // internal
                      size.width,                    // width
                      size.height,                   // height
                      0u,                            // border
                      gles_format->external_format,  // format
                      gles_format->type,             // type
                      nullptr                        // data
        );
        MarkSliceMipLevelInitialized(0, 0);
      }
    } break;
    case Type::kRenderBuffer:
    case Type::kRenderBufferMultisampled: {
      auto render_buffer_format =
          ToRenderBufferFormat(GetTextureDescriptor().format);
      if (!render_buffer_format.has_value()) {
        VALIDATION_LOG << "Invalid format for render-buffer image.";
        return;
      }
      gl.BindRenderbuffer(GL_RENDERBUFFER, handle.value());
      {
        if (type_ == Type::kRenderBufferMultisampled) {
          // BEWARE: these functions are not at all equivalent! the extensions
          // are from EXT_multisampled_render_to_texture and cannot be used
          // with regular GLES 3.0 multisampled renderbuffers/textures.
          if (gl.GetCapabilities()->SupportsImplicitResolvingMSAA()) {
            gl.RenderbufferStorageMultisampleEXT(
                /*target=*/GL_RENDERBUFFER,                        //
                /*samples=*/4,                                     //
                /*internal_format=*/render_buffer_format.value(),  //
                /*width=*/size.width,                              //
                /*height=*/size.height                             //
            );
          } else {
            gl.RenderbufferStorageMultisample(
                /*target=*/GL_RENDERBUFFER,                        //
                /*samples=*/4,                                     //
                /*internal_format=*/render_buffer_format.value(),  //
                /*width=*/size.width,                              //
                /*height=*/size.height                             //
            );
          }
        } else {
          gl.RenderbufferStorage(
              /*target=*/GL_RENDERBUFFER,                        //
              /*internal_format=*/render_buffer_format.value(),  //
              /*width=*/size.width,                              //
              /*height=*/size.height                             //
          );
        }
      }
      // Renderbuffers don't have mip levels, but we still mark slot (0, 0)
      // so the early-out guard at the top of this function fires on subsequent
      // calls.
      MarkSliceMipLevelInitialized(0, 0);
    } break;
  }
}
 
std::optional<GLuint> TextureGLES::GetGLHandle() const {
  if (!IsValid()) {
    return std::nullopt;
  }
  return reactor_->GetGLHandle(handle_.Get());
}
 
bool TextureGLES::Bind() {
  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;
}
 
void TextureGLES::MarkContentsInitialized() {
  for (auto& slice_mips : slice_mip_initialized_) {
    slice_mips.set();
  }
}
 
void TextureGLES::MarkSliceInitialized(size_t slice) {
  MarkSliceMipLevelInitialized(slice, 0);
}
 
bool TextureGLES::IsSliceInitialized(size_t slice) const {
  return IsSliceMipLevelInitialized(slice, 0);
}
 
void TextureGLES::MarkSliceMipLevelInitialized(size_t slice, size_t mip_level) {
  if (slice >= slice_mip_initialized_.size() ||
      mip_level >= kMaxTrackedMipLevels) {
    return;
  }
  slice_mip_initialized_[slice].set(mip_level);
}
 
bool TextureGLES::IsSliceMipLevelInitialized(size_t slice,
                                             size_t mip_level) const {
  if (slice >= slice_mip_initialized_.size() ||
      mip_level >= kMaxTrackedMipLevels) {
    return false;
  }
  return slice_mip_initialized_[slice].test(mip_level);
}
 
bool TextureGLES::GenerateMipmap() {
  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;
}
 
TextureGLES::Type TextureGLES::GetType() const {
  return type_;
}
 
static GLenum ToAttachmentType(TextureGLES::AttachmentType point) {
  switch (point) {
    case TextureGLES::AttachmentType::kColor0:
      return GL_COLOR_ATTACHMENT0;
    case TextureGLES::AttachmentType::kDepth:
      return GL_DEPTH_ATTACHMENT;
    case TextureGLES::AttachmentType::kStencil:
      return GL_STENCIL_ATTACHMENT;
  }
}
 
bool TextureGLES::EnsureSliceMipLevelStorage(size_t slice, size_t mip_level) {
  if (IsSliceMipLevelInitialized(slice, mip_level)) {
    return true;
  }
  // Renderbuffers and multisampled textures only have their single level
  // allocated at init; only sampled 2D and cube textures allocate per-level.
  if (type_ != Type::kTexture) {
    return true;
  }
  auto handle = GetGLHandle();
  if (!handle.has_value()) {
    return false;
  }
  const auto& gl = reactor_->GetProcTable();
  const auto& desc = GetTextureDescriptor();
  std::optional<PixelFormatGLES> gles_format = ToPixelFormatGLES(
      desc.format,
      gl.GetDescription()->HasExtension("GL_EXT_texture_format_BGRA8888"));
  if (!gles_format.has_value()) {
    return false;
  }
  ISize size = GetSize();
  bool is_cube = desc.type == TextureType::kTextureCube;
  GLenum image_target =
      is_cube ? GL_TEXTURE_CUBE_MAP_POSITIVE_X + slice : GL_TEXTURE_2D;
  gl.BindTexture(is_cube ? GL_TEXTURE_CUBE_MAP : GL_TEXTURE_2D, handle.value());
  gl.TexImage2D(image_target,                   // target
                static_cast<GLint>(mip_level),  // LOD level
                gles_format->internal_format,   // internal
                static_cast<GLsizei>(
                    std::max<int64_t>(1, size.width >> mip_level)),  // width
                static_cast<GLsizei>(
                    std::max<int64_t>(1, size.height >> mip_level)),  // height
                0u,                                                   // border
                gles_format->external_format,                         // format
                gles_format->type,                                    // type
                nullptr                                               // data
  );
  MarkSliceMipLevelInitialized(slice, mip_level);
  return true;
}
 
bool TextureGLES::SetAsFramebufferAttachment(GLenum target,
                                             AttachmentType attachment_type,
                                             uint32_t mip_level,
                                             uint32_t slice) {
  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;
}
 
bool TextureGLES::IsWrapped() const {
  return is_wrapped_;
}
 
std::optional<GLuint> TextureGLES::GetFBO() const {
  return wrapped_fbo_;
}
 
void TextureGLES::SetFence(HandleGLES fence) {
  FML_DCHECK(!fence_.IsValid());
  fence_ = UniqueHandleGLES(reactor_, fence);
}
 
// Visible for testing.
std::optional<HandleGLES> TextureGLES::GetSyncFence() const {
  return fence_.IsValid() ? std::optional(fence_.Get()) : std::nullopt;
}
 
void TextureGLES::SetCachedFBO(HandleGLES fbo) {
  cached_fbo_ = UniqueHandleGLES(reactor_, fbo);
}
 
const HandleGLES& TextureGLES::GetCachedFBO() const {
  return cached_fbo_.Get();
}
 
void TextureGLES::SetCachedFBOSubresource(uint32_t mip_level, uint32_t slice) {
  cached_fbo_mip_level_ = mip_level;
  cached_fbo_slice_ = slice;
}
 
bool TextureGLES::CachedFBOMatchesSubresource(uint32_t mip_level,
                                              uint32_t slice) const {
  return cached_fbo_mip_level_ == mip_level && cached_fbo_slice_ == slice;
}
 
}  // namespace impeller