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

#include <shader.h>

Inheritance diagram for flutter::gpu::Shader:

Classes
struct	TextureBinding

struct	UniformBinding

Public Member Functions
	~Shader () override

std::shared_ptr< const impeller::ShaderFunction >	GetFunctionFromLibrary (impeller::ShaderLibrary &library)

bool	IsRegistered (Context &context)

bool	RegisterSync (Context &context)

bool	IsDirty () const

void	SetClean ()

void	ResetFrom (Shader &other)

std::shared_ptr< impeller::VertexDescriptor >	CreateVertexDescriptor () const

const std::vector< impeller::ShaderStageIOSlot > &	GetStageInputs () const

const std::vector< impeller::ShaderStageBufferLayout > &	GetStageBufferLayouts () const

const std::vector< impeller::DescriptorSetLayout > &	GetDescriptorSetLayouts () const

impeller::ShaderStage	GetShaderStage () const

const Shader::UniformBinding *	GetUniformStruct (const std::string &name) const

const Shader::TextureBinding *	GetUniformTexture (const std::string &name) const

Public Member Functions inherited from flutter::RefCountedDartWrappable< Shader >
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< Shader >	Make (std::string library_id, std::string entrypoint, impeller::ShaderStage stage, std::shared_ptr< fml::Mapping > code_mapping, std::vector< impeller::ShaderStageIOSlot > inputs, std::vector< impeller::ShaderStageBufferLayout > layouts, std::unordered_map< std::string, UniformBinding > uniform_structs, std::unordered_map< std::string, TextureBinding > uniform_textures, std::vector< impeller::DescriptorSetLayout > descriptor_set_layouts)

Additional Inherited Members
Public Types inherited from tonic::DartWrappable
enum	DartNativeFields { kPeerIndex , kNumberOfNativeFields }

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 23 of file shader.h.

Constructor & Destructor Documentation

◆ ~Shader()

flutter::gpu::Shader::~Shader ( )

overridedefault

Member Function Documentation

◆ CreateVertexDescriptor()

std::shared_ptr< impeller::VertexDescriptor > flutter::gpu::Shader::CreateVertexDescriptor ( ) const

Definition at line 151 of file shader.cc.

          {
  auto vertex_descriptor = std::make_shared<impeller::VertexDescriptor>();
  vertex_descriptor->SetStageInputs(inputs_, layouts_);
  return vertex_descriptor;
}

Referenced by InternalFlutterGpu_RenderPipeline_Initialize().

◆ GetDescriptorSetLayouts()

const std::vector< impeller::DescriptorSetLayout > & flutter::gpu::Shader::GetDescriptorSetLayouts ( ) const

Definition at line 172 of file shader.cc.

                                      {
  return descriptor_set_layouts_;
}

Referenced by flutter::gpu::RenderPipeline::RenderPipeline().

◆ GetFunctionFromLibrary()

std::shared_ptr< const impeller::ShaderFunction > flutter::gpu::Shader::GetFunctionFromLibrary ( impeller::ShaderLibrary & library )

Definition at line 69 of file shader.cc.

                                    {
  return library.GetFunction(GetScopedName(), stage_);
}

References impeller::ShaderLibrary::GetFunction().

Referenced by flutter::gpu::RenderPipeline::BindToPipelineDescriptor(), and IsRegistered().

◆ GetShaderStage()

impeller::ShaderStage flutter::gpu::Shader::GetShaderStage ( ) const

Definition at line 167 of file shader.cc.

                                                 {
  return stage_;
}

Referenced by BindUniform(), and InternalFlutterGpu_RenderPass_BindTexture().

◆ GetStageBufferLayouts()

const std::vector< impeller::ShaderStageBufferLayout > & flutter::gpu::Shader::GetStageBufferLayouts ( ) const

Definition at line 163 of file shader.cc.

                                    {
  return layouts_;
}

◆ GetStageInputs()

const std::vector< impeller::ShaderStageIOSlot > & flutter::gpu::Shader::GetStageInputs ( ) const

Definition at line 158 of file shader.cc.

                                                                         {
  return inputs_;
}

◆ GetUniformStruct()

const Shader::UniformBinding * flutter::gpu::Shader::GetUniformStruct ( const std::string & name ) const

Definition at line 176 of file shader.cc.

                                 {
  auto uniform = uniform_structs_.find(name);
  if (uniform == uniform_structs_.end()) {
    return nullptr;
  }
  return &uniform->second;
}

References flutter::name.

Referenced by BindUniform(), InternalFlutterGpu_Shader_GetUniformMemberOffset(), and InternalFlutterGpu_Shader_GetUniformStructSize().

◆ GetUniformTexture()

const Shader::TextureBinding * flutter::gpu::Shader::GetUniformTexture ( const std::string & name ) const

Definition at line 185 of file shader.cc.

                                 {
  auto uniform = uniform_textures_.find(name);
  if (uniform == uniform_textures_.end()) {
    return nullptr;
  }
  return &uniform->second;
}

References flutter::name.

Referenced by InternalFlutterGpu_RenderPass_BindTexture().

◆ IsDirty()

bool flutter::gpu::Shader::IsDirty ( ) const

Whether this shader needs to be re-registered with the impeller shader library on next use. Fresh shaders start dirty. Set back to false by RegisterSync after registration completes, and back to true by ResetFrom when the underlying asset is reloaded.

