impeller::compiler::ShaderBundleData Class Reference

#include <shader_bundle_data.h>

Classes
struct	ShaderUniformStruct
struct	ShaderUniformStructField
struct	ShaderUniformTexture

Public Member Functions
	ShaderBundleData (std::string entrypoint, spv::ExecutionModel stage, TargetPlatform target_platform)
	~ShaderBundleData ()
void	AddUniformStruct (ShaderUniformStruct uniform_struct)
void	AddUniformTexture (ShaderUniformTexture uniform_texture)
void	AddInputDescription (InputDescription input)
void	SetShaderData (std::shared_ptr< fml::Mapping > shader)
void	SetSkSLData (std::shared_ptr< fml::Mapping > sksl)
std::unique_ptr< fb::shaderbundle::BackendShaderT >	CreateFlatbuffer () const

Detailed Description

Definition at line 18 of file shader_bundle_data.h.

Constructor & Destructor Documentation

ShaderBundleData()

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

Definition at line 16 of file shader_bundle_data.cc.

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

~ShaderBundleData()

impeller::compiler::ShaderBundleData::~ShaderBundleData ( )

default

Member Function Documentation

AddInputDescription()

void impeller::compiler::ShaderBundleData::AddInputDescription

(

InputDescription

input

)

Definition at line 33 of file shader_bundle_data.cc.

                                                                 {
  inputs_.emplace_back(std::move(input));
}

AddUniformStruct()

void impeller::compiler::ShaderBundleData::AddUniformStruct

(

ShaderUniformStruct

uniform_struct

)

Definition at line 25 of file shader_bundle_data.cc.

                                                                          {
  uniform_structs_.emplace_back(std::move(uniform_struct));
}

AddUniformTexture()

void impeller::compiler::ShaderBundleData::AddUniformTexture

(

ShaderUniformTexture

uniform_texture

)

Definition at line 29 of file shader_bundle_data.cc.

                                                                             {
  uniform_textures_.emplace_back(std::move(uniform_texture));
}

CreateFlatbuffer()

std::unique_ptr< fb::shaderbundle::BackendShaderT > impeller::compiler::ShaderBundleData::CreateFlatbuffer

(

)

const

Definition at line 144 of file shader_bundle_data.cc.

                                         {
  auto shader_bundle = std::make_unique<fb::shaderbundle::BackendShaderT>();
 
  // The high level object API is used here for writing to the buffer. This is
  // just a convenience.
  shader_bundle->entrypoint = entrypoint_;
  const auto stage = ToStage(stage_);
  if (!stage.has_value()) {
    VALIDATION_LOG << "Invalid shader bundle.";
    return nullptr;
  }
  shader_bundle->stage = stage.value();
  // This field is ignored, so just set it to anything.
  if (!shader_) {
    VALIDATION_LOG << "No shader specified for shader bundle.";
    return nullptr;
  }
  if (shader_->GetSize() > 0u) {
    shader_bundle->shader = {shader_->GetMapping(),
                             shader_->GetMapping() + shader_->GetSize()};
  }
  for (const auto& uniform : uniform_structs_) {
    auto desc = std::make_unique<fb::shaderbundle::ShaderUniformStructT>();
 
    desc->name = uniform.name;
    if (desc->name.empty()) {
      VALIDATION_LOG << "Uniform name cannot be empty.";
      return nullptr;
    }
    desc->ext_res_0 = uniform.ext_res_0;
    desc->set = uniform.set;
    desc->binding = uniform.binding;
    desc->size_in_bytes = uniform.size_in_bytes;
 
    for (const auto& field : uniform.fields) {
      auto field_desc =
          std::make_unique<fb::shaderbundle::ShaderUniformStructFieldT>();
      field_desc->name = field.name;
      auto type = ToUniformType(field.type);
      if (!type.has_value()) {
        VALIDATION_LOG << " Invalid shader type " << field.type << ".";
        return nullptr;
      }
      field_desc->type = type.value();
      field_desc->offset_in_bytes = field.offset_in_bytes;
      field_desc->element_size_in_bytes = field.element_size_in_bytes;
      field_desc->total_size_in_bytes = field.total_size_in_bytes;
      field_desc->array_elements = field.array_elements.value_or(0);
      desc->fields.push_back(std::move(field_desc));
    }
 
    shader_bundle->uniform_structs.emplace_back(std::move(desc));
  }
 
  for (const auto& texture : uniform_textures_) {
    auto desc = std::make_unique<fb::shaderbundle::ShaderUniformTextureT>();
    desc->name = texture.name;
    if (desc->name.empty()) {
      VALIDATION_LOG << "Uniform name cannot be empty.";
      return nullptr;
    }
    desc->ext_res_0 = texture.ext_res_0;
    desc->set = texture.set;
    desc->binding = texture.binding;
    shader_bundle->uniform_textures.emplace_back(std::move(desc));
  }
 
  for (const auto& input : inputs_) {
    auto desc = std::make_unique<fb::shaderbundle::ShaderInputT>();
 
    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;
 
    shader_bundle->inputs.emplace_back(std::move(desc));
  }
 
  return shader_bundle;
}

References impeller::compiler::ToInputType(), impeller::compiler::ToStage(), impeller::compiler::ToUniformType(), type, and VALIDATION_LOG.

SetShaderData()

void impeller::compiler::ShaderBundleData::SetShaderData

(

std::shared_ptr< fml::Mapping >

shader

)

Definition at line 37 of file shader_bundle_data.cc.

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

SetSkSLData()

void impeller::compiler::ShaderBundleData::SetSkSLData

(

std::shared_ptr< fml::Mapping >

sksl

)

---

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

• impeller/compiler/shader_bundle_data.h
• impeller/compiler/shader_bundle_data.cc