flutter::gpu::ShaderLibrary Class Reference

An immutable collection of shaders loaded from a shader bundle asset. More...

#include <shader_library.h>

Inheritance diagram for flutter::gpu::ShaderLibrary:

Public Types
using	ShaderMap = std::unordered_map< std::string, fml::RefPtr< Shader > >
Public Types inherited from tonic::DartWrappable
enum	DartNativeFields {   kPeerIndex ,   kNumberOfNativeFields }

Public Member Functions
fml::RefPtr< Shader >	GetShader (const std::string &shader_name, Dart_Handle shader_wrapper) const
	~ShaderLibrary () override
Public Member Functions inherited from flutter::RefCountedDartWrappable< ShaderLibrary >
virtual void	RetainDartWrappableReference () const override
virtual void	ReleaseDartWrappableReference () const override
Public Member Functions inherited from fml::RefCountedThreadSafe< T >
void	Release () const
Public Member Functions inherited from fml::internal::RefCountedThreadSafeBase
void	AddRef () const
bool	HasOneRef () const
void	AssertHasOneRef () const
Public Member Functions inherited from tonic::DartWrappable
	DartWrappable ()
virtual const DartWrapperInfo &	GetDartWrapperInfo () const =0
Dart_Handle	CreateDartWrapper (DartState *dart_state)
void	AssociateWithDartWrapper (Dart_Handle wrappable)
void	ClearDartWrapper ()
Dart_WeakPersistentHandle	dart_wrapper () const

Static Public Member Functions
static fml::RefPtr< ShaderLibrary >	MakeFromAsset (impeller::Context::BackendType backend_type, const std::string &name, std::string &out_error)
static fml::RefPtr< ShaderLibrary >	MakeFromShaders (ShaderMap shaders)
static fml::RefPtr< ShaderLibrary >	MakeFromFlatbuffer (impeller::Context::BackendType backend_type, std::shared_ptr< fml::Mapping > payload, std::string library_id="")
static void	SetOverride (fml::RefPtr< ShaderLibrary > override_shader_library)
	Sets a return override for MakeFromAsset for testing purposes.

Additional Inherited Members
Protected Member Functions inherited from fml::RefCountedThreadSafe< T >
	RefCountedThreadSafe ()
	~RefCountedThreadSafe ()
Protected Member Functions inherited from fml::internal::RefCountedThreadSafeBase
	RefCountedThreadSafeBase ()
	~RefCountedThreadSafeBase ()
bool	Release () const
void	Adopt ()
Protected Member Functions inherited from tonic::DartWrappable
virtual	~DartWrappable ()
Static Protected Member Functions inherited from tonic::DartWrappable
static Dart_PersistentHandle	GetTypeForWrapper (tonic::DartState *dart_state, const tonic::DartWrapperInfo &wrapper_info)

Detailed Description

An immutable collection of shaders loaded from a shader bundle asset.

Definition at line 21 of file shader_library.h.

Member Typedef Documentation

ShaderMap

using flutter::gpu::ShaderLibrary::ShaderMap = std::unordered_map<std::string, fml::RefPtr<Shader> >

Definition at line 26 of file shader_library.h.

Constructor & Destructor Documentation

~ShaderLibrary()

flutter::gpu::ShaderLibrary::~ShaderLibrary ( )

overridedefault

Member Function Documentation

GetShader()

fml::RefPtr< Shader > flutter::gpu::ShaderLibrary::GetShader	(	const std::string &	shader_name,
		Dart_Handle	shader_wrapper
	)		const

Definition at line 348 of file shader_library.cc.

                                                                               {
  auto it = shaders_.find(shader_name);
  if (it == shaders_.end()) {
    return nullptr;  // No matching shaders.
  }
  auto shader = it->second;
 
  if (shader->dart_wrapper() == nullptr) {
    shader->AssociateWithDartWrapper(shader_wrapper);
  }
  return shader;
}

Referenced by InternalFlutterGpu_ShaderLibrary_GetShader().

MakeFromAsset()

fml::RefPtr< ShaderLibrary > flutter::gpu::ShaderLibrary::MakeFromAsset ( impeller::Context::BackendType  backend_type, const std::string &  name, std::string &  out_error  )

static

Definition at line 29 of file shader_library.cc.

                          {
  if (override_shader_library_) {
    return override_shader_library_;
  }
 
  auto dart_state = UIDartState::Current();
  std::shared_ptr<AssetManager> asset_manager =
      dart_state->platform_configuration()->client()->GetAssetManager();
 
  std::unique_ptr<fml::Mapping> data = asset_manager->GetAsMapping(name);
  if (data == nullptr) {
    out_error = std::string("Asset '") + name + std::string("' not found.");
    return nullptr;
  }
 
  return MakeFromFlatbuffer(backend_type, std::move(data), name);
}

