#include <fragment_shader.h>

Inheritance diagram for flutter::ReusableFragmentShader:

Public Member Functions
	~ReusableFragmentShader () override

void	SetImageSampler (Dart_Handle index, Dart_Handle image, int filterQualityIndex)

bool	ValidateSamplers ()

bool	ValidateImageFilter ()

void	Dispose ()

std::shared_ptr< DlColorSource >	shader (DlImageSampling) override

std::shared_ptr< DlImageFilter >	as_image_filter () const

Public Member Functions inherited from flutter::Shader
	~Shader () override

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 Dart_Handle	Create (Dart_Handle wrapper, Dart_Handle program, Dart_Handle float_count, Dart_Handle sampler_count)

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

Protected Member Functions inherited from flutter::Shader
	Shader ()

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 25 of file fragment_shader.h.

Constructor & Destructor Documentation

◆ ~ReusableFragmentShader()

flutter::ReusableFragmentShader::~ReusableFragmentShader ( )

overridedefault

References shader().

Member Function Documentation

◆ as_image_filter()

std::shared_ptr< DlImageFilter > flutter::ReusableFragmentShader::as_image_filter ( ) const

Definition at line 97 of file fragment_shader.cc.

                                                                           {
  FML_CHECK(program_);
 
  // The lifetime of this object is longer than a frame, and the uniforms can be
  // continually changed on the UI thread. So we take a copy of the uniforms
  // before handing it to the DisplayList for consumption on the render thread.
  auto uniform_data = std::make_shared<std::vector<uint8_t>>();
  uniform_data->resize(uniform_data_->size());
  memcpy(uniform_data->data(), uniform_data_->bytes(), uniform_data->size());
 
  return program_->MakeDlImageFilter(std::move(uniform_data), samplers_);
}

References FML_CHECK.

Referenced by flutter::ImageFilter::initShader().

◆ Create()

Dart_Handle flutter::ReusableFragmentShader::Create	(	Dart_Handle	wrapper,
		Dart_Handle	program,
		Dart_Handle	float_count,
		Dart_Handle	sampler_count
	)

static

Definition at line 30 of file fragment_shader.cc.

                                                                             {
  auto* fragment_program =
      tonic::DartConverter<FragmentProgram*>::FromDart(program);
  uint64_t float_count =
      tonic::DartConverter<uint64_t>::FromDart(float_count_handle);
  uint64_t sampler_count =
      tonic::DartConverter<uint64_t>::FromDart(sampler_count_handle);
 
  auto res = fml::MakeRefCounted<ReusableFragmentShader>(
      fml::Ref(fragment_program), float_count, sampler_count);
  res->AssociateWithDartWrapper(wrapper);
 
  void* raw_uniform_data =
      reinterpret_cast<void*>(res->uniform_data_->writable_data());
  return Dart_NewExternalTypedData(Dart_TypedData_kFloat32, raw_uniform_data,
                                   float_count);
}

References fml::Ref().

◆ Dispose()

void flutter::ReusableFragmentShader::Dispose ( )

Definition at line 146 of file fragment_shader.cc.

                                     {
  uniform_data_.reset();
  program_ = nullptr;
  samplers_.clear();
  ClearDartWrapper();
}

◆ SetImageSampler()

void flutter::ReusableFragmentShader::SetImageSampler	(	Dart_Handle	index,
		Dart_Handle	image,
		int	filterQualityIndex
	)

Definition at line 63 of file fragment_shader.cc.

                                                                     {
  uint64_t index = tonic::DartConverter<uint64_t>::FromDart(index_handle);
  CanvasImage* image =
      tonic::DartConverter<CanvasImage*>::FromDart(image_handle);
  if (index >= samplers_.size()) {
    Dart_ThrowException(tonic::ToDart("Sampler index out of bounds"));
    return;
  }
  if (!image || !image->image()) {
    Dart_ThrowException(tonic::ToDart("Image has been disposed"));
    return;
  }
  if (!image->image()->isUIThreadSafe()) {
    Dart_ThrowException(tonic::ToDart("Image is not thread-safe"));
    return;
  }
 
  // TODO(115794): Once the DlImageSampling enum is replaced, expose the
  //               sampling options as a new default parameter for users.
  samplers_[index] = DlColorSource::MakeImage(
      image->image(), DlTileMode::kClamp, DlTileMode::kClamp,
      ImageFilter::SamplingFromIndex(filterQualityIndex), nullptr);
  // This should be true since we already checked the image above, but
  // we check again for sanity.
  FML_DCHECK(samplers_[index]->isUIThreadSafe());
 
  auto* uniform_floats =
      reinterpret_cast<float*>(uniform_data_->writable_data());
  uniform_floats[float_count_ + 2 * index] = image->width();
  uniform_floats[float_count_ + 2 * index + 1] = image->height();
}

References FML_DCHECK, FlutterVulkanImage::image, image, and tonic::ToDart().

◆ shader()

std::shared_ptr< DlColorSource > flutter::ReusableFragmentShader::shader ( DlImageSampling sampling )

overridevirtual

Implements flutter::Shader.

Definition at line 110 of file fragment_shader.cc.

                              {
  FML_CHECK(program_);
 
  // The lifetime of this object is longer than a frame, and the uniforms can be
  // continually changed on the UI thread. So we take a copy of the uniforms
  // before handing it to the DisplayList for consumption on the render thread.
  auto uniform_data = std::make_shared<std::vector<uint8_t>>();
  uniform_data->resize(uniform_data_->size());
  memcpy(uniform_data->data(), uniform_data_->bytes(), uniform_data->size());
 
  auto source = program_->MakeDlColorSource(std::move(uniform_data), samplers_);
  // The samplers should have been checked as they were added, this
  // is a double-sanity-check.
  FML_DCHECK(source->isUIThreadSafe());
  return source;
}

References FML_CHECK, and FML_DCHECK.

Referenced by ~ReusableFragmentShader().

◆ ValidateImageFilter()

bool flutter::ReusableFragmentShader::ValidateImageFilter ( )

Definition at line 130 of file fragment_shader.cc.

                                                 {
  if (samplers_.size() < 1) {
    return false;
  }
  // The first sampler does not need to be set.
  for (auto i = 1u; i < samplers_.size(); i++) {
    if (samplers_[i] == nullptr) {
      return false;
    }
    // The samplers should have been checked as they were added, this
    // is a double-sanity-check.
    FML_DCHECK(samplers_[i]->isUIThreadSafe());
  }
  return true;
}

References FML_DCHECK, and i.

◆ ValidateSamplers()

bool flutter::ReusableFragmentShader::ValidateSamplers ( )

Definition at line 51 of file fragment_shader.cc.

                                              {
  for (auto i = 0u; i < samplers_.size(); i++) {
    if (samplers_[i] == nullptr) {
      return false;
    }
    // The samplers should have been checked as they were added, this
    // is a double-sanity-check.
    FML_DCHECK(samplers_[i]->isUIThreadSafe());
  }
  return true;
}