impeller::RuntimeStage Class Reference

#include <runtime_stage.h>

Public Types
using	Map = std::map< RuntimeStageBackend, std::shared_ptr< RuntimeStage > >

Public Member Functions
	~RuntimeStage ()
	RuntimeStage (RuntimeStage &&)
RuntimeStage &	operator= (RuntimeStage &&)
RuntimeShaderStage	GetShaderStage () const
const std::vector< RuntimeUniformDescription > &	GetUniforms () const
const std::vector< DescriptorSetLayout > &	GetDescriptorSetLayouts () const
const std::string &	GetEntrypoint () const
const RuntimeUniformDescription *	GetUniform (const std::string &name) const
const std::shared_ptr< fml::Mapping > &	GetCodeMapping () const
bool	IsDirty () const
void	SetClean ()
void	SetLibraryId (std::string library_id)
const std::string &	GetLibraryId () const

Static Public Member Functions
static absl::StatusOr< Map >	DecodeRuntimeStages (const std::shared_ptr< fml::Mapping > &payload)
static absl::StatusOr< RuntimeStage >	Create (const fb::RuntimeStage *runtime_stage, const std::shared_ptr< fml::Mapping > &payload)

Static Public Attributes
static const char *	kVulkanUBOName

Detailed Description

Definition at line 21 of file runtime_stage.h.

Member Typedef Documentation

Map

using impeller::RuntimeStage::Map = std::map<RuntimeStageBackend, std::shared_ptr<RuntimeStage> >

Definition at line 25 of file runtime_stage.h.

Constructor & Destructor Documentation

~RuntimeStage()

impeller::RuntimeStage::~RuntimeStage ( )

default

RuntimeStage()

impeller::RuntimeStage::RuntimeStage ( RuntimeStage &&  )

default

Member Function Documentation

Create()

absl::StatusOr< RuntimeStage > impeller::RuntimeStage::Create ( const fb::RuntimeStage *  runtime_stage, const std::shared_ptr< fml::Mapping > &  payload  )

static

Definition at line 67 of file runtime_stage.cc.

                                              {
  if (!runtime_stage) {
    return absl::InvalidArgumentError("Runtime stage is null.");
  }
 
  RuntimeStage stage(payload);
  stage.stage_ = ToShaderStage(runtime_stage->stage());
  stage.entrypoint_ = runtime_stage->entrypoint()->str();
  stage.library_id_ = MakeFallbackLibraryId();
 
  auto* uniforms = runtime_stage->uniforms();
 
  // Note: image bindings are screwy and will always have the same offset.
  // track the binding of the UBO to determine where the image bindings go.
  // This is only guaranteed to give us the correct bindings if there is a
  // single sampler2D.
  std::optional<size_t> ubo_id;
  if (uniforms) {
    for (auto i = uniforms->begin(), end = uniforms->end(); i != end; i++) {
      RuntimeUniformDescription desc;
      desc.name = i->name()->str();
      desc.location = i->location();
      desc.binding = i->binding();
      desc.type = ToType(i->type());
      if (desc.type == kStruct) {
        ubo_id = desc.location;
        desc.binding = desc.location;
      }
      desc.dimensions = RuntimeUniformDimensions{
          static_cast<size_t>(i->rows()), static_cast<size_t>(i->columns())};
      desc.bit_width = i->bit_width();
      desc.array_elements = i->array_elements();
      if (i->padding_layout()) {
        for (const auto& byte_type : *i->padding_layout()) {
          impeller::RuntimePaddingType type;
          switch (byte_type) {
            case fb::PaddingType::kPadding:
              type = impeller::RuntimePaddingType::kPadding;
              break;
            case fb::PaddingType::kFloat:
              type = impeller::RuntimePaddingType::kFloat;
              break;
          }
          desc.padding_layout.push_back(type);
        }
      }
      if (i->struct_fields()) {
        for (const auto& elem : *i->struct_fields()) {
          desc.struct_fields.emplace_back(
              StructField{.name = elem->name()->str(),
                          .byte_size = static_cast<size_t>(elem->byte_size())});
        }
      }
      desc.struct_float_count = i->struct_float_count();
      stage.uniforms_.push_back(std::move(desc));
    }
  }
 
  stage.code_mapping_ = std::make_shared<fml::NonOwnedMapping>(
      runtime_stage->shader()->data(),           //
      runtime_stage->shader()->size(),           //
      [payload = stage.payload_](auto, auto) {}  //
  );
 
  size_t binding = 64;
  if (ubo_id.has_value() && ubo_id.value() == binding) {
    binding++;
  }
  for (auto& uniform : stage.uniforms_) {
    if (uniform.type == kSampledImage) {
      uniform.binding = binding;
      binding++;
      if (ubo_id.has_value() && ubo_id.value() == binding) {
        binding++;
      }
    }
  }
 
  for (const auto& uniform : stage.GetUniforms()) {
    if (uniform.type == kStruct) {
      stage.descriptor_set_layouts_.push_back(DescriptorSetLayout{
          static_cast<uint32_t>(uniform.location),
          DescriptorType::kUniformBuffer,
          ShaderStage::kFragment,
      });
    } else if (uniform.type == kSampledImage) {
      stage.descriptor_set_layouts_.push_back(DescriptorSetLayout{
          static_cast<uint32_t>(uniform.binding),
          DescriptorType::kSampledImage,
          ShaderStage::kFragment,
      });
    }
  }
 
  return stage;
}

