impeller::ProcTableGLES Class Reference

#include <proc_table_gles.h>

Public Types
using	Resolver = std::function< void *(const char *function_name)>

Public Member Functions
	ProcTableGLES (Resolver resolver)
	ProcTableGLES (ProcTableGLES &&other)=default
	~ProcTableGLES ()
	FOR_EACH_IMPELLER_PROC (IMPELLER_PROC)
	FOR_EACH_IMPELLER_GLES3_PROC (IMPELLER_PROC)
	FOR_EACH_IMPELLER_EXT_PROC (IMPELLER_PROC)
bool	IsValid () const
void	ShaderSourceMapping (GLuint shader, const fml::Mapping &mapping, const std::vector< Scalar > &defines={}) const
	Set the source for the attached [shader]. More...
const DescriptionGLES *	GetDescription () const
const std::shared_ptr< const CapabilitiesGLES > &	GetCapabilities () const
std::string	DescribeCurrentFramebuffer () const
std::string	GetProgramInfoLogString (GLuint program) const
bool	IsCurrentFramebufferComplete () const
bool	SetDebugLabel (DebugResourceType type, GLint name, const std::string &label) const
void	PushDebugGroup (const std::string &string) const
void	PopDebugGroup () const
std::optional< std::string >	ComputeShaderWithDefines (const fml::Mapping &mapping, const std::vector< Scalar > &defines) const

Detailed Description

Definition at line 217 of file proc_table_gles.h.

Member Typedef Documentation

Resolver

using impeller::ProcTableGLES::Resolver = std::function<void*(const char* function_name)>

Definition at line 219 of file proc_table_gles.h.

Constructor & Destructor Documentation

ProcTableGLES() [1/2]

impeller::ProcTableGLES::ProcTableGLES ( Resolver  resolver )

explicit

Definition at line 74 of file proc_table_gles.cc.

                                              {
  if (!resolver) {
    return;
  }
 
  resolver = WrappedResolver(resolver);
 
  auto error_fn = reinterpret_cast<PFNGLGETERRORPROC>(resolver("glGetError"));
  if (!error_fn) {
    VALIDATION_LOG << "Could not resolve "
                   << "glGetError";
    return;
  }
 
#define IMPELLER_PROC(proc_ivar)                                \
  if (auto fn_ptr = resolver(proc_ivar.name)) {                 \
    proc_ivar.function =                                        \
        reinterpret_cast<decltype(proc_ivar.function)>(fn_ptr); \
    proc_ivar.error_fn = error_fn;                              \
  } else {                                                      \
    VALIDATION_LOG << "Could not resolve " << proc_ivar.name;   \
    return;                                                     \
  }
 
  FOR_EACH_IMPELLER_PROC(IMPELLER_PROC);
 
#undef IMPELLER_PROC
 
#define IMPELLER_PROC(proc_ivar)                                \
  if (auto fn_ptr = resolver(proc_ivar.name)) {                 \
    proc_ivar.function =                                        \
        reinterpret_cast<decltype(proc_ivar.function)>(fn_ptr); \
    proc_ivar.error_fn = error_fn;                              \
  }
  FOR_EACH_IMPELLER_GLES3_PROC(IMPELLER_PROC);
  FOR_EACH_IMPELLER_EXT_PROC(IMPELLER_PROC);
 
#undef IMPELLER_PROC
 
  description_ = std::make_unique<DescriptionGLES>(*this);
 
  if (!description_->IsValid()) {
    return;
  }
 
  if (!description_->HasDebugExtension()) {
    PushDebugGroupKHR.Reset();
    PopDebugGroupKHR.Reset();
    ObjectLabelKHR.Reset();
  } else {
    GetIntegerv(GL_MAX_LABEL_LENGTH_KHR, &debug_label_max_length_);
  }
 
  if (!description_->HasExtension("GL_EXT_discard_framebuffer")) {
    DiscardFramebufferEXT.Reset();
  }
 
  capabilities_ = std::make_shared<CapabilitiesGLES>(*this);
 
  is_valid_ = true;
}

References FOR_EACH_IMPELLER_EXT_PROC(), FOR_EACH_IMPELLER_GLES3_PROC(), FOR_EACH_IMPELLER_PROC(), IMPELLER_PROC, VALIDATION_LOG, and impeller::WrappedResolver().

ProcTableGLES() [2/2]

impeller::ProcTableGLES::ProcTableGLES ( ProcTableGLES &&  other )

default

~ProcTableGLES()

impeller::ProcTableGLES::~ProcTableGLES ( )

default

Member Function Documentation

ComputeShaderWithDefines()