Definition at line 79 of file shader.cc.

                           {
  return is_dirty_;
}

Referenced by InternalFlutterGpu_Shader_DebugIsDirty().

◆ IsRegistered()

bool flutter::gpu::Shader::IsRegistered ( Context & context )

Definition at line 74 of file shader.cc.

                                          {
  auto& lib = *context.GetContext().GetShaderLibrary();
  return GetFunctionFromLibrary(lib) != nullptr;
}

References context, and GetFunctionFromLibrary().

◆ Make()

fml::RefPtr< Shader > flutter::gpu::Shader::Make	(	std::string	library_id,
		std::string	entrypoint,
		impeller::ShaderStage	stage,
		std::shared_ptr< fml::Mapping >	code_mapping,
		std::vector< impeller::ShaderStageIOSlot >	inputs,
		std::vector< impeller::ShaderStageBufferLayout >	layouts,
		std::unordered_map< std::string, UniformBinding >	uniform_structs,
		std::unordered_map< std::string, TextureBinding >	uniform_textures,
		std::vector< impeller::DescriptorSetLayout >	descriptor_set_layouts
	)

static

Definition at line 41 of file shader.cc.

                                                                   {
  auto shader = fml::MakeRefCounted<Shader>();
  shader->library_id_ = std::move(library_id);
  shader->entrypoint_ = std::move(entrypoint);
  shader->stage_ = stage;
  shader->code_mapping_ = std::move(code_mapping);
  shader->inputs_ = std::move(inputs);
  shader->layouts_ = std::move(layouts);
  shader->uniform_structs_ = std::move(uniform_structs);
  shader->uniform_textures_ = std::move(uniform_textures);
  shader->descriptor_set_layouts_ = std::move(descriptor_set_layouts);
  return shader;
}

Referenced by flutter::gpu::ParseShaderBundle().

◆ RegisterSync()

bool flutter::gpu::Shader::RegisterSync ( Context & context )

Definition at line 118 of file shader.cc.

                                          {
  auto& lib = *context.GetContext().GetShaderLibrary();
  const std::string scoped_name = GetScopedName();
 
  std::shared_ptr<const impeller::ShaderFunction> existing =
      lib.GetFunction(scoped_name, stage_);
  if (existing && !is_dirty_) {
    return true;  // Already registered and current.
  }
 
  // Dirty path: an earlier asset version still occupies the scoped slot.
  // Evict it (and any pipelines that referenced it) before registering the
  // new code mapping. Mirrors `RuntimeEffectContents::RegisterShader`.
  if (existing && is_dirty_) {
    context.GetContext().GetPipelineLibrary()->RemovePipelinesWithEntryPoint(
        existing);
    lib.UnregisterFunction(scoped_name, stage_);
  }
 
  std::promise<bool> promise;
  auto future = promise.get_future();
  lib.RegisterFunction(
      scoped_name, stage_, code_mapping_,
      fml::MakeCopyable([promise = std::move(promise)](bool result) mutable {
        promise.set_value(result);
      }));
  if (!future.get()) {
    return false;  // Registration failed.
  }
  is_dirty_ = false;
  return true;
}

References context, and fml::MakeCopyable().

Referenced by InternalFlutterGpu_RenderPipeline_Initialize().

◆ ResetFrom()

void flutter::gpu::Shader::ResetFrom ( Shader & other )

Replaces this shader's payload (code, layouts, uniforms) with the data from other, preserving the library_id / entrypoint registry key and marking this shader dirty. Used by ShaderLibrary to reload a shader bundle in place without breaking existing Dart wrappers.

Definition at line 87 of file shader.cc.

                                    {
  // Compare the compiled bytes against the freshly-parsed mapping before
  // moving anything. A shader bundle is the unit of asset distribution, so
  // editing one shader recompiles the whole bundle; without this dedupe
  // every unchanged shader in the bundle would still be evicted and
  // re-registered on reload. Code-byte equality is sufficient because
  // impellerc derives reflection metadata (uniforms, inputs, layouts)
  // deterministically from the compiled output.
  const bool code_changed =
      code_mapping_ == nullptr || other.code_mapping_ == nullptr ||
      code_mapping_->GetSize() != other.code_mapping_->GetSize() ||
      std::memcmp(code_mapping_->GetMapping(),
                  other.code_mapping_->GetMapping(),
                  code_mapping_->GetSize()) != 0;
 
  // library_id_ is intentionally preserved: the scoped registry key
  // (library_id + entrypoint) must remain stable across reloads so the
  // eviction triple-call in `RegisterSync` lands at the same slot.
  entrypoint_ = std::move(other.entrypoint_);
  stage_ = other.stage_;
  code_mapping_ = std::move(other.code_mapping_);
  inputs_ = std::move(other.inputs_);
  layouts_ = std::move(other.layouts_);
  uniform_structs_ = std::move(other.uniform_structs_);
  uniform_textures_ = std::move(other.uniform_textures_);
  descriptor_set_layouts_ = std::move(other.descriptor_set_layouts_);
  if (code_changed) {
    is_dirty_ = true;
  }
}

◆ SetClean()

void flutter::gpu::Shader::SetClean ( )

Definition at line 83 of file shader.cc.

                      {
  is_dirty_ = false;
}

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

lib/gpu/shader.h
lib/gpu/shader.cc

Classes

Public Member Functions

Static Public Member Functions

Additional Inherited Members