References impeller::RuntimeUniformDescription::array_elements, impeller::RuntimeUniformDescription::binding, impeller::RuntimeUniformDescription::bit_width, impeller::RuntimeUniformDescription::dimensions, end, GetUniforms(), impeller::kFloat, impeller::kFragment, impeller::kPadding, impeller::kSampledImage, impeller::kStruct, impeller::kUniformBuffer, impeller::RuntimeUniformDescription::location, impeller::StructField::name, impeller::RuntimeUniformDescription::name, impeller::RuntimeUniformDescription::padding_layout, impeller::RuntimeUniformDescription::struct_fields, impeller::RuntimeUniformDescription::struct_float_count, impeller::ToShaderStage(), impeller::ToType(), and impeller::RuntimeUniformDescription::type.

DecodeRuntimeStages()

absl::StatusOr< RuntimeStage::Map > impeller::RuntimeStage::DecodeRuntimeStages ( const std::shared_ptr< fml::Mapping > &  payload )

static

Definition at line 176 of file runtime_stage.cc.

                                              {
  if (payload == nullptr || !payload->GetMapping()) {
    return absl::InvalidArgumentError("Payload is null or empty.");
  }
  if (!fb::RuntimeStagesBufferHasIdentifier(payload->GetMapping())) {
    return absl::InvalidArgumentError(
        "Payload does not have valid identifier.");
  }
 
  flatbuffers::Verifier verifier(payload->GetMapping(), payload->GetSize());
  if (!fb::VerifyRuntimeStagesBuffer(verifier)) {
    return absl::InvalidArgumentError(
        "Runtime stages buffer failed verification.");
  }
 
  auto raw_stages = fb::GetRuntimeStages(payload->GetMapping());
  if (!raw_stages) {
    return absl::InvalidArgumentError("Failed to get runtime stages.");
  }
 
  const uint32_t version = raw_stages->format_version();
  const auto expected =
      static_cast<uint32_t>(fb::RuntimeStagesFormatVersion::kVersion);
  if (version != expected) {
    std::stringstream stream;
    stream << "Unsupported runtime stages format version. Expected " << expected
           << ", got " << version << ".";
    return absl::InvalidArgumentError(stream.str());
  }
 
  return Map{
      {RuntimeStageBackend::kSkSL,
       RuntimeStageIfPresent(raw_stages->sksl(), payload)},
      {RuntimeStageBackend::kMetal,
       RuntimeStageIfPresent(raw_stages->metal(), payload)},
      {RuntimeStageBackend::kOpenGLES,
       RuntimeStageIfPresent(raw_stages->opengles(), payload)},
      {RuntimeStageBackend::kOpenGLES3,
       RuntimeStageIfPresent(raw_stages->opengles3(), payload)},
      {RuntimeStageBackend::kVulkan,
       RuntimeStageIfPresent(raw_stages->vulkan(), payload)},
  };
}