std::optional< std::string > impeller::ProcTableGLES::ComputeShaderWithDefines	(	const fml::Mapping &	mapping,
		const std::vector< Scalar > &	defines
	)		const

Definition at line 166 of file proc_table_gles.cc.

                                            {
  auto shader_source = std::string{
      reinterpret_cast<const char*>(mapping.GetMapping()), mapping.GetSize()};
 
  // Look for the first newline after the '#version' header, which impellerc
  // will always emit as the first line of a compiled shader.
  auto index = shader_source.find('\n');
  if (index == std::string::npos) {
    VALIDATION_LOG << "Failed to append constant data to shader";
    return std::nullopt;
  }
 
  std::stringstream ss;
  ss << std::fixed;
  for (auto i = 0u; i < defines.size(); i++) {
    ss << "#define SPIRV_CROSS_CONSTANT_ID_" << i << " " << defines[i] << '\n';
  }
  auto define_string = ss.str();
  shader_source.insert(index + 1, define_string);
  return shader_source;
}

References VALIDATION_LOG.

Referenced by ShaderSourceMapping().

DescribeCurrentFramebuffer()

std::string impeller::ProcTableGLES::DescribeCurrentFramebuffer

(

)

const

Definition at line 259 of file proc_table_gles.cc.

                                                          {
  GLint framebuffer = GL_NONE;
  GetIntegerv(GL_FRAMEBUFFER_BINDING, &framebuffer);
  if (IsFramebuffer(framebuffer) == GL_FALSE) {
    return "No framebuffer or the default window framebuffer is bound.";
  }
 
  GLenum status = CheckFramebufferStatus(framebuffer);
  std::stringstream stream;
  stream << "FBO "
         << ((framebuffer == GL_NONE) ? "(Default)"
                                      : std::to_string(framebuffer))
         << ": " << FramebufferStatusToString(status) << std::endl;
  if (IsCurrentFramebufferComplete()) {
    stream << "Framebuffer is complete." << std::endl;
  } else {
    stream << "Framebuffer is incomplete." << std::endl;
  }
  stream << "Description: " << std::endl;
  stream << "Color Attachment: "
         << DescribeFramebufferAttachment(*this, GL_COLOR_ATTACHMENT0)
         << std::endl;
  stream << "Color Attachment: "
         << DescribeFramebufferAttachment(*this, GL_DEPTH_ATTACHMENT)
         << std::endl;
  stream << "Color Attachment: "
         << DescribeFramebufferAttachment(*this, GL_STENCIL_ATTACHMENT)
         << std::endl;
  return stream.str();
}

References impeller::DescribeFramebufferAttachment(), impeller::FramebufferStatusToString(), and IsCurrentFramebufferComplete().

FOR_EACH_IMPELLER_EXT_PROC()

impeller::ProcTableGLES::FOR_EACH_IMPELLER_EXT_PROC

(

IMPELLER_PROC

)

Referenced by ProcTableGLES().

FOR_EACH_IMPELLER_GLES3_PROC()

impeller::ProcTableGLES::FOR_EACH_IMPELLER_GLES3_PROC

(

IMPELLER_PROC

)

Referenced by ProcTableGLES().

FOR_EACH_IMPELLER_PROC()

impeller::ProcTableGLES::FOR_EACH_IMPELLER_PROC

(

IMPELLER_PROC

)

Referenced by ProcTableGLES().

GetCapabilities()

const std::shared_ptr< const CapabilitiesGLES > & impeller::ProcTableGLES::GetCapabilities

(

)

const

Definition at line 194 of file proc_table_gles.cc.

          {
  return capabilities_;
}

Referenced by impeller::SamplerGLES::ConfigureBoundTexture().

GetDescription()

const DescriptionGLES * impeller::ProcTableGLES::GetDescription

(

)

const

Definition at line 190 of file proc_table_gles.cc.

                                                           {
  return description_.get();
}

Referenced by impeller::CapabilitiesGLES::CapabilitiesGLES(), and impeller::GPUTracerGLES::GPUTracerGLES().

GetProgramInfoLogString()

std::string impeller::ProcTableGLES::GetProgramInfoLogString

(

GLuint

program

)

const

Definition at line 392 of file proc_table_gles.cc.

                                                                     {
  GLint length = 0;
  GetProgramiv(program, GL_INFO_LOG_LENGTH, &length);
  if (length <= 0) {
    return "";
  }
 
  length = std::min<GLint>(length, 1024);
  Allocation allocation;
  if (!allocation.Truncate(length, false)) {
    return "";
  }
  GetProgramInfoLog(program,  // program
                    length,   // max length
                    &length,  // length written (excluding NULL terminator)
                    reinterpret_cast<GLchar*>(allocation.GetBuffer())  // buffer
  );
  if (length <= 0) {
    return "";
  }
  return std::string{reinterpret_cast<const char*>(allocation.GetBuffer()),
                     static_cast<size_t>(length)};
}

