impeller::ShaderArchiveWriter Class Reference

#include <shader_archive_writer.h>

Public Member Functions
	ShaderArchiveWriter ()
	~ShaderArchiveWriter ()
bool	AddShaderAtPath (const std::string &path)
bool	AddShader (ArchiveShaderType type, std::string name, std::shared_ptr< fml::Mapping > mapping)
std::shared_ptr< fml::Mapping >	CreateMapping () const

Detailed Description

Definition at line 17 of file shader_archive_writer.h.

Constructor & Destructor Documentation

ShaderArchiveWriter()

impeller::ShaderArchiveWriter::ShaderArchiveWriter ( )

default

~ShaderArchiveWriter()

impeller::ShaderArchiveWriter::~ShaderArchiveWriter ( )

default

Member Function Documentation

AddShader()

bool impeller::ShaderArchiveWriter::AddShader	(	ArchiveShaderType	type,
		std::string	name,
		std::shared_ptr< fml::Mapping >	mapping
	)

Definition at line 74 of file shader_archive_writer.cc.

                                                                       {
  if (name.empty() || !mapping || mapping->GetMapping() == nullptr) {
    return false;
  }
 
  shader_descriptions_.emplace_back(
      ShaderDescription{type, std::move(name), std::move(mapping)});
  return true;
}

AddShaderAtPath()

bool impeller::ShaderArchiveWriter::AddShaderAtPath

(

const std::string &

path

)

Definition at line 31 of file shader_archive_writer.cc.

                                                                   {
  std::filesystem::path path(std_path);
 
  if (path.stem().empty()) {
    FML_LOG(ERROR) << "File path stem was empty for " << path;
    return false;
  }
 
  if (path.extension() != ".gles" && path.extension() != ".vkspv") {
    FML_LOG(ERROR) << "File path doesn't have a known shader extension "
                   << path;
    return false;
  }
 
  // Get rid of .gles
  path = path.replace_extension();
 
  auto shader_type = InferShaderTypefromFileExtension(path.extension());
 
  if (!shader_type.has_value()) {
    FML_LOG(ERROR) << "Could not infer shader type from file extension: "
                   << path.extension().string();
    return false;
  }
 
  // Get rid of the shader type extension (.vert, .frag, etc..).
  path = path.replace_extension();
 
  const auto shader_name = path.stem().string();
  if (shader_name.empty()) {
    FML_LOG(ERROR) << "Shader name was empty.";
    return false;
  }
 
  auto file_mapping = fml::FileMapping::CreateReadOnly(std_path);
  if (!file_mapping) {
    FML_LOG(ERROR) << "File doesn't exist at path: " << path;
    return false;
  }
 
  return AddShader(shader_type.value(), shader_name, std::move(file_mapping));
}

CreateMapping()

std::shared_ptr< fml::Mapping > impeller::ShaderArchiveWriter::CreateMapping

(

)

const

Definition at line 98 of file shader_archive_writer.cc.

                                                                   {
  fb::ShaderArchiveT shader_archive;
  for (const auto& shader_description : shader_descriptions_) {
    auto mapping = shader_description.mapping;
    if (!mapping) {
      return nullptr;
    }
    auto desc = std::make_unique<fb::ShaderBlobT>();
    desc->name = shader_description.name;
    desc->stage = ToStage(shader_description.type);
    desc->mapping = {mapping->GetMapping(),
                     mapping->GetMapping() + mapping->GetSize()};
    shader_archive.items.emplace_back(std::move(desc));
  }
  auto builder = std::make_shared<flatbuffers::FlatBufferBuilder>();
  builder->Finish(fb::ShaderArchive::Pack(*builder.get(), &shader_archive),
                  fb::ShaderArchiveIdentifier());
  return std::make_shared<fml::NonOwnedMapping>(builder->GetBufferPointer(),
                                                builder->GetSize(),
                                                [builder](auto, auto) {});
}

---

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

• impeller/shader_archive/shader_archive_writer.h
• impeller/shader_archive/shader_archive_writer.cc