impeller::compiler::Switches Class Reference

#include <switches.h>

Public Member Functions
	Switches ()
	~Switches ()
	Switches (const fml::CommandLine &command_line)
bool	AreValid (std::ostream &explain) const
std::vector< TargetPlatform >	PlatformsToCompile () const
	A vector containing at least one valid platform.
TargetPlatform	SelectDefaultTargetPlatform () const
SourceOptions	CreateSourceOptions (std::optional< TargetPlatform > target_platform=std::nullopt) const

Static Public Member Functions
static void	PrintHelp (std::ostream &stream)

Public Attributes
std::shared_ptr< fml::UniqueFD >	working_directory = nullptr
std::vector< IncludeDir >	include_directories = {}
std::string	source_file_name = ""
SourceType	input_type = SourceType::kUnknown
std::string	sl_file_name = ""
bool	iplr = false
std::string	shader_bundle = ""
std::string	spirv_file_name = ""
std::string	reflection_json_name = ""
std::string	reflection_header_name = ""
std::string	reflection_cc_name = ""
std::string	depfile_path = ""
std::vector< std::string >	defines = {}
bool	json_format = false
SourceLanguage	source_language = SourceLanguage::kUnknown
uint32_t	gles_language_version = 0
std::string	metal_version = ""
std::string	entry_point = ""
bool	use_half_textures = false
bool	require_framebuffer_fetch = false

Detailed Description

Definition at line 21 of file switches.h.

Constructor & Destructor Documentation

Switches() [1/2]

impeller::compiler::Switches::Switches ( )

default

~Switches()

impeller::compiler::Switches::~Switches ( )

default

Switches() [2/2]

impeller::compiler::Switches::Switches ( const fml::CommandLine &  command_line )

explicit

Definition at line 159 of file switches.cc.

    : working_directory(std::make_shared<fml::UniqueFD>(fml::OpenDirectory(
          Utf8FromPath(std::filesystem::current_path()).c_str(),
          false,  // create if necessary,
          fml::FilePermission::kRead))),
      source_file_name(command_line.GetOptionValueWithDefault("input", "")),
      input_type(SourceTypeFromCommandLine(command_line)),
      sl_file_name(command_line.GetOptionValueWithDefault("sl", "")),
      iplr(command_line.HasOption("iplr")),
      shader_bundle(
          command_line.GetOptionValueWithDefault("shader-bundle", "")),
      spirv_file_name(command_line.GetOptionValueWithDefault("spirv", "")),
      reflection_json_name(
          command_line.GetOptionValueWithDefault("reflection-json", "")),
      reflection_header_name(
          command_line.GetOptionValueWithDefault("reflection-header", "")),
      reflection_cc_name(
          command_line.GetOptionValueWithDefault("reflection-cc", "")),
      depfile_path(command_line.GetOptionValueWithDefault("depfile", "")),
      json_format(command_line.HasOption("json")),
      gles_language_version(
          stoi(command_line.GetOptionValueWithDefault("gles-language-version",
                                                      "0"))),
      metal_version(
          command_line.GetOptionValueWithDefault("metal-version", "1.2")),
      entry_point(
          command_line.GetOptionValueWithDefault("entry-point", "main")),
      use_half_textures(command_line.HasOption("use-half-textures")),
      require_framebuffer_fetch(
          command_line.HasOption("require-framebuffer-fetch")),
      target_platform_(TargetPlatformFromCommandLine(command_line)),
      runtime_stages_(RuntimeStagesFromCommandLine(command_line)) {
  auto language = ToLowerCase(
      command_line.GetOptionValueWithDefault("source-language", "glsl"));
 
  source_language = ToSourceLanguage(language);
 
  if (!working_directory || !working_directory->is_valid()) {
    return;
  }
 
  for (const auto& include_dir_path : command_line.GetOptionValues("include")) {
    if (!include_dir_path.data()) {
      continue;
    }
 
    // fml::OpenDirectoryReadOnly for Windows doesn't handle relative paths
    // beginning with `../` well, so we build an absolute path.
 
    // Get the current working directory as a utf8 encoded string.
    // Note that the `include_dir_path` is already utf8 encoded, and so we
    // mustn't attempt to double-convert it to utf8 lest multi-byte characters
    // will become mangled.
    std::filesystem::path include_dir_absolute;
    if (std::filesystem::path(include_dir_path).is_absolute()) {
      include_dir_absolute = std::filesystem::path(include_dir_path);
    } else {
      auto cwd = Utf8FromPath(std::filesystem::current_path());
      include_dir_absolute = std::filesystem::absolute(
          std::filesystem::path(cwd) / include_dir_path);
    }
 
    auto dir = std::make_shared<fml::UniqueFD>(fml::OpenDirectoryReadOnly(
        *working_directory, include_dir_absolute.string().c_str()));
    if (!dir || !dir->is_valid()) {
      continue;
    }
 
    IncludeDir dir_entry;
    dir_entry.name = include_dir_path;
    dir_entry.dir = std::move(dir);
 
    include_directories.emplace_back(std::move(dir_entry));
  }
 
  for (const auto& define : command_line.GetOptionValues("define")) {
    defines.emplace_back(define);
  }
}

