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::RuntimeStagesT >	CreateFlatbuffer () const
std::shared_ptr< fml::Mapping >	CreateJsonMapping () const
std::shared_ptr< fml::Mapping >	CreateMapping () const

Detailed Description

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

Referenced by impeller::compiler::GenerateShaderFB(), and impeller::compiler::OutputIPLR().

CreateFlatbuffer()

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

(

)

const

Definition at line 296 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 = 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();
      }
 
      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));
    }
    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;
}

References impeller::kMetal, impeller::kOpenGLES, impeller::kSkSL, impeller::kVulkan, impeller::compiler::ToInputType(), impeller::compiler::ToStage(), impeller::compiler::ToUniformType(), and VALIDATION_LOG.

Referenced by CreateMapping(), and impeller::compiler::GenerateShaderFB().

CreateJsonMapping()

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

(

)

const

Definition at line 219 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;
 
      if (uniform.array_elements.has_value()) {
        uniform_object[kUniformArrayElementsKey] =
            uniform.array_elements.value();
      } else {
        uniform_object[kUniformArrayElementsKey] = 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) {});
}

References impeller::compiler::kEntrypointKey, impeller::compiler::kShaderKey, impeller::compiler::kStageKey, 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::RuntimeStageBackendToString(), impeller::compiler::ToJsonStage(), impeller::compiler::ToJsonType(), and VALIDATION_LOG.

Referenced by impeller::compiler::OutputIPLR().

CreateMapping()

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

(

)

const

Definition at line 387 of file runtime_stage_data.cc.

                                                                {
  auto runtime_stages = CreateFlatbuffer();
  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) {});
}

References CreateFlatbuffer().

Referenced by impeller::compiler::OutputIPLR().

---

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

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