impeller::ShaderArchive Class Reference

#include <shader_archive.h>

Public Member Functions
	ShaderArchive (ShaderArchive &&)
	~ShaderArchive ()
size_t	GetShaderCount () const
std::shared_ptr< fml::Mapping >	GetMapping (ArchiveShaderType type, std::string name) const
size_t	IterateAllShaders (const std::function< bool(ArchiveShaderType type, const std::string &name, const std::shared_ptr< fml::Mapping > &mapping)> &) const

Static Public Member Functions
static absl::StatusOr< ShaderArchive >	Create (std::shared_ptr< fml::Mapping > payload)

Detailed Description

Definition at line 19 of file shader_archive.h.

Constructor & Destructor Documentation

ShaderArchive()

impeller::ShaderArchive::ShaderArchive ( ShaderArchive &&  )

default

Referenced by Create().

~ShaderArchive()

impeller::ShaderArchive::~ShaderArchive ( )

default

Member Function Documentation

Create()

absl::StatusOr< ShaderArchive > impeller::ShaderArchive::Create ( std::shared_ptr< fml::Mapping >  payload )

static

Definition at line 29 of file shader_archive.cc.

                                       {
  if (!payload || payload->GetMapping() == nullptr) {
    return absl::InvalidArgumentError("Shader mapping was absent.");
  }
 
  if (!fb::ShaderArchiveBufferHasIdentifier(payload->GetMapping())) {
    return absl::InvalidArgumentError("Invalid shader magic.");
  }
 
  auto shader_archive = fb::GetShaderArchive(payload->GetMapping());
  if (!shader_archive) {
    return absl::InvalidArgumentError("Could not read shader archive.");
  }
 
  const auto version = shader_archive->format_version();
  const auto expected =
      static_cast<uint32_t>(fb::ShaderArchiveFormatVersion::kVersion);
  if (version != expected) {
    std::stringstream stream;
    stream << "Unsupported shader archive format version. Expected: "
           << expected << ", Got: " << version;
    return absl::InvalidArgumentError(stream.str());
  }
 
  Shaders shaders;
  if (auto items = shader_archive->items()) {
    for (auto i = items->begin(), end = items->end(); i != end; i++) {
      ShaderKey key;
      key.name = i->name()->str();
      key.type = ToShaderType(i->stage());
      shaders[key] = std::make_shared<fml::NonOwnedMapping>(
          i->mapping()->Data(), i->mapping()->size(), [payload](auto, auto) {
            // The pointers are into the base payload. Instead of copying the
            // data, just hold onto the payload.
          });
    }
  }
 
  return ShaderArchive(std::move(payload), std::move(shaders));
}

References end, ShaderArchive(), and impeller::ToShaderType().

Referenced by impeller::testing::TEST().

GetMapping()

std::shared_ptr< fml::Mapping > impeller::ShaderArchive::GetMapping	(	ArchiveShaderType	type,
		std::string	name
	)		const

Definition at line 83 of file shader_archive.cc.

                          {
  ShaderKey key;
  key.type = type;
  key.name = std::move(name);
  auto found = shaders_.find(key);
  return found == shaders_.end() ? nullptr : found->second;
}

References type.

GetShaderCount()

size_t impeller::ShaderArchive::GetShaderCount

(

)

const

Definition at line 79 of file shader_archive.cc.

                                           {
  return shaders_.size();
}

IterateAllShaders()

size_t impeller::ShaderArchive::IterateAllShaders

(

const std::function< bool(ArchiveShaderType type, const std::string &name, const std::shared_ptr< fml::Mapping > &mapping)> &

callback

)

const

Definition at line 93 of file shader_archive.cc.

                        {
  if (!callback) {
    return 0u;
  }
  size_t count = 0u;
  for (const auto& shader : shaders_) {
    count++;
    if (!callback(shader.first.type, shader.first.name, shader.second)) {
      break;
    }
  }
  return count;
}

---

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

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