Member Function Documentation

AreValid()

bool impeller::compiler::Switches::AreValid

(

std::ostream &

explain

)

const

Definition at line 239 of file switches.cc.

                                                 {
  // When producing a shader bundle, all flags related to single shader inputs
  // and outputs such as `--input` and `--spirv-file-name` are ignored. Instead,
  // input files are read from the shader bundle spec and a single flatbuffer
  // containing all compiled shaders and reflection state is output to `--sl`.
  const bool shader_bundle_mode = !shader_bundle.empty();
 
  bool valid = true;
  if (target_platform_ == TargetPlatform::kUnknown && runtime_stages_.empty() &&
      !shader_bundle_mode) {
    explain << "Either a target platform was not specified, or no runtime "
               "stages were specified."
            << std::endl;
    valid = false;
  }
 
  if (source_language == SourceLanguage::kUnknown && !shader_bundle_mode) {
    explain << "Invalid source language type." << std::endl;
    valid = false;
  }
 
  if (!working_directory || !working_directory->is_valid()) {
    explain << "Could not open the working directory: \""
            << Utf8FromPath(std::filesystem::current_path()).c_str() << "\""
            << std::endl;
    valid = false;
  }
 
  if (source_file_name.empty() && !shader_bundle_mode) {
    explain << "Input file name was empty." << std::endl;
    valid = false;
  }
 
  if (sl_file_name.empty()) {
    explain << "Target shading language file name was empty." << std::endl;
    valid = false;
  }
 
  if (spirv_file_name.empty() && !shader_bundle_mode) {
    explain << "Spirv file name was empty." << std::endl;
    valid = false;
  }
 
  if (iplr && shader_bundle_mode) {
    explain << "--iplr and --shader-bundle flag cannot be specified at the "
               "same time"
            << std::endl;
    valid = false;
  }
 
  return valid;
}

CreateSourceOptions()

SourceOptions impeller::compiler::Switches::CreateSourceOptions

(

std::optional< TargetPlatform >

target_platform = std::nullopt

)

const

Definition at line 307 of file switches.cc.

                                                       {
  SourceOptions options;
  options.target_platform =
      target_platform.value_or(SelectDefaultTargetPlatform());
  options.source_language = source_language;
  if (input_type == SourceType::kUnknown) {
    options.type = SourceTypeFromFileName(source_file_name);
  } else {
    options.type = input_type;
  }
  options.working_directory = working_directory;
  options.file_name = source_file_name;
  options.include_dirs = include_directories;
  options.defines = defines;
  options.entry_point_name = EntryPointFunctionNameFromSourceName(
      source_file_name, options.type, options.source_language, entry_point);
  options.json_format = json_format;
  options.gles_language_version = gles_language_version;
  options.metal_version = metal_version;
  options.use_half_textures = use_half_textures;
  options.require_framebuffer_fetch = require_framebuffer_fetch;
  return options;
}

PlatformsToCompile()

std::vector< TargetPlatform > impeller::compiler::Switches::PlatformsToCompile

(

)

const

A vector containing at least one valid platform.

Definition at line 292 of file switches.cc.

                                                             {
  if (target_platform_ == TargetPlatform::kUnknown) {
    return runtime_stages_;
  }
  return {target_platform_};
}

PrintHelp()

void impeller::compiler::Switches::PrintHelp ( std::ostream &  stream )

static

