impeller::PipelineLibraryGLES Class Reference

#include <pipeline_library_gles.h>

Inheritance diagram for impeller::PipelineLibraryGLES:

Public Member Functions
	~PipelineLibraryGLES () override
Public Member Functions inherited from impeller::PipelineLibrary
virtual	~PipelineLibrary ()
PipelineFuture< PipelineDescriptor >	GetPipeline (std::optional< PipelineDescriptor > descriptor)
PipelineFuture< ComputePipelineDescriptor >	GetPipeline (std::optional< ComputePipelineDescriptor > descriptor)

Private Member Functions
bool	IsValid () const override
PipelineFuture< PipelineDescriptor >	GetPipeline (PipelineDescriptor descriptor) override
PipelineFuture< ComputePipelineDescriptor >	GetPipeline (ComputePipelineDescriptor descriptor) override
void	RemovePipelinesWithEntryPoint (std::shared_ptr< const ShaderFunction > function) override

Additional Inherited Members
Protected Member Functions inherited from impeller::PipelineLibrary
	PipelineLibrary ()

Detailed Description

Definition at line 16 of file pipeline_library_gles.h.

Constructor & Destructor Documentation

~PipelineLibraryGLES()

impeller::PipelineLibraryGLES::~PipelineLibraryGLES ( )

overridedefault

Member Function Documentation

GetPipeline() [1/2]

PipelineFuture< ComputePipelineDescriptor > impeller::PipelineLibraryGLES::GetPipeline ( ComputePipelineDescriptor  descriptor )

overrideprivatevirtual

Implements impeller::PipelineLibrary.

Definition at line 260 of file pipeline_library_gles.cc.

                                          {
  auto promise = std::make_shared<
      std::promise<std::shared_ptr<Pipeline<ComputePipelineDescriptor>>>>();
  // TODO(dnfield): implement compute for GLES.
  promise->set_value(nullptr);
  return {descriptor, promise->get_future()};
}

GetPipeline() [2/2]

PipelineFuture< PipelineDescriptor > impeller::PipelineLibraryGLES::GetPipeline ( PipelineDescriptor  descriptor )

overrideprivatevirtual

Implements impeller::PipelineLibrary.

Definition at line 183 of file pipeline_library_gles.cc.

                                   {
  if (auto found = pipelines_.find(descriptor); found != pipelines_.end()) {
    return found->second;
  }
 
  if (!reactor_) {
    return {
        descriptor,
        RealizedFuture<std::shared_ptr<Pipeline<PipelineDescriptor>>>(nullptr)};
  }
 
  auto vert_function = descriptor.GetEntrypointForStage(ShaderStage::kVertex);
  auto frag_function = descriptor.GetEntrypointForStage(ShaderStage::kFragment);
 
  if (!vert_function || !frag_function) {
    VALIDATION_LOG
        << "Could not find stage entrypoint functions in pipeline descriptor.";
    return {
        descriptor,
        RealizedFuture<std::shared_ptr<Pipeline<PipelineDescriptor>>>(nullptr)};
  }
 
  auto promise = std::make_shared<
      std::promise<std::shared_ptr<Pipeline<PipelineDescriptor>>>>();
  auto pipeline_future =
      PipelineFuture<PipelineDescriptor>{descriptor, promise->get_future()};
  pipelines_[descriptor] = pipeline_future;
  auto weak_this = weak_from_this();
 
  auto result = reactor_->AddOperation(
      [promise, weak_this, reactor_ptr = reactor_, descriptor, vert_function,
       frag_function](const ReactorGLES& reactor) {
        auto strong_this = weak_this.lock();
        if (!strong_this) {
          promise->set_value(nullptr);
          VALIDATION_LOG << "Library was collected before a pending pipeline "
                            "creation could finish.";
          return;
        }
        auto pipeline = std::shared_ptr<PipelineGLES>(
            new PipelineGLES(reactor_ptr, strong_this, descriptor));
        auto program = reactor.GetGLHandle(pipeline->GetProgramHandle());
        if (!program.has_value()) {
          promise->set_value(nullptr);
          VALIDATION_LOG << "Could not obtain program handle.";
          return;
        }
        const auto link_result = LinkProgram(reactor,        //
                                             pipeline,       //
                                             vert_function,  //
                                             frag_function   //
        );
        if (!link_result) {
          promise->set_value(nullptr);
          VALIDATION_LOG << "Could not link pipeline program.";
          return;
        }
        if (!pipeline->BuildVertexDescriptor(reactor.GetProcTable(),
                                             program.value())) {
          promise->set_value(nullptr);
          VALIDATION_LOG << "Could not build pipeline vertex descriptors.";
          return;
        }
        if (!pipeline->IsValid()) {
          promise->set_value(nullptr);
          VALIDATION_LOG << "Pipeline validation checks failed.";
          return;
        }
        promise->set_value(std::move(pipeline));
      });
  FML_CHECK(result);
 
  return pipeline_future;
}

IsValid()

bool impeller::PipelineLibraryGLES::IsValid ( ) const

overrideprivatevirtual

Implements impeller::PipelineLibrary.

Definition at line 178 of file pipeline_library_gles.cc.

                                        {
  return reactor_ != nullptr;
}

RemovePipelinesWithEntryPoint()

void impeller::PipelineLibraryGLES::RemovePipelinesWithEntryPoint ( std::shared_ptr< const ShaderFunction >  function )

overrideprivatevirtual

Implements impeller::PipelineLibrary.

Definition at line 270 of file pipeline_library_gles.cc.

                                                  {
  fml::erase_if(pipelines_, [&](auto item) {
    return item->first.GetEntrypointForStage(function->GetStage())
        ->IsEqual(*function);
  });
}

---

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

• impeller/renderer/backend/gles/pipeline_library_gles.h
• impeller/renderer/backend/gles/pipeline_library_gles.cc