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)
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 314 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;
}

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));
}

MakeFromFlatbuffer()

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

static

Definition at line 177 of file shader_library.cc.

                                       {
  if (payload == nullptr || !payload->GetMapping()) {
    return nullptr;
  }
  if (!impeller::fb::shaderbundle::ShaderBundleBufferHasIdentifier(
          payload->GetMapping())) {
    return nullptr;
  }
  auto* bundle =
      impeller::fb::shaderbundle::GetShaderBundle(payload->GetMapping());
  if (!bundle) {
    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::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()) {
            members.push_back(impeller::ShaderStructMemberMetadata{
                .type = FromUniformType(struct_member->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()),
            });
          }
        }
 
        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()),
        };
      }
    }
 
    std::unordered_map<std::string, impeller::SampledImageSlot>
        uniform_textures;
    if (backend_shader->uniform_textures() != nullptr) {
      for (const auto& uniform : *backend_shader->uniform_textures()) {
        uniform_textures[uniform->name()->str()] = 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()),
        };
      }
    }
 
    std::shared_ptr<impeller::VertexDescriptor> vertex_descriptor = nullptr;
    if (backend_shader->stage() ==
        impeller::fb::shaderbundle::ShaderStage::kVertex) {
      vertex_descriptor = std::make_shared<impeller::VertexDescriptor>();
      auto inputs_fb = backend_shader->inputs();
 
      std::vector<impeller::ShaderStageIOSlot> 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;
      }
      std::vector<impeller::ShaderStageBufferLayout> layouts = {
          impeller::ShaderStageBufferLayout{
              .stride = default_stride,
              .binding = 0u,
          }};
 
      vertex_descriptor->SetStageInputs(inputs, layouts);
    }
 
    auto shader = flutter::gpu::Shader::Make(
        backend_shader->entrypoint()->str(),
        ToShaderStage(backend_shader->stage()), std::move(code_mapping),
        std::move(vertex_descriptor), std::move(uniform_structs),
        std::move(uniform_textures));
    shader_map[bundled_shader->name()->str()] = std::move(shader);
  }
 
  return fml::MakeRefCounted<flutter::gpu::ShaderLibrary>(
      std::move(payload), std::move(shader_map));
}

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 309 of file shader_library.cc.

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

---

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

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