Definition at line 41 of file switches.cc.

                                           {
  // clang-format off
  const std::string optional_prefix =          "[optional]          ";
  const std::string optional_multiple_prefix = "[optional,multiple] ";
  // clang-format on
 
  stream << std::endl;
  stream << "ImpellerC is an offline shader processor and reflection engine."
         << std::endl;
  stream << "---------------------------------------------------------------"
         << std::endl;
  stream << "Expected invocation is:" << std::endl << std::endl;
  stream << "./impellerc <One platform or multiple runtime stages> "
            "--input=<source_file> --sl=<sl_output_file> <optional arguments>"
         << std::endl
         << std::endl;
 
  stream << "Valid platforms are:" << std::endl << std::endl;
  stream << "One of [";
  for (const auto& platform : kKnownPlatforms) {
    stream << " --" << platform.first;
  }
  stream << " ]" << std::endl << std::endl;
 
  stream << "Valid runtime stages are:" << std::endl << std::endl;
  stream << "At least one of [";
  for (const auto& platform : kKnownRuntimeStages) {
    stream << " --" << platform.first;
  }
  stream << " ]" << std::endl << std::endl;
 
  stream << "Optional arguments:" << std::endl << std::endl;
  stream << optional_prefix
         << "--spirv=<spirv_output_file> (ignored for --shader-bundle)"
         << std::endl;
  stream << optional_prefix << "--input-type={";
  for (const auto& source_type : kKnownSourceTypes) {
    stream << source_type.first << ", ";
  }
  stream << "}" << std::endl;
  stream << optional_prefix << "--source-language=glsl|hlsl (default: glsl)"
         << std::endl;
  stream << optional_prefix
         << "--entry-point=<entry_point_name> (default: main; "
            "ignored for glsl)"
         << std::endl;
  stream << optional_prefix
         << "--iplr (causes --sl file to be emitted in "
            "iplr format)"
         << std::endl;
  stream << optional_prefix
         << "--shader-bundle=<bundle_spec> (causes --sl "
            "file to be "
            "emitted in Flutter GPU's shader bundle format)"
         << std::endl;
  stream << optional_prefix << "--reflection-json=<reflection_json_file>"
         << std::endl;
  stream << optional_prefix << "--reflection-header=<reflection_header_file>"
         << std::endl;
  stream << optional_prefix << "--reflection-cc=<reflection_cc_file>"
         << std::endl;
  stream << optional_multiple_prefix << "--include=<include_directory>"
         << std::endl;
  stream << optional_multiple_prefix << "--define=<define>" << std::endl;
  stream << optional_prefix << "--depfile=<depfile_path>" << std::endl;
  stream << optional_prefix << "--gles-language-version=<number>" << std::endl;
  stream << optional_prefix << "--json" << std::endl;
  stream << optional_prefix
         << "--use-half-textures (force openGL semantics when "
            "targeting metal)"
         << std::endl;
  stream << optional_prefix << "--require-framebuffer-fetch" << std::endl;
}

SelectDefaultTargetPlatform()

TargetPlatform impeller::compiler::Switches::SelectDefaultTargetPlatform

(

)

const

Definition at line 299 of file switches.cc.

                                                           {
  if (target_platform_ == TargetPlatform::kUnknown &&
      !runtime_stages_.empty()) {
    return runtime_stages_.front();
  }
  return target_platform_;
}

Member Data Documentation

defines

std::vector<std::string> impeller::compiler::Switches::defines = {}

Definition at line 38 of file switches.h.

{};

depfile_path

std::string impeller::compiler::Switches::depfile_path = ""

Definition at line 37 of file switches.h.

entry_point

std::string impeller::compiler::Switches::entry_point = ""

Definition at line 43 of file switches.h.

gles_language_version

uint32_t impeller::compiler::Switches::gles_language_version = 0

Definition at line 41 of file switches.h.

include_directories

std::vector<IncludeDir> impeller::compiler::Switches::include_directories = {}

Definition at line 24 of file switches.h.

{};

input_type

SourceType impeller::compiler::Switches::input_type = SourceType::kUnknown

Definition at line 26 of file switches.h.

iplr

bool impeller::compiler::Switches::iplr = false

Definition at line 31 of file switches.h.

json_format

bool impeller::compiler::Switches::json_format = false

Definition at line 39 of file switches.h.

metal_version

std::string impeller::compiler::Switches::metal_version = ""

Definition at line 42 of file switches.h.

reflection_cc_name

std::string impeller::compiler::Switches::reflection_cc_name = ""

Definition at line 36 of file switches.h.

reflection_header_name

std::string impeller::compiler::Switches::reflection_header_name = ""

Definition at line 35 of file switches.h.

reflection_json_name

std::string impeller::compiler::Switches::reflection_json_name = ""

Definition at line 34 of file switches.h.

require_framebuffer_fetch

bool impeller::compiler::Switches::require_framebuffer_fetch = false

Definition at line 45 of file switches.h.

shader_bundle

std::string impeller::compiler::Switches::shader_bundle = ""

Definition at line 32 of file switches.h.

sl_file_name

std::string impeller::compiler::Switches::sl_file_name = ""

The raw shader file output by the compiler. For –iplr and –shader-bundle modes, this is used as the filename for the output flatbuffer output.

Definition at line 30 of file switches.h.

source_file_name

std::string impeller::compiler::Switches::source_file_name = ""

Definition at line 25 of file switches.h.

source_language

SourceLanguage impeller::compiler::Switches::source_language = SourceLanguage::kUnknown

Definition at line 40 of file switches.h.

spirv_file_name

std::string impeller::compiler::Switches::spirv_file_name = ""

Definition at line 33 of file switches.h.

use_half_textures

bool impeller::compiler::Switches::use_half_textures = false

Definition at line 44 of file switches.h.

working_directory

std::shared_ptr<fml::UniqueFD> impeller::compiler::Switches::working_directory = nullptr

Definition at line 23 of file switches.h.

---

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

• impeller/compiler/switches.h
• impeller/compiler/switches.cc