impeller::PassBindingsCache Class Reference

Ensures that bindings on the pass are not redundantly set or updated. Avoids making the driver do additional checks and makes the frame insights during profiling and instrumentation not complain about the same. More...

#include <pass_bindings_cache.h>

Public Member Functions
	PassBindingsCache (id< MTLRenderCommandEncoder > encoder)
	PassBindingsCache (const PassBindingsCache &)=delete
	PassBindingsCache (PassBindingsCache &&)=delete
void	SetRenderPipelineState (id< MTLRenderPipelineState > pipeline)
void	SetDepthStencilState (id< MTLDepthStencilState > depth_stencil)
bool	SetBuffer (ShaderStage stage, uint64_t index, uint64_t offset, id< MTLBuffer > buffer)
bool	SetTexture (ShaderStage stage, uint64_t index, id< MTLTexture > texture)
bool	SetSampler (ShaderStage stage, uint64_t index, id< MTLSamplerState > sampler)
void	SetViewport (const Viewport &viewport)
void	SetScissor (const IRect &scissor)
void	BindPipeline (vk::CommandBuffer command_buffer, vk::PipelineBindPoint pipeline_bind_point, vk::Pipeline pipeline)
void	SetStencilReference (vk::CommandBuffer command_buffer, vk::StencilFaceFlags face_mask, uint32_t reference)
void	SetScissor (vk::CommandBuffer command_buffer, uint32_t first_scissor, uint32_t scissor_count, const vk::Rect2D *scissors)
void	SetViewport (vk::CommandBuffer command_buffer, uint32_t first_viewport, uint32_t viewport_count, const vk::Viewport *viewports)

Detailed Description

Ensures that bindings on the pass are not redundantly set or updated. Avoids making the driver do additional checks and makes the frame insights during profiling and instrumentation not complain about the same.

There should be no change to rendering if this caching was absent.

Definition at line 194 of file render_pass_mtl.mm.

Constructor & Destructor Documentation

PassBindingsCache() [1/3]

impeller::PassBindingsCache::PassBindingsCache ( id< MTLRenderCommandEncoder >  encoder )

inlineexplicit

Definition at line 195 of file render_pass_mtl.mm.

      : encoder_(encoder) {}

PassBindingsCache() [2/3]

impeller::PassBindingsCache::PassBindingsCache ( const PassBindingsCache &  )

delete

PassBindingsCache() [3/3]

impeller::PassBindingsCache::PassBindingsCache ( PassBindingsCache &&  )

delete

Member Function Documentation

BindPipeline()

void impeller::PassBindingsCache::BindPipeline	(	vk::CommandBuffer	command_buffer,
		vk::PipelineBindPoint	pipeline_bind_point,
		vk::Pipeline	pipeline
	)

Definition at line 8 of file pass_bindings_cache.cc.

                                                          {
  switch (pipeline_bind_point) {
    case vk::PipelineBindPoint::eGraphics:
      if (graphics_pipeline_.has_value() &&
          graphics_pipeline_.value() == pipeline) {
        return;
      }
      graphics_pipeline_ = pipeline;
      break;
    case vk::PipelineBindPoint::eCompute:
      if (compute_pipeline_.has_value() &&
          compute_pipeline_.value() == pipeline) {
        return;
      }
      compute_pipeline_ = pipeline;
      break;
    default:
      break;
  }
  command_buffer.bindPipeline(pipeline_bind_point, pipeline);
}

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

SetBuffer()

bool impeller::PassBindingsCache::SetBuffer ( ShaderStage  stage, uint64_t  index, uint64_t  offset, id< MTLBuffer >  buffer  )

inline

