impeller::BufferBindingsGLES Class Reference

Sets up stage bindings for single draw call in the OpenGLES backend. More...

#include <buffer_bindings_gles.h>

Public Member Functions
	BufferBindingsGLES ()
	~BufferBindingsGLES ()
bool	RegisterVertexStageInput (const ProcTableGLES &gl, const std::vector< ShaderStageIOSlot > &inputs, const std::vector< ShaderStageBufferLayout > &layouts)
bool	ReadUniformsBindings (const ProcTableGLES &gl, GLuint program)
bool	BindVertexAttributes (const ProcTableGLES &gl, size_t vertex_offset) const
bool	BindUniformData (const ProcTableGLES &gl, Allocator &transients_allocator, const Bindings &vertex_bindings, const Bindings &fragment_bindings)
bool	UnbindVertexAttributes (const ProcTableGLES &gl) const

Detailed Description

Sets up stage bindings for single draw call in the OpenGLES backend.

Definition at line 22 of file buffer_bindings_gles.h.

Constructor & Destructor Documentation

BufferBindingsGLES()

impeller::BufferBindingsGLES::BufferBindingsGLES ( )

default

~BufferBindingsGLES()

impeller::BufferBindingsGLES::~BufferBindingsGLES ( )

default

Member Function Documentation

BindUniformData()

bool impeller::BufferBindingsGLES::BindUniformData	(	const ProcTableGLES &	gl,
		Allocator &	transients_allocator,
		const Bindings &	vertex_bindings,
		const Bindings &	fragment_bindings
	)

Definition at line 145 of file buffer_bindings_gles.cc.

                                                                            {
  for (const auto& buffer : vertex_bindings.buffers) {
    if (!BindUniformBuffer(gl, transients_allocator, buffer.view)) {
      return false;
    }
  }
  for (const auto& buffer : fragment_bindings.buffers) {
    if (!BindUniformBuffer(gl, transients_allocator, buffer.view)) {
      return false;
    }
  }
 
  std::optional<size_t> next_unit_index =
      BindTextures(gl, vertex_bindings, ShaderStage::kVertex);
  if (!next_unit_index.has_value()) {
    return false;
  }
 
  if (!BindTextures(gl, fragment_bindings, ShaderStage::kFragment,
                    *next_unit_index)
           .has_value()) {
    return false;
  }
 
  return true;
}

References impeller::Bindings::buffers, impeller::kFragment, and impeller::kVertex.

BindVertexAttributes()

bool impeller::BufferBindingsGLES::BindVertexAttributes	(	const ProcTableGLES &	gl,
		size_t	vertex_offset
	)		const

Definition at line 128 of file buffer_bindings_gles.cc.

                                                                          {
  for (const auto& array : vertex_attrib_arrays_) {
    gl.EnableVertexAttribArray(array.index);
    gl.VertexAttribPointer(array.index,       // index
                           array.size,        // size (must be 1, 2, 3, or 4)
                           array.type,        // type
                           array.normalized,  // normalized
                           array.stride,      // stride
                           reinterpret_cast<const GLvoid*>(static_cast<GLsizei>(
                               vertex_offset + array.offset))  // pointer
    );
  }
 
  return true;
}

ReadUniformsBindings()

bool impeller::BufferBindingsGLES::ReadUniformsBindings	(	const ProcTableGLES &	gl,
		GLuint	program
	)

Definition at line 83 of file buffer_bindings_gles.cc.

                                                              {
  if (!gl.IsProgram(program)) {
    return false;
  }
  GLint max_name_size = 0;
  gl.GetProgramiv(program, GL_ACTIVE_UNIFORM_MAX_LENGTH, &max_name_size);
 
  GLint uniform_count = 0;
  gl.GetProgramiv(program, GL_ACTIVE_UNIFORMS, &uniform_count);
 
  // Query the Program for all active uniform locations, and
  // record this via normalized key.
  for (GLint i = 0; i < uniform_count; i++) {
    std::vector<GLchar> name;
    name.resize(max_name_size);
    GLsizei written_count = 0u;
    GLint uniform_var_size = 0u;
    GLenum uniform_type = GL_FLOAT;
    // Note: Active uniforms are defined as uniforms that may have an impact on
    //       the output of the shader. Drivers are allowed to (and often do)
    //       optimize out unused uniforms.
    gl.GetActiveUniform(program,            // program
                        i,                  // index
                        max_name_size,      // buffer_size
                        &written_count,     // length
                        &uniform_var_size,  // size
                        &uniform_type,      // type
                        name.data()         // name
    );
    auto location = gl.GetUniformLocation(program, name.data());
    if (location == -1) {
      VALIDATION_LOG << "Could not query the location of an active uniform.";
      return false;
    }
    if (written_count <= 0) {
      VALIDATION_LOG << "Uniform name could not be read for active uniform.";
      return false;
    }
    uniform_locations_[NormalizeUniformKey(std::string{
        name.data(), static_cast<size_t>(written_count)})] = location;
  }
  return true;
}

References impeller::NormalizeUniformKey(), and VALIDATION_LOG.

RegisterVertexStageInput()

bool impeller::BufferBindingsGLES::RegisterVertexStageInput	(	const ProcTableGLES &	gl,
		const std::vector< ShaderStageIOSlot > &	inputs,
		const std::vector< ShaderStageBufferLayout > &	layouts
	)

Definition at line 22 of file buffer_bindings_gles.cc.

                                                       {
  std::vector<VertexAttribPointer> vertex_attrib_arrays;
  for (auto i = 0u; i < p_inputs.size(); i++) {
    const auto& input = p_inputs[i];
    const auto& layout = layouts[input.binding];
    VertexAttribPointer attrib;
    attrib.index = input.location;
    // Component counts must be 1, 2, 3 or 4. Do that validation now.
    if (input.vec_size < 1u || input.vec_size > 4u) {
      return false;
    }
    attrib.size = input.vec_size;
    auto type = ToVertexAttribType(input.type);
    if (!type.has_value()) {
      return false;
    }
    attrib.type = type.value();
    attrib.normalized = GL_FALSE;
    attrib.offset = input.offset;
    attrib.stride = layout.stride;
    vertex_attrib_arrays.emplace_back(attrib);
  }
  vertex_attrib_arrays_ = std::move(vertex_attrib_arrays);
  return true;
}

References impeller::ToVertexAttribType().

UnbindVertexAttributes()

bool impeller::BufferBindingsGLES::UnbindVertexAttributes

(

const ProcTableGLES &

gl

)

const

Definition at line 175 of file buffer_bindings_gles.cc.

                                                                             {
  for (const auto& array : vertex_attrib_arrays_) {
    gl.DisableVertexAttribArray(array.index);
  }
  return true;
}

---

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

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