References flutter::UIDartState::Current(), flutter::data, MakeFromFlatbuffer(), and flutter::name.

Referenced by InternalFlutterGpu_ShaderLibrary_InitializeWithAsset().

MakeFromFlatbuffer()

fml::RefPtr< ShaderLibrary > flutter::gpu::ShaderLibrary::MakeFromFlatbuffer ( impeller::Context::BackendType  backend_type, std::shared_ptr< fml::Mapping >  payload, std::string  library_id = ""  )

static

library_id is a stable identifier (typically the asset path the bundle was loaded from) used to namespace the shaders' entrypoints in the shared shader registry, so they cannot collide with engine-internal shaders or with shaders from a different bundle. If empty, a process-unique fallback is generated.

Definition at line 173 of file shader_library.cc.

                          {
  if (payload == nullptr || !payload->GetMapping()) {
    return nullptr;
  }
  if (library_id.empty()) {
    library_id = impeller::ShaderKey::MakeFallbackLibraryId();
  }
  if (!impeller::fb::shaderbundle::ShaderBundleBufferHasIdentifier(
          payload->GetMapping())) {
    return nullptr;
  }
  auto* bundle =
      impeller::fb::shaderbundle::GetShaderBundle(payload->GetMapping());
  if (!bundle) {
    return nullptr;
  }
 
  const auto version = bundle->format_version();
  const auto expected = static_cast<uint32_t>(
      impeller::fb::shaderbundle::ShaderBundleFormatVersion::kVersion);
  if (version != expected) {
    VALIDATION_LOG << "Unsupported shader bundle format version: " << version
                   << ", expected: " << expected
                   << ". This shader bundle was compiled with an incompatible "
                      "version of impellerc. Please rebuild the shader bundle "
                      "with the version of impellerc that ships with the "
                      "current Flutter SDK.";
    return nullptr;
  }
 
  ShaderLibrary::ShaderMap shader_map;
 
  for (const auto* bundled_shader : *bundle->shaders()) {
    const impeller::fb::shaderbundle::BackendShader* backend_shader =
        GetShaderBackend(backend_type, bundled_shader);
    if (!backend_shader) {
      VALIDATION_LOG << "Failed to unpack shader \""
                     << bundled_shader->name()->c_str() << "\" from bundle.";
      continue;
    }
 
    auto code_mapping = std::make_shared<fml::NonOwnedMapping>(
        backend_shader->shader()->data(),   //
        backend_shader->shader()->size(),   //
        [payload = payload](auto, auto) {}  //
    );
 
    std::vector<impeller::DescriptorSetLayout> descriptor_set_layouts;
 
    std::unordered_map<std::string, Shader::UniformBinding> uniform_structs;
    if (backend_shader->uniform_structs() != nullptr) {
      for (const auto& uniform : *backend_shader->uniform_structs()) {
        std::vector<impeller::ShaderStructMemberMetadata> members;
        if (uniform->fields() != nullptr) {
          for (const auto& struct_member : *uniform->fields()) {
            const impeller::ShaderType type =
                FromUniformType(struct_member->type());
            members.push_back(impeller::ShaderStructMemberMetadata{
                .type = type,
                .name = struct_member->name()->c_str(),
                .offset = static_cast<size_t>(struct_member->offset_in_bytes()),
                .size =
                    static_cast<size_t>(struct_member->element_size_in_bytes()),
                .byte_length =
                    static_cast<size_t>(struct_member->total_size_in_bytes()),
                .array_elements =
                    struct_member->array_elements() == 0
                        ? std::optional<size_t>(std::nullopt)
                        : static_cast<size_t>(struct_member->array_elements()),
                .float_type = impeller::DeriveShaderFloatType(
                    type, static_cast<size_t>(struct_member->vec_size()),
                    static_cast<size_t>(struct_member->columns())),
            });
          }
        }
 
        uniform_structs[uniform->name()->str()] = Shader::UniformBinding{
            .slot =
                impeller::ShaderUniformSlot{
                    .name = uniform->name()->c_str(),
                    .ext_res_0 = static_cast<size_t>(uniform->ext_res_0()),
                    .set = static_cast<size_t>(uniform->set()),
                    .binding = static_cast<size_t>(uniform->binding()),
                },
            .metadata =
                impeller::ShaderMetadata{
                    .name = uniform->name()->c_str(),
                    .members = members,
                },
            .size_in_bytes = static_cast<size_t>(uniform->size_in_bytes()),
        };
 
        descriptor_set_layouts.push_back(impeller::DescriptorSetLayout{
            static_cast<uint32_t>(uniform->binding()),
            impeller::DescriptorType::kUniformBuffer,
            ToShaderStage(backend_shader->stage()),
        });
      }
    }
 
    std::unordered_map<std::string, Shader::TextureBinding> uniform_textures;
    if (backend_shader->uniform_textures() != nullptr) {
      for (const auto& uniform : *backend_shader->uniform_textures()) {
        Shader::TextureBinding texture_binding;
        texture_binding.slot = impeller::SampledImageSlot{
            .name = uniform->name()->c_str(),
            .texture_index = static_cast<size_t>(uniform->ext_res_0()),
            .set = static_cast<size_t>(uniform->set()),
            .binding = static_cast<size_t>(uniform->binding()),
        };
        texture_binding.metadata = impeller::ShaderMetadata{
            .name = uniform->name()->c_str(),
            .members = {},
        };
 
        uniform_textures[uniform->name()->str()] = texture_binding;
 
        descriptor_set_layouts.push_back(impeller::DescriptorSetLayout{
            static_cast<uint32_t>(uniform->binding()),
            impeller::DescriptorType::kSampledImage,
            ToShaderStage(backend_shader->stage()),
        });
      }
    }
 
    std::vector<impeller::ShaderStageIOSlot> inputs;
    std::vector<impeller::ShaderStageBufferLayout> layouts;
    if (backend_shader->stage() ==
        impeller::fb::shaderbundle::ShaderStage::kVertex) {
      auto inputs_fb = backend_shader->inputs();
 
      inputs.reserve(inputs_fb->size());
      size_t default_stride = 0;
      for (const auto& input : *inputs_fb) {
        impeller::ShaderStageIOSlot slot;
        slot.name = input->name()->c_str();
        slot.location = input->location();
        slot.set = input->set();
        slot.binding = input->binding();
        slot.type = FromInputType(input->type());
        slot.bit_width = input->bit_width();
        slot.vec_size = input->vec_size();
        slot.columns = input->columns();
        slot.offset = input->offset();
        inputs.emplace_back(slot);
 
        default_stride +=
            SizeOfInputType(input->type()) * slot.vec_size * slot.columns;
      }
      layouts = {impeller::ShaderStageBufferLayout{
          .stride = default_stride,
          .binding = 0u,
      }};
    }
 
    auto shader = flutter::gpu::Shader::Make(
        library_id, backend_shader->entrypoint()->str(),
        ToShaderStage(backend_shader->stage()), std::move(code_mapping),
        std::move(inputs), std::move(layouts), std::move(uniform_structs),
        std::move(uniform_textures), std::move(descriptor_set_layouts));
    shader_map[bundled_shader->name()->str()] = std::move(shader);
  }
 
  return fml::MakeRefCounted<flutter::gpu::ShaderLibrary>(
      std::move(payload), std::move(shader_map));
}

