impeller::compiler::SPIRVCompiler Class Reference

#include <spirv_compiler.h>

Public Member Functions
	SPIRVCompiler (const SourceOptions &options, std::shared_ptr< const fml::Mapping > sources)
	~SPIRVCompiler ()
std::shared_ptr< fml::Mapping >	CompileToSPV (std::stringstream &error_stream, const shaderc::CompileOptions &spirv_options) const

Detailed Description

Definition at line 57 of file spirv_compiler.h.

Constructor & Destructor Documentation

SPIRVCompiler()

impeller::compiler::SPIRVCompiler::SPIRVCompiler	(	const SourceOptions &	options,
		std::shared_ptr< const fml::Mapping >	sources
	)

Definition at line 15 of file spirv_compiler.cc.

    : options_(options), sources_(std::move(sources)) {}

~SPIRVCompiler()

impeller::compiler::SPIRVCompiler::~SPIRVCompiler ( )

default

Member Function Documentation

CompileToSPV()

std::shared_ptr< fml::Mapping > impeller::compiler::SPIRVCompiler::CompileToSPV	(	std::stringstream &	error_stream,
		const shaderc::CompileOptions &	spirv_options
	)		const

Definition at line 21 of file spirv_compiler.cc.

                                                      {
  if (!sources_ || sources_->GetMapping() == nullptr) {
    COMPILER_ERROR(stream) << "Invalid sources for SPIRV Compiler.";
    return nullptr;
  }
 
  shaderc::Compiler spv_compiler;
  if (!spv_compiler.IsValid()) {
    COMPILER_ERROR(stream) << "Could not initialize the "
                           << SourceLanguageToString(options_.source_language)
                           << " to SPIRV compiler.";
    return nullptr;
  }
 
  const auto shader_kind = ToShaderCShaderKind(options_.type);
 
  if (shader_kind == shaderc_shader_kind::shaderc_glsl_infer_from_source) {
    COMPILER_ERROR(stream) << "Could not figure out shader stage.";
    return nullptr;
  }
 
  auto result = std::make_shared<shaderc::SpvCompilationResult>(
      spv_compiler.CompileGlslToSpv(
          reinterpret_cast<const char*>(sources_->GetMapping()),  // source_text
          sources_->GetSize(),                // source_text_size
          shader_kind,                        // shader_kind
          options_.file_name.c_str(),         // input_file_name
          options_.entry_point_name.c_str(),  // entry_point_name
          spirv_options                       // options
          ));
  if (result->GetCompilationStatus() !=
      shaderc_compilation_status::shaderc_compilation_status_success) {
    COMPILER_ERROR(stream) << SourceLanguageToString(options_.source_language)
                           << " to SPIRV failed; "
                           << ShaderCErrorToString(
                                  result->GetCompilationStatus())
                           << ". " << result->GetNumErrors() << " error(s) and "
                           << result->GetNumWarnings() << " warning(s).";
    // It should normally be enough to check that there are errors or warnings,
    // but some cases result in no errors or warnings and still have an error
    // message. If there's a message we should print it.
    if (result->GetNumErrors() > 0 || result->GetNumWarnings() > 0 ||
        !result->GetErrorMessage().empty()) {
      COMPILER_ERROR_NO_PREFIX(stream) << result->GetErrorMessage();
    }
    return nullptr;
  }
 
  if (!result) {
    COMPILER_ERROR(stream) << "Could not fetch SPIRV from compile job.";
    return nullptr;
  }
 
  const auto data_length = (result->cend() - result->cbegin()) *
                           sizeof(decltype(result)::element_type::element_type);
 
  return std::make_unique<fml::NonOwnedMapping>(
      reinterpret_cast<const uint8_t*>(result->cbegin()),  //
      data_length,                                         //
      [result](auto, auto) {}                              //
  );
}

---

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

• impeller/compiler/spirv_compiler.h
• impeller/compiler/spirv_compiler.cc