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
std::string	ReloadFromAsset (impeller::Context::BackendType backend_type, const std::string &name)

std::string	ReloadFromFlatbuffer (impeller::Context::BackendType backend_type, std::shared_ptr< fml::Mapping > payload)

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

const std::string &	GetLibraryId () 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

◆ GetLibraryId()

const std::string & flutter::gpu::ShaderLibrary::GetLibraryId ( ) const

inline

Definition at line 65 of file shader_library.h.

65{ return library_id_; }

◆ GetShader()

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

Definition at line 406 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 338 of file shader_library.cc.

                          {
  if (payload == nullptr || !payload->GetMapping()) {
    return nullptr;
  }
  if (library_id.empty()) {
    library_id = impeller::ShaderKey::MakeFallbackLibraryId();
  }
  ShaderMap shader_map = ParseShaderBundle(backend_type, payload, library_id);
  if (shader_map.empty()) {
    return nullptr;
  }
  return fml::MakeRefCounted<flutter::gpu::ShaderLibrary>(
      std::move(payload), std::move(shader_map), std::move(library_id));
}

References impeller::ShaderKey::MakeFallbackLibraryId(), and flutter::gpu::ParseShaderBundle().

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

◆ ReloadFromAsset()

std::string flutter::gpu::ShaderLibrary::ReloadFromAsset	(	impeller::Context::BackendType	backend_type,
		const std::string &	name
	)

Re-fetches name from the AssetManager and reparses it into this library, preserving Dart object identity and the library_id so any already-handed-out Shader instances continue to work. Existing Shader entries whose names appear in the new bundle are mutated in place and marked dirty so the next pipeline build evicts and re-registers them. Returns the empty string on success.

Definition at line 356 of file shader_library.cc.

                           {
  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) {
    return "Asset '" + name + "' not found.";
  }
  return ReloadFromFlatbuffer(backend_type, std::move(data));
}

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

Referenced by InternalFlutterGpu_ShaderLibrary_ReinitializeWithAsset().

◆ ReloadFromFlatbuffer()

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

Reparses payload into this library, preserving Dart object identity and the library_id. Returns the empty string on success.

Definition at line 370 of file shader_library.cc.

                                       {
  if (payload == nullptr || !payload->GetMapping()) {
    return "Empty shader bundle payload.";
  }
  ShaderMap new_shaders = ParseShaderBundle(backend_type, payload, library_id_);
  if (new_shaders.empty()) {
    return "Shader bundle could not be parsed.";
  }
 
  // Reuse the existing Shader instance for any name that survives the
  // reload so user-held Dart wrappers stay attached to live data. Names
  // that disappeared in the new bundle drop out of the map; names that
  // are new get added. The eviction of old shader functions happens
  // lazily in `Shader::RegisterSync` when the dirty bit is observed.
  ShaderMap merged;
  for (auto& [name, parsed] : new_shaders) {
    auto it = shaders_.find(name);
    if (it != shaders_.end()) {
      it->second->ResetFrom(*parsed);
      merged[name] = it->second;
    } else {
      merged[name] = std::move(parsed);
    }
  }
  shaders_ = std::move(merged);
  payload_ = std::move(payload);
  return "";
}

References flutter::name, and flutter::gpu::ParseShaderBundle().

Referenced by ReloadFromAsset().

◆ 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 401 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

Public Types

Public Member Functions

Static Public Member Functions

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ ShaderMap

Constructor & Destructor Documentation

◆ ~ShaderLibrary()

Member Function Documentation

◆ GetLibraryId()

◆ GetShader()

◆ MakeFromAsset()

◆ MakeFromFlatbuffer()

◆ MakeFromShaders()

◆ ReloadFromAsset()

◆ ReloadFromFlatbuffer()

◆ SetOverride()