Definition at line 218 of file render_pass_mtl.mm.

                                       {
    auto& buffers_map = buffers_[stage];
    auto found = buffers_map.find(index);
    if (found != buffers_map.end() && found->second.buffer == buffer) {
      // The right buffer is bound. Check if its offset needs to be updated.
      if (found->second.offset == offset) {
        // Buffer and its offset is identical. Nothing to do.
        return true;
      }
 
      // Only the offset needs to be updated.
      found->second.offset = offset;
 
      switch (stage) {
        case ShaderStage::kVertex:
          [encoder_ setVertexBufferOffset:offset atIndex:index];
          return true;
        case ShaderStage::kFragment:
          [encoder_ setFragmentBufferOffset:offset atIndex:index];
          return true;
        default:
          VALIDATION_LOG << "Cannot update buffer offset of an unknown stage.";
          return false;
      }
      return true;
    }
    buffers_map[index] = {buffer, static_cast<size_t>(offset)};
    switch (stage) {
      case ShaderStage::kVertex:
        [encoder_ setVertexBuffer:buffer offset:offset atIndex:index];
        return true;
      case ShaderStage::kFragment:
        [encoder_ setFragmentBuffer:buffer offset:offset atIndex:index];
        return true;
      default:
        VALIDATION_LOG << "Cannot bind buffer to unknown shader stage.";
        return false;
    }
    return false;
  }

References VALIDATION_LOG.

Referenced by impeller::Bind().

SetDepthStencilState()

void impeller::PassBindingsCache::SetDepthStencilState ( id< MTLDepthStencilState >  depth_stencil )

inline

Definition at line 210 of file render_pass_mtl.mm.

                                                                    {
    if (depth_stencil_ == depth_stencil) {
      return;
    }
    depth_stencil_ = depth_stencil;
    [encoder_ setDepthStencilState:depth_stencil_];
  }

SetRenderPipelineState()

void impeller::PassBindingsCache::SetRenderPipelineState ( id< MTLRenderPipelineState >  pipeline )

inline

Definition at line 202 of file render_pass_mtl.mm.

                                                                   {
    if (pipeline == pipeline_) {
      return;
    }
    pipeline_ = pipeline;
    [encoder_ setRenderPipelineState:pipeline_];
  }

SetSampler()

bool impeller::PassBindingsCache::SetSampler ( ShaderStage  stage, uint64_t  index, id< MTLSamplerState >  sampler  )

inline

Definition at line 284 of file render_pass_mtl.mm.

                                               {
    auto& sampler_map = samplers_[stage];
    auto found = sampler_map.find(index);
    if (found != sampler_map.end() && found->second == sampler) {
      // Already bound.
      return true;
    }
    sampler_map[index] = sampler;
    switch (stage) {
      case ShaderStage::kVertex:
        [encoder_ setVertexSamplerState:sampler atIndex:index];
        return true;
      case ShaderStage::kFragment:
        [encoder_ setFragmentSamplerState:sampler atIndex:index];
        return true;
      default:
        VALIDATION_LOG << "Cannot bind buffer to unknown shader stage.";
        return false;
    }
    return false;
  }

References VALIDATION_LOG.

Referenced by impeller::Bind().

SetScissor() [1/2]

void impeller::PassBindingsCache::SetScissor ( const IRect &  scissor )

inline

Definition at line 323 of file render_pass_mtl.mm.

                                        {
    if (scissor_.has_value() && scissor_.value() == scissor) {
      return;
    }
    [encoder_
        setScissorRect:MTLScissorRect{
                           .x = static_cast<NSUInteger>(scissor.origin.x),
                           .y = static_cast<NSUInteger>(scissor.origin.y),
                           .width = static_cast<NSUInteger>(scissor.size.width),
                           .height =
                               static_cast<NSUInteger>(scissor.size.height),
                       }];
    scissor_ = scissor;
  }

References impeller::TSize< T >::height, impeller::TRect< T >::origin, impeller::TRect< T >::size, impeller::TSize< T >::width, impeller::TPoint< T >::x, and impeller::TPoint< T >::y.

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

SetScissor() [2/2]

