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 binding, size_t vertex_offset, size_t instance=0)
bool	BindUniformData (const ProcTableGLES &gl, const std::vector< TextureAndSampler > &bound_textures, const std::vector< BufferResource > &bound_buffers, Range texture_range, Range buffer_range)
bool	UnbindVertexAttributes (const ProcTableGLES &gl)

Detailed Description

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

Definition at line 30 of file buffer_bindings_gles.h.

Constructor & Destructor Documentation

BufferBindingsGLES()

impeller::BufferBindingsGLES::BufferBindingsGLES ( )

default

~BufferBindingsGLES()

impeller::BufferBindingsGLES::~BufferBindingsGLES ( )

default

References type.

Member Function Documentation

BindUniformData()

bool impeller::BufferBindingsGLES::BindUniformData	(	const ProcTableGLES &	gl,
		const std::vector< TextureAndSampler > &	bound_textures,
		const std::vector< BufferResource > &	bound_buffers,
		Range	texture_range,
		Range	buffer_range
	)

Definition at line 261 of file buffer_bindings_gles.cc.

                        {
  for (auto i = 0u; i < buffer_range.length; i++) {
    if (!BindUniformBuffer(gl, bound_buffers[buffer_range.offset + i])) {
      return false;
    }
  }
  std::optional<size_t> next_unit_index =
      BindTextures(gl, bound_textures, texture_range, ShaderStage::kVertex);
  if (!next_unit_index.has_value()) {
    return false;
  }
  if (!BindTextures(gl, bound_textures, texture_range, ShaderStage::kFragment,
                    *next_unit_index)
           .has_value()) {
    return false;
  }
 
  return true;
}

References i, impeller::kFragment, impeller::kVertex, impeller::Range::length, and impeller::Range::offset.

Referenced by impeller::EncodeCommandsInReactor(), impeller::testing::TEST(), impeller::testing::TEST(), impeller::testing::TEST(), and impeller::testing::TEST().

BindVertexAttributes()

bool impeller::BufferBindingsGLES::BindVertexAttributes	(	const ProcTableGLES &	gl,
		size_t	binding,
		size_t	vertex_offset,
		size_t	instance = 0
	)

Bind the vertex attributes for buffer slot [binding].

[instance] re-points instance-rate attributes at the given instance, used to emulate an instanced draw on drivers without hardware instancing support. It is 0 for a non-instanced or hardware-instanced draw.

Definition at line 197 of file buffer_bindings_gles.cc.

                                                               {
  if (binding >= vertex_attrib_arrays_.size()) {
    return false;
  }
 
  // For an emulated instanced draw (instance > 0), a binding whose attributes
  // are all vertex-rate (divisor 0) does not change across instances, so the
  // state bound for instance 0 still applies. Skip the redundant re-binding.
  if (instance > 0u) {
    bool has_instance_rate = false;
    for (const auto& array : vertex_attrib_arrays_[binding]) {
      if (array.vertex_attrib_divisor != 0u) {
        has_instance_rate = true;
        break;
      }
    }
    if (!has_instance_rate) {
      return true;
    }
  }
 
  if (!gl.GetCapabilities()->IsES()) {
    FML_DCHECK(vertex_array_object_ == 0);
    gl.GenVertexArrays(1, &vertex_array_object_);
    gl.BindVertexArray(vertex_array_object_);
  }
 
  for (const auto& array : vertex_attrib_arrays_[binding]) {
    gl.EnableVertexAttribArray(array.index);
    // For an emulated instanced draw, an instance-rate attribute is
    // re-pointed at instance `instance`, since there is no hardware divisor
    // to advance it. A non-instanced or hardware-instanced draw passes
    // instance 0 and lets the divisor (if any) do the stepping.
    size_t attribute_offset = vertex_offset + array.offset;
    if (array.vertex_attrib_divisor != 0u) {
      attribute_offset += instance * static_cast<size_t>(array.stride);
    }
    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<uintptr_t>(attribute_offset))  // ptr
    );
    // Set the instancing divisor when the driver supports it. It is core
    // on ES 3.0+ and comes from GL_EXT_instanced_arrays on ES 2.0. When
    // unavailable, only per-vertex (divisor 0) bindings are possible,
    // which is the default. Setting it for every attribute (including
    // divisor 0) also clears any stale divisor left by a prior pipeline,
    // which matters on ES, where there is no vertex array object.
    if (gl.VertexAttribDivisor.IsAvailable()) {
      gl.VertexAttribDivisor(array.index, array.vertex_attrib_divisor);
    } else if (gl.VertexAttribDivisorEXT.IsAvailable()) {
      gl.VertexAttribDivisorEXT(array.index, array.vertex_attrib_divisor);
    }
  }
 
  return true;
}

References FML_DCHECK, impeller::ProcTableGLES::GetCapabilities(), and instance.

Referenced by impeller::BindVertexBuffer(), and impeller::testing::TEST().

ReadUniformsBindings()

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

Definition at line 104 of file buffer_bindings_gles.cc.

                                                              {
  if (!gl.IsProgram(program)) {
    return false;
  }
  program_handle_ = program;
  if (gl.GetDescription()->GetGlVersion().IsAtLeast(Version{3, 0, 0})) {
    return ReadUniformsBindingsV3(gl, program);
  }
  return ReadUniformsBindingsV2(gl, program);
}

References impeller::ProcTableGLES::GetDescription(), impeller::DescriptionGLES::GetGlVersion(), and impeller::Version::IsAtLeast().

RegisterVertexStageInput()

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

Definition at line 32 of file buffer_bindings_gles.cc.

                                                       {
  std::vector<std::vector<VertexAttribPointer>> vertex_attrib_arrays(
      layouts.size());
  // Every layout corresponds to a vertex binding.
  // As we record, separate the attributes into buckets for each layout in
  // ascending order. We do this because later on, we'll need to associate each
  // of the attributes with bound buffers corresponding to the binding.
  for (auto layout_i = 0u; layout_i < layouts.size(); layout_i++) {
    const auto& layout = layouts[layout_i];
    for (const auto& input : p_inputs) {
      if (input.binding != layout_i) {
        continue;
      }
      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;
      attrib.vertex_attrib_divisor =
          layout.input_rate == VertexInputRate::kInstance ? 1u : 0u;
      vertex_attrib_arrays[layout_i].push_back(attrib);
    }
  }
  vertex_attrib_arrays_ = std::move(vertex_attrib_arrays);
  return true;
}

References input(), impeller::kInstance, impeller::ToVertexAttribType(), and type.

Referenced by impeller::testing::TEST().

UnbindVertexAttributes()

bool impeller::BufferBindingsGLES::UnbindVertexAttributes

(

const ProcTableGLES &

gl

)

Definition at line 286 of file buffer_bindings_gles.cc.

                                                                       {
  for (const auto& array : vertex_attrib_arrays_) {
    for (const auto& attribute : array) {
      gl.DisableVertexAttribArray(attribute.index);
    }
  }
  if (!gl.GetCapabilities()->IsES()) {
    gl.DeleteVertexArrays(1, &vertex_array_object_);
    vertex_array_object_ = 0;
  }
 
  return true;
}

References impeller::ProcTableGLES::GetCapabilities().

Referenced by impeller::EncodeCommandsInReactor().

---

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