References impeller::kMetal, impeller::kOpenGLES, impeller::kOpenGLES3, impeller::kSkSL, and impeller::kVulkan.

Referenced by impeller::interop::FragmentProgram::FragmentProgram(), impeller::GoldenPlaygroundTest::OpenAssetAsRuntimeStage(), impeller::PlaygroundTest::OpenAssetAsRuntimeStage(), and impeller::testing::TEST_P().

GetCodeMapping()

const std::shared_ptr< fml::Mapping > & impeller::RuntimeStage::GetCodeMapping

(

)

const

Definition at line 228 of file runtime_stage.cc.

                                                                    {
  return code_mapping_;
}

Referenced by impeller::RuntimeStagePlayground::RegisterStage().

GetDescriptorSetLayouts()

const std::vector< DescriptorSetLayout > & impeller::RuntimeStage::GetDescriptorSetLayouts

(

)

const

Definition at line 271 of file runtime_stage.cc.

          {
  return descriptor_set_layouts_;
}

GetEntrypoint()

const std::string & impeller::RuntimeStage::GetEntrypoint

(

)

const

Definition at line 247 of file runtime_stage.cc.

                                                   {
  return entrypoint_;
}

Referenced by impeller::RuntimeStagePlayground::RegisterStage().

GetLibraryId()

const std::string & impeller::RuntimeStage::GetLibraryId

(

)

const

Definition at line 267 of file runtime_stage.cc.

                                                  {
  return library_id_;
}

GetShaderStage()

RuntimeShaderStage impeller::RuntimeStage::GetShaderStage

(

)

const

Definition at line 251 of file runtime_stage.cc.

                                                      {
  return stage_;
}

Referenced by impeller::RuntimeStagePlayground::RegisterStage().

GetUniform()

const RuntimeUniformDescription * impeller::RuntimeStage::GetUniform

(

const std::string &

name

)

const

Definition at line 237 of file runtime_stage.cc.

                                 {
  for (const auto& uniform : uniforms_) {
    if (uniform.name == name) {
      return &uniform;
    }
  }
  return nullptr;
}

GetUniforms()

const std::vector< RuntimeUniformDescription > & impeller::RuntimeStage::GetUniforms

(

)

const

Definition at line 232 of file runtime_stage.cc.

          {
  return uniforms_;
}

Referenced by Create().

IsDirty()

bool impeller::RuntimeStage::IsDirty

(

)

const

Definition at line 255 of file runtime_stage.cc.

                                 {
  return is_dirty_;
}

operator=()

RuntimeStage & impeller::RuntimeStage::operator= ( RuntimeStage &&  )

default

SetClean()

void impeller::RuntimeStage::SetClean

(

)

Definition at line 259 of file runtime_stage.cc.

                            {
  is_dirty_ = false;
}

SetLibraryId()

void impeller::RuntimeStage::SetLibraryId

(

std::string

library_id

)

Stable per-source identifier used to namespace this stage's entrypoint in the shared shader registry, so that user-supplied runtime shaders cannot collide with engine-internal shaders or with shaders from other asset paths. Defaults to a process-unique fallback assigned at decode time. Should be overwritten with a stable id (typically the asset path the stage was loaded from) so that hot reload of the same asset continues to evict and replace the same registry slot.

Definition at line 263 of file runtime_stage.cc.

                                                    {
  library_id_ = std::move(library_id);
}

Member Data Documentation

kVulkanUBOName

const char * impeller::RuntimeStage::kVulkanUBOName

static

Initial value:

=
    "_RESERVED_IDENTIFIER_FIXUP_gl_DefaultUniformBlock"

The generated name from GLSLang/shaderc for the UBO containing non-opaque uniforms specified in the user-written runtime effect shader.

Vulkan does not allow non-opaque uniforms outside of a UBO.

Definition at line 23 of file runtime_stage.h.

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

---

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

• impeller/runtime_stage/runtime_stage.h
• impeller/runtime_stage/runtime_stage.cc