References impeller::ShaderStageIOSlot::binding, impeller::ShaderStageIOSlot::bit_width, impeller::ShaderStageIOSlot::columns, impeller::DeriveShaderFloatType(), flutter::gpu::FromInputType(), flutter::gpu::FromUniformType(), flutter::gpu::GetShaderBackend(), input(), impeller::kSampledImage, impeller::kUniformBuffer, impeller::ShaderStageIOSlot::location, flutter::gpu::Shader::Make(), impeller::ShaderKey::MakeFallbackLibraryId(), flutter::gpu::Shader::TextureBinding::metadata, impeller::ShaderMetadata::name, impeller::ShaderUniformSlot::name, impeller::SampledImageSlot::name, impeller::ShaderStageIOSlot::name, impeller::ShaderStageIOSlot::offset, impeller::ShaderStageIOSlot::set, flutter::set, flutter::gpu::SizeOfInputType(), flutter::gpu::Shader::UniformBinding::slot, flutter::gpu::Shader::TextureBinding::slot, impeller::ShaderStageBufferLayout::stride, flutter::gpu::ToShaderStage(), impeller::ShaderStructMemberMetadata::type, impeller::ShaderStageIOSlot::type, type, VALIDATION_LOG, and impeller::ShaderStageIOSlot::vec_size.

Referenced by impeller::testing::InstantiateTestShaderLibrary(), and MakeFromAsset().

MakeFromShaders()

fml::RefPtr< ShaderLibrary > flutter::gpu::ShaderLibrary::MakeFromShaders ( ShaderMap  shaders )

static

Definition at line 50 of file shader_library.cc.

                                                                         {
  return fml::MakeRefCounted<flutter::gpu::ShaderLibrary>(nullptr,
                                                          std::move(shaders));
}

SetOverride()

void flutter::gpu::ShaderLibrary::SetOverride ( fml::RefPtr< ShaderLibrary >  override_shader_library )

static

Sets a return override for MakeFromAsset for testing purposes.

Definition at line 343 of file shader_library.cc.

                                                      {
  override_shader_library_ = std::move(override_shader_library);
}

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

---

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

• lib/gpu/shader_library.h
• lib/gpu/shader_library.cc