impeller::compiler::RuntimeStageData Class Reference

#include <runtime_stage_data.h>

Public Member Functions
	RuntimeStageData (std::string entrypoint, spv::ExecutionModel stage, TargetPlatform target_platform)
	~RuntimeStageData ()
void	AddUniformDescription (UniformDescription uniform)
void	SetShaderData (std::shared_ptr< fml::Mapping > shader)
void	SetSkSLData (std::shared_ptr< fml::Mapping > sksl)
std::shared_ptr< fml::Mapping >	CreateMapping () const
std::shared_ptr< fml::Mapping >	CreateJsonMapping () const

Detailed Description

Definition at line 28 of file runtime_stage_data.h.

Constructor & Destructor Documentation

RuntimeStageData()

impeller::compiler::RuntimeStageData::RuntimeStageData	(	std::string	entrypoint,
		spv::ExecutionModel	stage,
		TargetPlatform	target_platform
	)

Definition at line 18 of file runtime_stage_data.cc.

    : entrypoint_(std::move(entrypoint)),
      stage_(stage),
      target_platform_(target_platform) {}

~RuntimeStageData()

impeller::compiler::RuntimeStageData::~RuntimeStageData ( )

default

Member Function Documentation

AddUniformDescription()

void impeller::compiler::RuntimeStageData::AddUniformDescription

(

UniformDescription

uniform

)

Definition at line 27 of file runtime_stage_data.cc.

                                                                       {
  uniforms_.emplace_back(std::move(uniform));
}

CreateJsonMapping()

std::shared_ptr< fml::Mapping > impeller::compiler::RuntimeStageData::CreateJsonMapping

(

)

const

Definition at line 221 of file runtime_stage_data.cc.

                                                                    {
  // Runtime Stage Data JSON format
  //   {
  //      "stage": 0,
  //      "target_platform": "",
  //      "entrypoint": "",
  //      "shader": "",
  //      "sksl": "",
  //      "uniforms": [
  //        {
  //           "name": "..",
  //           "location": 0,
  //           "type": 0,
  //           "rows": 0,
  //           "columns": 0,
  //           "bit_width": 0,
  //           "array_elements": 0,
  //        }
  //      ]
  //   },
  nlohmann::json root;
 
  const auto stage = ToJsonStage(stage_);
  if (!stage.has_value()) {
    VALIDATION_LOG << "Invalid runtime stage.";
    return nullptr;
  }
  root[kStageKey] = stage.value();
 
  const auto target_platform = ToJsonTargetPlatform(target_platform_);
  if (!target_platform.has_value()) {
    VALIDATION_LOG << "Invalid target platform for runtime stage.";
    return nullptr;
  }
  root[kTargetPlatformKey] = target_platform.value();
 
  if (shader_->GetSize() > 0u) {
    std::string shader(reinterpret_cast<const char*>(shader_->GetMapping()),
                       shader_->GetSize());
    root[kShaderKey] = shader.c_str();
  }
 
  auto& uniforms = root[kUniformsKey] = nlohmann::json::array_t{};
  for (const auto& uniform : uniforms_) {
    nlohmann::json uniform_object;
    uniform_object[kUniformNameKey] = uniform.name.c_str();
    uniform_object[kUniformLocationKey] = uniform.location;
    uniform_object[kUniformRowsKey] = uniform.rows;
    uniform_object[kUniformColumnsKey] = uniform.columns;
 
    auto uniform_type = ToJsonType(uniform.type);
    if (!uniform_type.has_value()) {
      VALIDATION_LOG << "Invalid uniform type for runtime stage.";
      return nullptr;
    }
 
    uniform_object[kUniformTypeKey] = uniform_type.value();
    uniform_object[kUniformBitWidthKey] = uniform.bit_width;
 
    if (uniform.array_elements.has_value()) {
      uniform_object[kUniformArrayElementsKey] = uniform.array_elements.value();
    } else {
      uniform_object[kUniformArrayElementsKey] = 0;
    }
    uniforms.push_back(uniform_object);
  }
 
  auto json_string = std::make_shared<std::string>(root.dump(2u));
 
  return std::make_shared<fml::NonOwnedMapping>(
      reinterpret_cast<const uint8_t*>(json_string->data()),
      json_string->size(), [json_string](auto, auto) {});
}

