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)

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 28 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,
		const std::vector< TextureAndSampler > &	bound_textures,
		const std::vector< BufferResource > &	bound_buffers,
		Range	texture_range,
		Range	buffer_range
	)

Definition at line 222 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 impeller::kFragment, impeller::kVertex, impeller::Range::length, and impeller::Range::offset.

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

◆ BindVertexAttributes()

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

Definition at line 194 of file buffer_bindings_gles.cc.

                                                                     {
   if (binding >= vertex_attrib_arrays_.size()) {
     return false;
   }
  
   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);
     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;
 }

References impeller::ProcTableGLES::GetCapabilities().

Referenced by impeller::BindVertexBuffer().

◆ ReadUniformsBindings()

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

Definition at line 101 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 31 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;
       vertex_attrib_arrays[layout_i].push_back(attrib);
     }
   }
   vertex_attrib_arrays_ = std::move(vertex_attrib_arrays);
   return true;
 }

References impeller::ToVertexAttribType(), and type.

◆ UnbindVertexAttributes()

bool impeller::BufferBindingsGLES::UnbindVertexAttributes ( const ProcTableGLES & gl )

Definition at line 247 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;
 }