impeller::BlitCopyBufferToTextureCommandGLES Struct Reference

#include <blit_command_gles.h>

Inheritance diagram for impeller::BlitCopyBufferToTextureCommandGLES:

Public Member Functions
	~BlitCopyBufferToTextureCommandGLES () override
std::string	GetLabel () const override
bool	Encode (const ReactorGLES &reactor) const override
Public Member Functions inherited from impeller::BlitEncodeGLES
virtual	~BlitEncodeGLES ()

Additional Inherited Members
Static Public Member Functions inherited from impeller::BackendCast< BlitEncodeGLES, BlitCommand >
static BlitEncodeGLES &	Cast (BlitCommand &base)
static const BlitEncodeGLES &	Cast (const BlitCommand &base)
static BlitEncodeGLES *	Cast (BlitCommand *base)
static const BlitEncodeGLES *	Cast (const BlitCommand *base)
Public Attributes inherited from impeller::BlitCopyBufferToTextureCommand
BufferView	source
std::shared_ptr< Texture >	destination
IRect	destination_region
uint32_t	mip_level = 0
uint32_t	slice = 0
Public Attributes inherited from impeller::BlitCommand
std::string	label

Detailed Description

Definition at line 23 of file blit_command_gles.h.

Constructor & Destructor Documentation

~BlitCopyBufferToTextureCommandGLES()

impeller::BlitCopyBufferToTextureCommandGLES::~BlitCopyBufferToTextureCommandGLES ( )

overridedefault

Member Function Documentation

Encode()

bool impeller::BlitCopyBufferToTextureCommandGLES::Encode ( const ReactorGLES &  reactor ) const

overridevirtual

Implements impeller::BlitEncodeGLES.

Definition at line 140 of file blit_command_gles.cc.

                                      {
  TextureGLES& texture_gles = TextureGLES::Cast(*destination);
 
  if (texture_gles.GetType() != TextureGLES::Type::kTexture) {
    VALIDATION_LOG << "Incorrect texture usage flags for setting contents on "
                      "this texture object.";
    return false;
  }
 
  if (texture_gles.IsWrapped()) {
    VALIDATION_LOG << "Cannot set the contents of a wrapped texture.";
    return false;
  }
 
  const auto& tex_descriptor = texture_gles.GetTextureDescriptor();
 
  if (tex_descriptor.size.IsEmpty()) {
    return true;
  }
 
  if (!tex_descriptor.IsValid() ||
      source.GetRange().length !=
          BytesForTextureRegion(tex_descriptor.format,
                                destination_region.GetWidth(),
                                destination_region.GetHeight())) {
    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;
  }
 
  auto gl_handle = texture_gles.GetGLHandle();
  if (!gl_handle.has_value()) {
    VALIDATION_LOG
        << "Texture was collected before it could be uploaded to the GPU.";
    return false;
  }
  const auto& gl = reactor.GetProcTable();
  gl.BindTexture(texture_type, gl_handle.value());
  const GLvoid* tex_data =
      source.GetBuffer()->OnGetContents() + source.GetRange().offset;
 
  // Block-compressed textures cannot be allocated empty and then filled with a
  // sub-image; glCompressedTexImage2D redefines the entire mip level. Require
  // the upload to cover the full mip level starting at the origin.
  if (gles_format->is_compressed) {
    const auto mip_width =
        std::max<int32_t>(1, tex_descriptor.size.width >> mip_level);
    const auto mip_height =
        std::max<int32_t>(1, tex_descriptor.size.height >> mip_level);
    if (destination_region.GetX() != 0 || destination_region.GetY() != 0 ||
        destination_region.GetWidth() != mip_width ||
        destination_region.GetHeight() != mip_height) {
      VALIDATION_LOG << "Compressed textures must be uploaded as a full mip "
                        "level starting at the origin.";
      return false;
    }
    gl.PixelStorei(GL_UNPACK_ALIGNMENT, 1);
    gl.CompressedTexImage2D(texture_target,                // target
                            mip_level,                     // LOD level
                            gles_format->internal_format,  // internal format
                            mip_width,                     // width
                            mip_height,                    // height
                            0u,                            // border
                            source.GetRange().length,      // image size
                            tex_data);                     // data
    texture_gles.MarkSliceMipLevelInitialized(slice, mip_level);
    return true;
  }
 
  // GL_INVALID_OPERATION if the requested mip level has not been defined by
  // a previous glTexImage2D operation. Allocate the requested mip lazily on
  // first write, only for the level the upload is actually targeting. The
  // snapshot pipeline (single base-level allocation followed by
  // glGenerateMipmap) keeps its existing GL footprint, and per-level uploads
  // pay only for the levels they touch.
  if (!texture_gles.IsSliceMipLevelInitialized(slice, mip_level)) {
    const auto level_width =
        std::max<int32_t>(1, tex_descriptor.size.width >> mip_level);
    const auto level_height =
        std::max<int32_t>(1, tex_descriptor.size.height >> mip_level);
    gl.TexImage2D(texture_target,                // target
                  mip_level,                     // LOD level
                  gles_format->internal_format,  // internal format
                  level_width,                   // width
                  level_height,                  // height
                  0u,                            // border
                  gles_format->external_format,  // format
                  gles_format->type,             // type
                  nullptr);                      // data
    texture_gles.MarkSliceMipLevelInitialized(slice, mip_level);
  }
 
  {
    gl.PixelStorei(GL_UNPACK_ALIGNMENT, 1);
    gl.TexSubImage2D(texture_target,                  // target
                     mip_level,                       // LOD level
                     destination_region.GetX(),       // xoffset
                     destination_region.GetY(),       // yoffset
                     destination_region.GetWidth(),   // width
                     destination_region.GetHeight(),  // height
                     gles_format->external_format,    // format
                     gles_format->type,               // type
                     tex_data);                       // data
  }
  return true;
}

References impeller::BytesForTextureRegion(), impeller::BackendCast< TextureGLES, Texture >::Cast(), impeller::BlitCopyBufferToTextureCommand::destination, impeller::BlitCopyBufferToTextureCommand::destination_region, impeller::BufferView::GetBuffer(), impeller::TextureGLES::GetGLHandle(), impeller::TRect< T >::GetHeight(), impeller::BufferView::GetRange(), impeller::Texture::GetTextureDescriptor(), impeller::TextureGLES::GetType(), impeller::TRect< T >::GetWidth(), impeller::TRect< T >::GetX(), impeller::TRect< T >::GetY(), impeller::TextureGLES::IsSliceMipLevelInitialized(), impeller::TextureGLES::IsWrapped(), impeller::TextureGLES::kTexture, impeller::kTexture2D, impeller::kTexture2DMultisample, impeller::kTextureCube, impeller::kTextureExternalOES, impeller::Range::length, impeller::TextureGLES::MarkSliceMipLevelInitialized(), impeller::BlitCopyBufferToTextureCommand::mip_level, impeller::Range::offset, impeller::DeviceBuffer::OnGetContents(), reactor, impeller::BlitCopyBufferToTextureCommand::slice, impeller::BlitCopyBufferToTextureCommand::source, impeller::ToPixelFormatGLES(), and VALIDATION_LOG.

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

GetLabel()

std::string impeller::BlitCopyBufferToTextureCommandGLES::GetLabel ( ) const

overridevirtual

Implements impeller::BlitEncodeGLES.

Definition at line 136 of file blit_command_gles.cc.

                                                             {
  return label;
}

References impeller::BlitCommand::label.

---

The documentation for this struct was generated from the following files:

• impeller/renderer/backend/gles/blit_command_gles.h
• impeller/renderer/backend/gles/blit_command_gles.cc