#include <switches.h>

Public Member Functions
	Switches ()

	~Switches ()

	Switches (const fml::CommandLine &command_line)

bool	AreValid (std::ostream &explain) const

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

Public Attributes
TargetPlatform	target_platform = TargetPlatform::kUnknown

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	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

Detailed Description

Definition at line 20 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 )

Definition at line 113 of file switches.cc.

     : target_platform(TargetPlatformFromCommandLine(command_line)),
       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")),
       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")) {
   auto language =
       command_line.GetOptionValueWithDefault("source-language", "glsl");
   std::transform(language.begin(), language.end(), language.begin(),
                  [](char x) { return std::tolower(x); });
   if (language == "glsl") {
     source_language = SourceLanguage::kGLSL;
   } else if (language == "hlsl") {
     source_language = SourceLanguage::kHLSL;
   }
  
   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);
   }
 }

References defines, impeller::compiler::IncludeDir::dir, include_directories, impeller::compiler::kGLSL, impeller::compiler::kHLSL, impeller::compiler::IncludeDir::name, source_language, impeller::compiler::Utf8FromPath(), and working_directory.

Member Function Documentation

◆ AreValid()

bool impeller::compiler::Switches::AreValid ( std::ostream & explain ) const

Definition at line 193 of file switches.cc.

                                                  {
   bool valid = true;
   if (target_platform == TargetPlatform::kUnknown) {
     explain << "The target platform (only one) was not specified." << std::endl;
     valid = false;
   }
  
   if (source_language == SourceLanguage::kUnknown) {
     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()) {
     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()) {
     explain << "Spirv file name was empty." << std::endl;
     valid = false;
   }
   return valid;
 }

References impeller::compiler::kUnknown, sl_file_name, source_file_name, source_language, spirv_file_name, target_platform, impeller::compiler::Utf8FromPath(), and working_directory.

Referenced by impeller::compiler::Main(), and impeller::compiler::testing::TEST().

◆ PrintHelp()

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

static

Definition at line 39 of file switches.cc.

                                            {
   stream << std::endl;
   stream << "ImpellerC is an offline shader processor and reflection engine."
          << std::endl;
   stream << "---------------------------------------------------------------"
          << std::endl;
   stream << "Valid Argument are:" << std::endl;
   stream << "One of [";
   for (const auto& platform : kKnownPlatforms) {
     stream << " --" << platform.first;
   }
   stream << " ]" << std::endl;
   stream << "--input=<source_file>" << std::endl;
   stream << "[optional] --input-type={";
   for (const auto& source_type : kKnownSourceTypes) {
     stream << source_type.first << ", ";
   }
   stream << "}" << std::endl;
   stream << "--sl=<sl_output_file>" << std::endl;
   stream << "--spirv=<spirv_output_file>" << std::endl;
   stream << "[optional] --source-language=glsl|hlsl (default: glsl)"
          << std::endl;
   stream << "[optional] --entry-point=<entry_point_name> (default: main; "
             "ignored for glsl)"
          << std::endl;
   stream << "[optional] --iplr (causes --sl file to be emitted in iplr format)"
          << std::endl;
   stream << "[optional] --reflection-json=<reflection_json_file>" << std::endl;
   stream << "[optional] --reflection-header=<reflection_header_file>"
          << std::endl;
   stream << "[optional] --reflection-cc=<reflection_cc_file>" << std::endl;
   stream << "[optional,multiple] --include=<include_directory>" << std::endl;
   stream << "[optional,multiple] --define=<define>" << std::endl;
   stream << "[optional] --depfile=<depfile_path>" << std::endl;
   stream << "[optional] --gles-language-version=<number>" << std::endl;
   stream << "[optional] --json" << std::endl;
   stream << "[optional] --use-half-textures (force openGL semantics when "
             "targeting metal)"
          << std::endl;
 }