void impeller::PassBindingsCache::SetScissor	(	vk::CommandBuffer	command_buffer,
		uint32_t	first_scissor,
		uint32_t	scissor_count,
		const vk::Rect2D *	scissors
	)

Definition at line 45 of file pass_bindings_cache.cc.

                                                             {
  if (first_scissor == 0 && scissor_count == 1) {
    if (scissors_.has_value() && scissors_.value() == scissors[0]) {
      return;
    }
    scissors_ = scissors[0];
  }
  command_buffer.setScissor(first_scissor, scissor_count, scissors);
}

SetStencilReference()

void impeller::PassBindingsCache::SetStencilReference	(	vk::CommandBuffer	command_buffer,
		vk::StencilFaceFlags	face_mask,
		uint32_t	reference
	)

Definition at line 32 of file pass_bindings_cache.cc.

                                                                {
  if (stencil_face_flags_.has_value() &&
      face_mask == stencil_face_flags_.value() &&
      reference == stencil_reference_) {
    return;
  }
  stencil_face_flags_ = face_mask;
  stencil_reference_ = reference;
  command_buffer.setStencilReference(face_mask, reference);
}

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

SetTexture()

bool impeller::PassBindingsCache::SetTexture ( ShaderStage  stage, uint64_t  index, id< MTLTexture >  texture  )

inline

Definition at line 262 of file render_pass_mtl.mm.

                                                                             {
    auto& texture_map = textures_[stage];
    auto found = texture_map.find(index);
    if (found != texture_map.end() && found->second == texture) {
      // Already bound.
      return true;
    }
    texture_map[index] = texture;
    switch (stage) {
      case ShaderStage::kVertex:
        [encoder_ setVertexTexture:texture atIndex:index];
        return true;
      case ShaderStage::kFragment:
        [encoder_ setFragmentTexture:texture atIndex:index];
        return true;
      default:
        VALIDATION_LOG << "Cannot bind buffer to unknown shader stage.";
        return false;
    }
    return false;
  }

References VALIDATION_LOG.

Referenced by impeller::Bind().

SetViewport() [1/2]

void impeller::PassBindingsCache::SetViewport ( const Viewport &  viewport )

inline

Definition at line 308 of file render_pass_mtl.mm.

                                             {
    if (viewport_.has_value() && viewport_.value() == viewport) {
      return;
    }
    [encoder_ setViewport:MTLViewport{
                              .originX = viewport.rect.origin.x,
                              .originY = viewport.rect.origin.y,
                              .width = viewport.rect.size.width,
                              .height = viewport.rect.size.height,
                              .znear = viewport.depth_range.z_near,
                              .zfar = viewport.depth_range.z_far,
                          }];
    viewport_ = viewport;
  }

References impeller::Viewport::depth_range, impeller::TSize< T >::height, impeller::TRect< T >::origin, impeller::Viewport::rect, impeller::TRect< T >::size, impeller::TSize< T >::width, impeller::TPoint< T >::x, impeller::TPoint< T >::y, impeller::DepthRange::z_far, and impeller::DepthRange::z_near.

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

SetViewport() [2/2]

void impeller::PassBindingsCache::SetViewport	(	vk::CommandBuffer	command_buffer,
		uint32_t	first_viewport,
		uint32_t	viewport_count,
		const vk::Viewport *	viewports
	)

Definition at line 58 of file pass_bindings_cache.cc.

                                                                 {
  if (first_viewport == 0 && viewport_count == 1) {
    // Note that this is doing equality checks on floating point numbers.
    if (viewport_.has_value() && viewport_.value() == viewports[0]) {
      return;
    }
    viewport_ = viewports[0];
  }
  command_buffer.setViewport(first_viewport, viewport_count, viewports);
}

---

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

• impeller/renderer/backend/metal/render_pass_mtl.mm
• impeller/renderer/backend/vulkan/pass_bindings_cache.h
• impeller/renderer/backend/vulkan/pass_bindings_cache.cc