impeller::compiler::RuntimeStageData Class Reference

#include <runtime_stage_data.h>

Classes
struct	Shader

Public Member Functions
	RuntimeStageData ()
	~RuntimeStageData ()
void	AddShader (const std::shared_ptr< Shader > &data)
std::unique_ptr< fb::RuntimeStageT >	CreateStageFlatbuffer (impeller::RuntimeStageBackend backend) const
std::unique_ptr< fb::RuntimeStagesT >	CreateMultiStageFlatbuffer () const
std::shared_ptr< fml::Mapping >	CreateJsonMapping () const
std::shared_ptr< fml::Mapping >	CreateMapping () const

Detailed Description

Definition at line 21 of file runtime_stage_data.h.

Constructor & Destructor Documentation

RuntimeStageData()

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

default

~RuntimeStageData()

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

default

Member Function Documentation

AddShader()

void impeller::compiler::RuntimeStageData::AddShader

(

const std::shared_ptr< Shader > &

data

)

Definition at line 27 of file runtime_stage_data.cc.

                                                                  {
  FML_DCHECK(data);
  FML_DCHECK(data_.find(data->backend) == data_.end());
  data_[data->backend] = data;
}

CreateJsonMapping()

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

(

)

const

Definition at line 210 of file runtime_stage_data.cc.

                                                                    {
  // Runtime Stage Data JSON format
  //   {
  //      "sksl": {
  //        "stage": 0,
  //        "entrypoint": "",
  //        "shader": "",
  //        "uniforms": [
  //          {
  //             "name": "..",
  //             "location": 0,
  //             "type": 0,
  //             "rows": 0,
  //             "columns": 0,
  //             "bit_width": 0,
  //             "array_elements": 0,
  //          }
  //        ]
  //      },
  //      "metal": ...
  //   },
  nlohmann::json root;
 
  for (const auto& kvp : data_) {
    nlohmann::json platform_object;
 
    const auto stage = ToJsonStage(kvp.second->stage);
    if (!stage.has_value()) {
      VALIDATION_LOG << "Invalid runtime stage.";
      return nullptr;
    }
    platform_object[kStageKey] = static_cast<uint32_t>(stage.value());
    platform_object[kEntrypointKey] = kvp.second->entrypoint;
 
    if (kvp.second->shader->GetSize() > 0u) {
      std::string shader(
          reinterpret_cast<const char*>(kvp.second->shader->GetMapping()),
          kvp.second->shader->GetSize());
      platform_object[kShaderKey] = shader.c_str();
    }
 
    auto& uniforms = platform_object[kUniformsKey] = nlohmann::json::array_t{};
    for (const auto& uniform : kvp.second->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;
      uniform_object[kUniformArrayElementsKey] =
          uniform.array_elements.value_or(0);
 
      uniforms.push_back(uniform_object);
    }
 
    root[RuntimeStageBackendToString(kvp.first)] = platform_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) {});
}

CreateMapping()

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

(

)

const

Definition at line 392 of file runtime_stage_data.cc.

                                                                {
  auto runtime_stages = CreateMultiStageFlatbuffer();
  if (!runtime_stages) {
    return nullptr;
  }
 
  auto builder = std::make_shared<flatbuffers::FlatBufferBuilder>();
  builder->Finish(fb::RuntimeStages::Pack(*builder.get(), runtime_stages.get()),
                  fb::RuntimeStagesIdentifier());
  return std::make_shared<fml::NonOwnedMapping>(builder->GetBufferPointer(),
                                                builder->GetSize(),
                                                [builder](auto, auto) {});
}

CreateMultiStageFlatbuffer()

std::unique_ptr< fb::RuntimeStagesT > impeller::compiler::RuntimeStageData::CreateMultiStageFlatbuffer

(

)

const

Definition at line 367 of file runtime_stage_data.cc.

                                                   {
  // The high level object API is used here for writing to the buffer. This is
  // just a convenience.
  auto runtime_stages = std::make_unique<fb::RuntimeStagesT>();
 
  for (const auto& kvp : data_) {
    auto runtime_stage = CreateStageFlatbuffer(kvp.first);
    switch (kvp.first) {
      case RuntimeStageBackend::kSkSL:
        runtime_stages->sksl = std::move(runtime_stage);
        break;
      case RuntimeStageBackend::kMetal:
        runtime_stages->metal = std::move(runtime_stage);
        break;
      case RuntimeStageBackend::kOpenGLES:
        runtime_stages->opengles = std::move(runtime_stage);
        break;
      case RuntimeStageBackend::kVulkan:
        runtime_stages->vulkan = std::move(runtime_stage);
        break;
    }
  }
  return runtime_stages;
}

CreateStageFlatbuffer()

std::unique_ptr< fb::RuntimeStageT > impeller::compiler::RuntimeStageData::CreateStageFlatbuffer

(

impeller::RuntimeStageBackend

backend

)

const

Definition at line 283 of file runtime_stage_data.cc.

                                               {
  auto kvp = data_.find(backend);
  if (kvp == data_.end()) {
    return nullptr;
  }
 
  auto runtime_stage = std::make_unique<fb::RuntimeStageT>();
  runtime_stage->entrypoint = kvp->second->entrypoint;
  const auto stage = ToStage(kvp->second->stage);
  if (!stage.has_value()) {
    VALIDATION_LOG << "Invalid runtime stage.";
    return nullptr;
  }
  runtime_stage->stage = stage.value();
  if (!kvp->second->shader) {
    VALIDATION_LOG << "No shader specified for runtime stage.";
    return nullptr;
  }
  if (kvp->second->shader->GetSize() > 0u) {
    runtime_stage->shader = {
        kvp->second->shader->GetMapping(),
        kvp->second->shader->GetMapping() + kvp->second->shader->GetSize()};
  }
  for (const auto& uniform : kvp->second->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 = ToUniformType(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();
    }
 
    for (const auto& byte_type : uniform.struct_layout) {
      desc->struct_layout.push_back(static_cast<fb::StructByteType>(byte_type));
    }
    desc->struct_float_count = uniform.struct_float_count;
 
    runtime_stage->uniforms.emplace_back(std::move(desc));
  }
 
  for (const auto& input : kvp->second->inputs) {
    auto desc = std::make_unique<fb::StageInputT>();
 
    desc->name = input.name;
 
    if (desc->name.empty()) {
      VALIDATION_LOG << "Stage input name cannot be empty.";
      return nullptr;
    }
    desc->location = input.location;
    desc->set = input.set;
    desc->binding = input.binding;
    auto input_type = ToInputType(input.type);
    if (!input_type.has_value()) {
      VALIDATION_LOG << "Invalid uniform type for runtime stage.";
      return nullptr;
    }
    desc->type = input_type.value();
    desc->bit_width = input.bit_width;
    desc->vec_size = input.vec_size;
    desc->columns = input.columns;
    desc->offset = input.offset;
 
    runtime_stage->inputs.emplace_back(std::move(desc));
  }
 
  return runtime_stage;
}

---

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

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