References impeller::compiler::kShaderKey, impeller::compiler::kStageKey, impeller::compiler::kTargetPlatformKey, impeller::compiler::kUniformArrayElementsKey, impeller::compiler::kUniformBitWidthKey, impeller::compiler::kUniformColumnsKey, impeller::compiler::kUniformLocationKey, impeller::compiler::kUniformNameKey, impeller::compiler::kUniformRowsKey, impeller::compiler::kUniformsKey, impeller::compiler::kUniformTypeKey, impeller::compiler::ToJsonStage(), impeller::compiler::ToJsonTargetPlatform(), impeller::compiler::ToJsonType(), and VALIDATION_LOG.

CreateMapping()

std::shared_ptr< fml::Mapping > impeller::compiler::RuntimeStageData::CreateMapping

(

)

const

Definition at line 295 of file runtime_stage_data.cc.

                                                                {
  // The high level object API is used here for writing to the buffer. This is
  // just a convenience.
  fb::RuntimeStageT runtime_stage;
  runtime_stage.entrypoint = entrypoint_;
  const auto stage = ToStage(stage_);
  if (!stage.has_value()) {
    VALIDATION_LOG << "Invalid runtime stage.";
    return nullptr;
  }
  runtime_stage.stage = stage.value();
  const auto target_platform = ToTargetPlatform(target_platform_);
  if (!target_platform.has_value()) {
    VALIDATION_LOG << "Invalid target platform for runtime stage.";
    return nullptr;
  }
  runtime_stage.target_platform = target_platform.value();
  if (!shader_) {
    VALIDATION_LOG << "No shader specified for runtime stage.";
    return nullptr;
  }
  if (shader_->GetSize() > 0u) {
    runtime_stage.shader = {shader_->GetMapping(),
                            shader_->GetMapping() + shader_->GetSize()};
  }
  // It is not an error for the SkSL to be ommitted.
  if (sksl_->GetSize() > 0u) {
    runtime_stage.sksl = {sksl_->GetMapping(),
                          sksl_->GetMapping() + sksl_->GetSize()};
  }
  for (const auto& uniform : uniforms_) {
    auto desc = std::make_unique<fb::UniformDescriptionT>();
 
    desc->name = uniform.name;
    if (desc->name.empty()) {
      VALIDATION_LOG << "Uniform name cannot be empty.";
      return nullptr;
    }
    desc->location = uniform.location;
    desc->rows = uniform.rows;
    desc->columns = uniform.columns;
    auto uniform_type = ToType(uniform.type);
    if (!uniform_type.has_value()) {
      VALIDATION_LOG << "Invalid uniform type for runtime stage.";
      return nullptr;
    }
    desc->type = uniform_type.value();
    desc->bit_width = uniform.bit_width;
    if (uniform.array_elements.has_value()) {
      desc->array_elements = uniform.array_elements.value();
    }
 
    runtime_stage.uniforms.emplace_back(std::move(desc));
  }
  auto builder = std::make_shared<flatbuffers::FlatBufferBuilder>();
  builder->Finish(fb::RuntimeStage::Pack(*builder.get(), &runtime_stage),
                  fb::RuntimeStageIdentifier());
  return std::make_shared<fml::NonOwnedMapping>(builder->GetBufferPointer(),
                                                builder->GetSize(),
                                                [builder](auto, auto) {});
}

References impeller::compiler::ToStage(), impeller::compiler::ToTargetPlatform(), impeller::compiler::ToType(), and VALIDATION_LOG.

SetShaderData()

void impeller::compiler::RuntimeStageData::SetShaderData

(

std::shared_ptr< fml::Mapping >

shader

)

Definition at line 31 of file runtime_stage_data.cc.

                                                                     {
  shader_ = std::move(shader);
}

SetSkSLData()

void impeller::compiler::RuntimeStageData::SetSkSLData

(

std::shared_ptr< fml::Mapping >

sksl

)

Definition at line 35 of file runtime_stage_data.cc.

                                                                 {
  sksl_ = std::move(sksl);
}

---

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

• impeller/compiler/runtime_stage_data.h
• impeller/compiler/runtime_stage_data.cc