flutter::FragmentProgram Class Reference

#include <fragment_program.h>

Inheritance diagram for flutter::FragmentProgram:

Public Member Functions
	~FragmentProgram () override
std::string	initFromAsset (const std::string &asset_name)
fml::RefPtr< FragmentShader >	shader (Dart_Handle shader, Dart_Handle uniforms_handle, Dart_Handle samplers)
std::shared_ptr< DlColorSource >	MakeDlColorSource (std::shared_ptr< std::vector< uint8_t > > float_uniforms, const std::vector< std::shared_ptr< DlColorSource > > &children)
std::shared_ptr< DlImageFilter >	MakeDlImageFilter (std::shared_ptr< std::vector< uint8_t > > float_uniforms, const std::vector< std::shared_ptr< DlColorSource > > &children)
Public Member Functions inherited from flutter::RefCountedDartWrappable< FragmentProgram >
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 void	Create (Dart_Handle wrapper)

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

Definition at line 24 of file fragment_program.h.

Constructor & Destructor Documentation

~FragmentProgram()

flutter::FragmentProgram::~FragmentProgram ( )

overridedefault

Member Function Documentation

Create()

void flutter::FragmentProgram::Create ( Dart_Handle  wrapper )

static

Definition at line 235 of file fragment_program.cc.

                                                {
  auto res = fml::MakeRefCounted<FragmentProgram>();
  res->AssociateWithDartWrapper(wrapper);
}

initFromAsset()

std::string flutter::FragmentProgram::initFromAsset

(

const std::string &

asset_name

)

Definition at line 100 of file fragment_program.cc.

                                                                    {
  FML_TRACE_EVENT("flutter", "FragmentProgram::initFromAsset", "asset",
                  asset_name);
  UIDartState* ui_dart_state = UIDartState::Current();
  std::shared_ptr<AssetManager> asset_manager =
      ui_dart_state->platform_configuration()->client()->GetAssetManager();
 
  std::unique_ptr<fml::Mapping> data = asset_manager->GetAsMapping(asset_name);
  if (data == nullptr) {
    return std::string("Asset '") + asset_name + std::string("' not found");
  }
 
  auto runtime_stages =
      impeller::RuntimeStage::DecodeRuntimeStages(std::move(data));
 
  if (runtime_stages.empty()) {
    return std::string("Asset '") + asset_name +
           std::string("' does not contain any shader data.");
  }
 
  impeller::RuntimeStageBackend backend =
      ui_dart_state->GetRuntimeStageBackend();
  std::shared_ptr<impeller::RuntimeStage> runtime_stage =
      runtime_stages[backend];
  if (!runtime_stage) {
    std::ostringstream stream;
    stream << "Asset '" << asset_name
           << "' does not contain appropriate runtime stage data for current "
              "backend ("
           << RuntimeStageBackendToString(backend) << ")." << std::endl
           << "Found stages: ";
    for (const auto& kvp : runtime_stages) {
      if (kvp.second) {
        stream << RuntimeStageBackendToString(kvp.first) << " ";
      }
    }
    return stream.str();
  }
 
  int sampled_image_count = 0;
  size_t other_uniforms_bytes = 0;
  const std::vector<impeller::RuntimeUniformDescription>& uniforms =
      runtime_stage->GetUniforms();
  Dart_Handle uniform_info = Dart_NewList(uniforms.size());
  FML_DCHECK(!Dart_IsError(uniform_info));
  for (size_t i = 0; i < uniforms.size(); ++i) {
    const impeller::RuntimeUniformDescription& uniform_description =
        uniforms[i];
 
    Dart_Handle map = ConvertUniformDescriptionToMap(uniform_description);
    [[maybe_unused]] Dart_Handle dart_result =
        Dart_ListSetAt(uniform_info, i, map);
    FML_DCHECK(!Dart_IsError(dart_result));
 
    if (uniform_description.type ==
        impeller::RuntimeUniformType::kSampledImage) {
      sampled_image_count++;
    } else {
      other_uniforms_bytes += uniform_description.GetSize();
    }
  }
 
  if (UIDartState::Current()->IsImpellerEnabled()) {
    // Spawn (but do not block on) a task that will load the runtime stage and
    // populate an initial shader variant.
    auto snapshot_controller = UIDartState::Current()->GetSnapshotDelegate();
    ui_dart_state->GetTaskRunners().GetRasterTaskRunner()->PostTask(
        [runtime_stage, snapshot_controller]() {
          if (!snapshot_controller) {
            return;
          }
          snapshot_controller->CacheRuntimeStage(runtime_stage);
        });
#if IMPELLER_SUPPORTS_RENDERING
    runtime_effect_ = DlRuntimeEffectImpeller::Make(std::move(runtime_stage));
#endif
  } else {
    const auto& code_mapping = runtime_stage->GetCodeMapping();
    auto code_size = code_mapping->GetSize();
    const char* sksl =
        reinterpret_cast<const char*>(code_mapping->GetMapping());
    // SkString makes a copy.
    SkRuntimeEffect::Result result =
        SkRuntimeEffect::MakeForShader(SkString(sksl, code_size));
    if (result.effect == nullptr) {
      return std::string("Invalid SkSL:\n") + sksl +
             std::string("\nSkSL Error:\n") + result.errorText.c_str();
    }
    runtime_effect_ = DlRuntimeEffectSkia::Make(result.effect);
  }
 
  Dart_Handle ths = Dart_HandleFromWeakPersistent(dart_wrapper());
  if (Dart_IsError(ths)) {
    Dart_PropagateError(ths);
  }
 
  Dart_Handle result = Dart_SetField(ths, tonic::ToDart("_samplerCount"),
                                     Dart_NewInteger(sampled_image_count));
  if (Dart_IsError(result)) {
    return "Failed to set sampler count for fragment program.";
  }
 
  size_t rounded_uniform_bytes =
      (other_uniforms_bytes + sizeof(float) - 1) & ~(sizeof(float) - 1);
  size_t float_count = rounded_uniform_bytes / sizeof(float);
 
  result = Dart_SetField(ths, tonic::ToDart("_uniformFloatCount"),
                         Dart_NewInteger(float_count));
  if (Dart_IsError(result)) {
    return "Failed to set uniform float count for fragment program.";
  }
 
  result = Dart_SetField(ths, tonic::ToDart("_uniformInfo"), uniform_info);
  if (Dart_IsError(result)) {
    FML_DLOG(ERROR) << Dart_GetError(result);
    return "Failed to set uniform info for fragment program.";
  }
 
  return "";
}

