impeller::ReactorGLES Class Reference

#include <reactor_gles.h>

Classes
class	Worker

Public Types
using	WorkerID = UniqueID
using	Ref = std::shared_ptr< ReactorGLES >
using	Operation = std::function< void(const ReactorGLES &reactor)>

Public Member Functions
	ReactorGLES (std::unique_ptr< ProcTableGLES > gl)
	~ReactorGLES ()
bool	IsValid () const
WorkerID	AddWorker (std::weak_ptr< Worker > worker)
bool	RemoveWorker (WorkerID)
const ProcTableGLES &	GetProcTable () const
std::optional< GLuint >	GetGLHandle (const HandleGLES &handle) const
HandleGLES	CreateHandle (HandleType type)
void	CollectHandle (HandleGLES handle)
void	SetDebugLabel (const HandleGLES &handle, std::string label)
bool	AddOperation (Operation operation)
bool	React ()

Detailed Description

Definition at line 19 of file reactor_gles.h.

Member Typedef Documentation

Operation

using impeller::ReactorGLES::Operation = std::function<void(const ReactorGLES& reactor)>

Definition at line 53 of file reactor_gles.h.

Ref

using impeller::ReactorGLES::Ref = std::shared_ptr<ReactorGLES>

Definition at line 31 of file reactor_gles.h.

WorkerID

using impeller::ReactorGLES::WorkerID = UniqueID

Definition at line 21 of file reactor_gles.h.

Constructor & Destructor Documentation

ReactorGLES()

impeller::ReactorGLES::ReactorGLES

(

std::unique_ptr< ProcTableGLES >

gl

)

Definition at line 14 of file reactor_gles.cc.

    : proc_table_(std::move(gl)) {
  if (!proc_table_ || !proc_table_->IsValid()) {
    VALIDATION_LOG << "Proc table was invalid.";
    return;
  }
  can_set_debug_labels_ = proc_table_->GetDescription()->HasDebugExtension();
  is_valid_ = true;
}

References VALIDATION_LOG.

~ReactorGLES()

impeller::ReactorGLES::~ReactorGLES ( )

default

Member Function Documentation

AddOperation()

bool impeller::ReactorGLES::AddOperation

(

Operation

operation

)

Definition at line 70 of file reactor_gles.cc.

                                                  {
  if (!operation) {
    return false;
  }
  {
    Lock ops_lock(ops_mutex_);
    ops_.emplace_back(std::move(operation));
  }
  // Attempt a reaction if able but it is not an error if this isn't possible.
  [[maybe_unused]] auto result = React();
  return true;
}

References React().

AddWorker()

ReactorGLES::WorkerID impeller::ReactorGLES::AddWorker

(

std::weak_ptr< Worker >

worker

)

Definition at line 30 of file reactor_gles.cc.

                                                                     {
  Lock lock(workers_mutex_);
  auto id = WorkerID{};
  workers_[id] = std::move(worker);
  return id;
}

CollectHandle()

void impeller::ReactorGLES::CollectHandle

(

HandleGLES

handle

)

Definition at line 148 of file reactor_gles.cc.

                                                 {
  WriterLock handles_lock(handles_mutex_);
  if (auto found = handles_.find(handle); found != handles_.end()) {
    found->second.pending_collection = true;
  }
}

CreateHandle()

HandleGLES impeller::ReactorGLES::CreateHandle

(

HandleType

type

)

Definition at line 132 of file reactor_gles.cc.

                                                    {
  if (type == HandleType::kUnknown) {
    return HandleGLES::DeadHandle();
  }
  auto new_handle = HandleGLES::Create(type);
  if (new_handle.IsDead()) {
    return HandleGLES::DeadHandle();
  }
  WriterLock handles_lock(handles_mutex_);
  auto gl_handle = CanReactOnCurrentThread()
                       ? CreateGLHandle(GetProcTable(), type)
                       : std::nullopt;
  handles_[new_handle] = LiveHandle{gl_handle};
  return new_handle;
}

References impeller::CreateGLHandle(), impeller::HandleGLES::DeadHandle(), GetProcTable(), and impeller::kUnknown.

GetGLHandle()

std::optional< GLuint > impeller::ReactorGLES::GetGLHandle

(

const HandleGLES &

handle

)

const

Definition at line 52 of file reactor_gles.cc.

                                                                           {
  ReaderLock handles_lock(handles_mutex_);
  if (auto found = handles_.find(handle); found != handles_.end()) {
    if (found->second.pending_collection) {
      VALIDATION_LOG
          << "Attempted to acquire a handle that was pending collection.";
      return std::nullopt;
    }
    if (!found->second.name.has_value()) {
      VALIDATION_LOG << "Attempt to acquire a handle outside of an operation.";
      return std::nullopt;
    }
    return found->second.name;
  }
  VALIDATION_LOG << "Attempted to acquire an invalid GL handle.";
  return std::nullopt;
}

References VALIDATION_LOG.

Referenced by impeller::LinkProgram().

GetProcTable()

const ProcTableGLES & impeller::ReactorGLES::GetProcTable

(

)

const

Definition at line 47 of file reactor_gles.cc.

                                                     {
  FML_DCHECK(IsValid());
  return *proc_table_;
}

References IsValid().

Referenced by CreateHandle(), impeller::BlitCopyTextureToTextureCommandGLES::Encode(), impeller::BlitCopyTextureToBufferCommandGLES::Encode(), impeller::EncodeCommandsInReactor(), and impeller::LinkProgram().

IsValid()

bool impeller::ReactorGLES::IsValid

(

)

const

Definition at line 26 of file reactor_gles.cc.

                                {
  return is_valid_;
}

Referenced by GetProcTable().

React()

bool impeller::ReactorGLES::React

(

)

Definition at line 155 of file reactor_gles.cc.

                        {
  if (!CanReactOnCurrentThread()) {
    return false;
  }
  TRACE_EVENT0("impeller", "ReactorGLES::React");
  while (HasPendingOperations()) {
    if (!ReactOnce()) {
      return false;
    }
  }
  return true;
}

Referenced by AddOperation().

RemoveWorker()

bool impeller::ReactorGLES::RemoveWorker

(

WorkerID

worker

)

Definition at line 37 of file reactor_gles.cc.

                                              {
  Lock lock(workers_mutex_);
  return workers_.erase(worker) == 1;
}

SetDebugLabel()

void impeller::ReactorGLES::SetDebugLabel	(	const HandleGLES &	handle,
		std::string	label
	)

Definition at line 250 of file reactor_gles.cc.

                                                                         {
  if (!can_set_debug_labels_) {
    return;
  }
  if (handle.IsDead()) {
    return;
  }
  WriterLock handles_lock(handles_mutex_);
  if (auto found = handles_.find(handle); found != handles_.end()) {
    found->second.pending_debug_label = std::move(label);
  }
}

References impeller::HandleGLES::IsDead().

---

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

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