References impeller::Allocation::GetBuffer(), and impeller::Allocation::Truncate().

IsCurrentFramebufferComplete()

bool impeller::ProcTableGLES::IsCurrentFramebufferComplete

(

)

const

Definition at line 290 of file proc_table_gles.cc.

                                                       {
  GLint framebuffer = GL_NONE;
  GetIntegerv(GL_FRAMEBUFFER_BINDING, &framebuffer);
  if (IsFramebuffer(framebuffer) == GL_FALSE) {
    // The default framebuffer is always complete.
    return true;
  }
  GLenum status = CheckFramebufferStatus(framebuffer);
  return status == GL_FRAMEBUFFER_COMPLETE;
}

Referenced by DescribeCurrentFramebuffer().

IsValid()

bool impeller::ProcTableGLES::IsValid

(

)

const

Definition at line 138 of file proc_table_gles.cc.

                                  {
  return is_valid_;
}

PopDebugGroup()

void impeller::ProcTableGLES::PopDebugGroup

(

)

const

Definition at line 382 of file proc_table_gles.cc.

                                        {
#ifdef IMPELLER_DEBUG
  if (debug_label_max_length_ <= 0) {
    return;
  }
 
  PopDebugGroupKHR();
#endif  // IMPELLER_DEBUG
}

PushDebugGroup()

void impeller::ProcTableGLES::PushDebugGroup

(

const std::string &

string

)

const

Definition at line 365 of file proc_table_gles.cc.

                                                               {
#ifdef IMPELLER_DEBUG
  if (debug_label_max_length_ <= 0) {
    return;
  }
 
  UniqueID id;
  const auto label_length =
      std::min<GLsizei>(debug_label_max_length_ - 1, label.size());
  PushDebugGroupKHR(GL_DEBUG_SOURCE_APPLICATION_KHR,  // source
                    static_cast<GLuint>(id.id),       // id
                    label_length,                     // length
                    label.data()                      // message
  );
#endif  // IMPELLER_DEBUG
}

Referenced by impeller::EncodeCommandsInReactor().

SetDebugLabel()

bool impeller::ProcTableGLES::SetDebugLabel	(	DebugResourceType	type,
		GLint	name,
		const std::string &	label
	)		const

Definition at line 339 of file proc_table_gles.cc.

                                                                {
  if (debug_label_max_length_ <= 0) {
    return true;
  }
  if (!ObjectLabelKHR.IsAvailable()) {
    return true;
  }
  if (!ResourceIsLive(*this, type, name)) {
    return false;
  }
  const auto identifier = ToDebugIdentifier(type);
  const auto label_length =
      std::min<GLsizei>(debug_label_max_length_ - 1, label.size());
  if (!identifier.has_value()) {
    return true;
  }
  ObjectLabelKHR(identifier.value(),  // identifier
                 name,                // name
                 label_length,        // length
                 label.data()         // label
  );
  return true;
}

References impeller::ResourceIsLive(), and impeller::ToDebugIdentifier().

ShaderSourceMapping()

void impeller::ProcTableGLES::ShaderSourceMapping	(	GLuint	shader,
		const fml::Mapping &	mapping,
		const std::vector< Scalar > &	defines = {}
	)		const

Set the source for the attached [shader].

Optionally, [defines] may contain a string value that will be append to the shader source after the version marker. This can be used to support static specialization. For example, setting "#define Foo 1".

Definition at line 142 of file proc_table_gles.cc.

                                            {
  if (defines.empty()) {
    const GLchar* sources[] = {
        reinterpret_cast<const GLchar*>(mapping.GetMapping())};
    const GLint lengths[] = {static_cast<GLint>(mapping.GetSize())};
    ShaderSource(shader, 1u, sources, lengths);
    return;
  }
  const auto& shader_source = ComputeShaderWithDefines(mapping, defines);
  if (!shader_source.has_value()) {
    VALIDATION_LOG << "Failed to append constant data to shader";
    return;
  }
 
  const GLchar* sources[] = {
      reinterpret_cast<const GLchar*>(shader_source->c_str())};
  const GLint lengths[] = {static_cast<GLint>(shader_source->size())};
  ShaderSource(shader, 1u, sources, lengths);
}

References ComputeShaderWithDefines(), and VALIDATION_LOG.

---

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

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