References flutter::PlatformConfiguration::client(), flutter::UIDartState::Current(), tonic::DartWrappable::dart_wrapper(), flutter::data, impeller::RuntimeStage::DecodeRuntimeStages(), FML_DCHECK, FML_DLOG, FML_TRACE_EVENT, flutter::PlatformConfigurationClient::GetAssetManager(), flutter::TaskRunners::GetRasterTaskRunner(), flutter::UIDartState::GetRuntimeStageBackend(), impeller::RuntimeUniformDescription::GetSize(), flutter::UIDartState::GetSnapshotDelegate(), flutter::UIDartState::GetTaskRunners(), i, impeller::kSampledImage, flutter::DlRuntimeEffectSkia::Make(), flutter::DlRuntimeEffectImpeller::Make(), flutter::UIDartState::platform_configuration(), fml::TaskRunner::PostTask(), flutter::RuntimeStageBackendToString(), tonic::ToDart(), and impeller::RuntimeUniformDescription::type.

MakeDlColorSource()

std::shared_ptr< DlColorSource > flutter::FragmentProgram::MakeDlColorSource	(	std::shared_ptr< std::vector< uint8_t > >	float_uniforms,
		const std::vector< std::shared_ptr< DlColorSource > > &	children
	)

Definition at line 221 of file fragment_program.cc.

                                                             {
  return DlColorSource::MakeRuntimeEffect(runtime_effect_, children,
                                          std::move(float_uniforms));
}

References flutter::DlColorSource::MakeRuntimeEffect().

MakeDlImageFilter()

std::shared_ptr< DlImageFilter > flutter::FragmentProgram::MakeDlImageFilter	(	std::shared_ptr< std::vector< uint8_t > >	float_uniforms,
		const std::vector< std::shared_ptr< DlColorSource > > &	children
	)

Definition at line 228 of file fragment_program.cc.

                                                             {
  return DlImageFilter::MakeRuntimeEffect(runtime_effect_, children,
                                          std::move(float_uniforms));
}

References flutter::DlImageFilter::MakeRuntimeEffect().

shader()

fml::RefPtr< FragmentShader > flutter::FragmentProgram::shader	(	Dart_Handle	shader,
		Dart_Handle	uniforms_handle,
		Dart_Handle	samplers
	)

---

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

• lib/ui/painting/fragment_program.h
• lib/ui/painting/fragment_program.cc