| Flutter Impeller |

switches.cc
Go to the documentation of this file.
1 // Copyright 2013 The Flutter Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "impeller/compiler/switches.h"
6
7 #include <algorithm>
8 #include <cctype>
9 #include <filesystem>
10 #include <map>
11
12 #include "flutter/fml/file.h"
13 #include "fml/command_line.h"
14 #include "impeller/compiler/types.h"
15 #include "impeller/compiler/utilities.h"
16
17 namespace impeller {
18 namespace compiler {
19
20 static const std::map<std::string, TargetPlatform> kKnownPlatforms = {
21 {"metal-desktop", TargetPlatform::kMetalDesktop},
22 {"metal-ios", TargetPlatform::kMetalIOS},
23 {"vulkan", TargetPlatform::kVulkan},
24 {"opengl-es", TargetPlatform::kOpenGLES},
25 {"opengl-desktop", TargetPlatform::kOpenGLDesktop},
26 };
27
28 static const std::map<std::string, TargetPlatform> kKnownRuntimeStages = {
29 {"sksl", TargetPlatform::kSkSL},
30 {"runtime-stage-metal", TargetPlatform::kRuntimeStageMetal},
31 {"runtime-stage-gles", TargetPlatform::kRuntimeStageGLES},
32 {"runtime-stage-gles3", TargetPlatform::kRuntimeStageGLES3},
33 {"runtime-stage-vulkan", TargetPlatform::kRuntimeStageVulkan},
34 };
35
36 static const std::map<std::string, SourceType> kKnownSourceTypes = {
37 {"vert", SourceType::kVertexShader},
38 {"frag", SourceType::kFragmentShader},
39 {"comp", SourceType::kComputeShader},
40 };
41
42 void Switches::PrintHelp(std::ostream& stream) {
43 // clang-format off
44 const std::string optional_prefix = "[optional] ";
45 const std::string optional_multiple_prefix = "[optional,multiple] ";
46 // clang-format on
47
48 stream << std::endl;
49 stream << "ImpellerC is an offline shader processor and reflection engine."
50 << std::endl;
51 stream << "---------------------------------------------------------------"
52 << std::endl;
53 stream << "Expected invocation is:" << std::endl << std::endl;
54 stream << "./impellerc <One platform or multiple runtime stages> "
55 "--input=<source_file> --sl=<sl_output_file> <optional arguments>"
56 << std::endl
57 << std::endl;
58
59 stream << "Valid platforms are:" << std::endl << std::endl;
60 stream << "One of [";
61 for (const auto& platform : kKnownPlatforms) {
62 stream << " --" << platform.first;
63 }
64 stream << " ]" << std::endl << std::endl;
65
66 stream << "Valid runtime stages are:" << std::endl << std::endl;
67 stream << "At least one of [";
68 for (const auto& platform : kKnownRuntimeStages) {
69 stream << " --" << platform.first;
70 }
71 stream << " ]" << std::endl << std::endl;
72
73 stream << "Optional arguments:" << std::endl << std::endl;
74 stream << optional_prefix
75 << "--spirv=<spirv_output_file> (ignored for --shader-bundle)"
76 << std::endl;
77 stream << optional_prefix << "--input-type={";
78 for (const auto& source_type : kKnownSourceTypes) {
79 stream << source_type.first << ", ";
80 }
81 stream << "}" << std::endl;
82 stream << optional_prefix << "--source-language=glsl|hlsl (default: glsl)"
83 << std::endl;
84 stream << optional_prefix
85 << "--entry-point=<entry_point_name> (default: main; "
86 "ignored for glsl)"
87 << std::endl;
88 stream << optional_prefix
89 << "--iplr (causes --sl file to be emitted in "
90 "iplr format)"
91 << std::endl;
92 stream << optional_prefix
93 << "--shader-bundle=<bundle_spec> (causes --sl "
94 "file to be "
95 "emitted in Flutter GPU's shader bundle format)"
96 << std::endl;
97 stream << optional_prefix << "--reflection-json=<reflection_json_file>"
98 << std::endl;
99 stream << optional_prefix << "--reflection-header=<reflection_header_file>"
100 << std::endl;
101 stream << optional_prefix << "--reflection-cc=<reflection_cc_file>"
102 << std::endl;
103 stream << optional_multiple_prefix << "--include=<include_directory>"
104 << std::endl;
105 stream << optional_multiple_prefix << "--define=<define>" << std::endl;
106 stream << optional_prefix << "--depfile=<depfile_path>" << std::endl;
107 stream << optional_prefix << "--gles-language-version=<number>" << std::endl;
108 stream << optional_prefix << "--json" << std::endl;
109 stream << optional_prefix
110 << "--use-half-textures (force openGL semantics when "
111 "targeting metal)"
112 << std::endl;
113 stream << optional_prefix << "--require-framebuffer-fetch" << std::endl;
114 }
115
116 Switches::Switches() = default;
117
118 Switches::~Switches() = default;
119
120 static TargetPlatform TargetPlatformFromCommandLine(
121 const fml::CommandLine& command_line) {
122 auto target = TargetPlatform::kUnknown;
123 for (const auto& platform : kKnownPlatforms) {
124 if (command_line.HasOption(platform.first)) {
125 // If the platform has already been determined, the caller may have
126 // specified multiple platforms. This is an error and only one must be
127 // selected.
128 if (target != TargetPlatform::kUnknown) {
129 return TargetPlatform::kUnknown;
130 }
131 target = platform.second;
132 // Keep going to detect duplicates.
133 }
134 }
135 return target;
136 }
137
138 static std::vector<TargetPlatform> RuntimeStagesFromCommandLine(
139 const fml::CommandLine& command_line) {
140 std::vector<TargetPlatform> stages;
141 for (const auto& platform : kKnownRuntimeStages) {
142 if (command_line.HasOption(platform.first)) {
143 stages.push_back(platform.second);
144 }
145 }
146 return stages;
147 }
148
149 static SourceType SourceTypeFromCommandLine(
150 const fml::CommandLine& command_line) {
151 auto source_type_option =
152 command_line.GetOptionValueWithDefault("input-type", "");
153 auto source_type_search = kKnownSourceTypes.find(source_type_option);
154 if (source_type_search == kKnownSourceTypes.end()) {
155 return SourceType::kUnknown;
156 }
157 return source_type_search->second;
158 }
159
160 Switches::Switches(const fml::CommandLine& command_line)
161 : working_directory(std::make_shared<fml::UniqueFD>(fml::OpenDirectory(
162 Utf8FromPath(std::filesystem::current_path()).c_str(),
163 false, // create if necessary,
164 fml::FilePermission::kRead))),
165 source_file_name(command_line.GetOptionValueWithDefault("input", "")),
166 input_type(SourceTypeFromCommandLine(command_line)),
167 sl_file_name(command_line.GetOptionValueWithDefault("sl", "")),
168 iplr(command_line.HasOption("iplr")),
169 shader_bundle(
170 command_line.GetOptionValueWithDefault("shader-bundle", "")),
171 spirv_file_name(command_line.GetOptionValueWithDefault("spirv", "")),
172 reflection_json_name(
173 command_line.GetOptionValueWithDefault("reflection-json", "")),
174 reflection_header_name(
175 command_line.GetOptionValueWithDefault("reflection-header", "")),
176 reflection_cc_name(
177 command_line.GetOptionValueWithDefault("reflection-cc", "")),
178 depfile_path(command_line.GetOptionValueWithDefault("depfile", "")),
179 json_format(command_line.HasOption("json")),
180 gles_language_version(
181 stoi(command_line.GetOptionValueWithDefault("gles-language-version",
182 "0"))),
183 metal_version(
184 command_line.GetOptionValueWithDefault("metal-version", "1.2")),
185 entry_point(
186 command_line.GetOptionValueWithDefault("entry-point", "main")),
187 use_half_textures(command_line.HasOption("use-half-textures")),
188 require_framebuffer_fetch(
189 command_line.HasOption("require-framebuffer-fetch")),
190 target_platform_(TargetPlatformFromCommandLine(command_line)),
191 runtime_stages_(RuntimeStagesFromCommandLine(command_line)) {
192 auto language = ToLowerCase(
193 command_line.GetOptionValueWithDefault("source-language", "glsl"));
194
195 source_language = ToSourceLanguage(language);
196
197 if (!working_directory || !working_directory->is_valid()) {
198 return;
199 }
200
201 for (const auto& include_dir_path : command_line.GetOptionValues("include")) {
202 if (!include_dir_path.data()) {
203 continue;
204 }
205
206 // fml::OpenDirectoryReadOnly for Windows doesn't handle relative paths
207 // beginning with `../` well, so we build an absolute path.
208
209 // Get the current working directory as a utf8 encoded string.
210 // Note that the `include_dir_path` is already utf8 encoded, and so we
211 // mustn't attempt to double-convert it to utf8 lest multi-byte characters
212 // will become mangled.
213 std::filesystem::path include_dir_absolute;
214 if (std::filesystem::path(include_dir_path).is_absolute()) {
215 include_dir_absolute = std::filesystem::path(include_dir_path);
216 } else {
217 auto cwd = Utf8FromPath(std::filesystem::current_path());
218 include_dir_absolute = std::filesystem::absolute(
219 std::filesystem::path(cwd) / include_dir_path);
220 }
221
222 auto dir = std::make_shared<fml::UniqueFD>(fml::OpenDirectoryReadOnly(
223 *working_directory, include_dir_absolute.string().c_str()));
224 if (!dir || !dir->is_valid()) {
225 continue;
226 }
227
228 IncludeDir dir_entry;
229 dir_entry.name = include_dir_path;
230 dir_entry.dir = std::move(dir);
231
232 include_directories.emplace_back(std::move(dir_entry));
233 }
234
235 for (const auto& define : command_line.GetOptionValues("define")) {
236 defines.emplace_back(define);
237 }
238 }
239
240 bool Switches::AreValid(std::ostream& explain) const {
241 // When producing a shader bundle, all flags related to single shader inputs
242 // and outputs such as `--input` and `--spirv-file-name` are ignored. Instead,
243 // input files are read from the shader bundle spec and a single flatbuffer
244 // containing all compiled shaders and reflection state is output to `--sl`.
245 const bool shader_bundle_mode = !shader_bundle.empty();
246
247 bool valid = true;
248 if (target_platform_ == TargetPlatform::kUnknown && runtime_stages_.empty() &&
249 !shader_bundle_mode) {
250 explain << "Either a target platform was not specified, or no runtime "
251 "stages were specified."
252 << std::endl;
253 valid = false;
254 }
255
256 if (source_language == SourceLanguage::kUnknown && !shader_bundle_mode) {
257 explain << "Invalid source language type." << std::endl;
258 valid = false;
259 }
260
261 if (!working_directory || !working_directory->is_valid()) {
262 explain << "Could not open the working directory: \""
263 << Utf8FromPath(std::filesystem::current_path()).c_str() << "\""
264 << std::endl;
265 valid = false;
266 }
267
268 if (source_file_name.empty() && !shader_bundle_mode) {
269 explain << "Input file name was empty." << std::endl;
270 valid = false;
271 }
272
273 if (sl_file_name.empty()) {
274 explain << "Target shading language file name was empty." << std::endl;
275 valid = false;
276 }
277
278 if (spirv_file_name.empty() && !shader_bundle_mode) {
279 explain << "Spirv file name was empty." << std::endl;
280 valid = false;
281 }
282
283 if (iplr && shader_bundle_mode) {
284 explain << "--iplr and --shader-bundle flag cannot be specified at the "
285 "same time"
286 << std::endl;
287 valid = false;
288 }
289
290 return valid;
291 }
292
293 std::vector<TargetPlatform> Switches::PlatformsToCompile() const {
294 if (target_platform_ == TargetPlatform::kUnknown) {
295 return runtime_stages_;
296 }
297 return {target_platform_};
298 }
299
300 TargetPlatform Switches::SelectDefaultTargetPlatform() const {
301 if (target_platform_ == TargetPlatform::kUnknown &&
302 !runtime_stages_.empty()) {
303 return runtime_stages_.front();
304 }
305 return target_platform_;
306 }
307
308 SourceOptions Switches::CreateSourceOptions(
309 std::optional<TargetPlatform> target_platform) const {
310 SourceOptions options;
311 options.target_platform =
312 target_platform.value_or(SelectDefaultTargetPlatform());
313 options.source_language = source_language;
314 if (input_type == SourceType::kUnknown) {
315 options.type = SourceTypeFromFileName(source_file_name);
316 } else {
317 options.type = input_type;
318 }
319 options.working_directory = working_directory;
320 options.file_name = source_file_name;
321 options.include_dirs = include_directories;
322 options.defines = defines;
323 options.entry_point_name = EntryPointFunctionNameFromSourceName(
324 source_file_name, options.type, options.source_language, entry_point);
325 options.json_format = json_format;
326 options.gles_language_version = gles_language_version;
327 options.metal_version = metal_version;
328 options.use_half_textures = use_half_textures;
329 options.require_framebuffer_fetch = require_framebuffer_fetch;
330 return options;
331 }
332
333 } // namespace compiler
334 } // namespace impeller
impeller::compiler::Switches::require_framebuffer_fetch
bool require_framebuffer_fetch
Definition: switches.h:45
impeller::compiler::Switches::PlatformsToCompile
std::vector< TargetPlatform > PlatformsToCompile() const
A vector containing at least one valid platform.
Definition: switches.cc:293
impeller::compiler::Switches::use_half_textures
bool use_half_textures
Definition: switches.h:44
impeller::compiler::Switches::source_language
SourceLanguage source_language
Definition: switches.h:40
impeller::compiler::Switches::metal_version
std::string metal_version
Definition: switches.h:42
impeller::compiler::Switches::gles_language_version
uint32_t gles_language_version
Definition: switches.h:41
impeller::compiler::Switches::sl_file_name
std::string sl_file_name
Definition: switches.h:30
impeller::compiler::Switches::entry_point
std::string entry_point
Definition: switches.h:43
impeller::compiler::Switches::shader_bundle
std::string shader_bundle
Definition: switches.h:32
impeller::compiler::Switches::defines
std::vector< std::string > defines
Definition: switches.h:38
impeller::compiler::Switches::working_directory
std::shared_ptr< fml::UniqueFD > working_directory
Definition: switches.h:23
impeller::compiler::Switches::CreateSourceOptions
SourceOptions CreateSourceOptions(std::optional< TargetPlatform > target_platform=std::nullopt) const
Definition: switches.cc:308
impeller::compiler::Switches::spirv_file_name
std::string spirv_file_name
Definition: switches.h:33
impeller::compiler::Switches::input_type
SourceType input_type
Definition: switches.h:26
impeller::compiler::Switches::AreValid
bool AreValid(std::ostream &explain) const
Definition: switches.cc:240
impeller::compiler::Switches::PrintHelp
static void PrintHelp(std::ostream &stream)
Definition: switches.cc:42
impeller::compiler::Switches::Switches
Switches()
impeller::compiler::Switches::iplr
bool iplr
Definition: switches.h:31
impeller::compiler::Switches::source_file_name
std::string source_file_name
Definition: switches.h:25
impeller::compiler::Switches::json_format
bool json_format
Definition: switches.h:39
impeller::compiler::Switches::include_directories
std::vector< IncludeDir > include_directories
Definition: switches.h:24
impeller::compiler::Switches::~Switches
~Switches()
impeller::compiler::Switches::SelectDefaultTargetPlatform
TargetPlatform SelectDefaultTargetPlatform() const
Definition: switches.cc:300
switches.h
types.h
fml
Definition: metal_screenshot.h:16
impeller::compiler::ToLowerCase
std::string ToLowerCase(std::string_view string)
Definition: utilities.cc:62
impeller::compiler::SourceType
SourceType
Definition: types.h:21
impeller::compiler::SourceType::kUnknown
@ kUnknown
impeller::compiler::SourceType::kFragmentShader
@ kFragmentShader
impeller::compiler::SourceType::kVertexShader
@ kVertexShader
impeller::compiler::SourceType::kComputeShader
@ kComputeShader
impeller::compiler::kKnownPlatforms
static const std::map< std::string, TargetPlatform > kKnownPlatforms
Definition: switches.cc:20
impeller::compiler::SourceLanguage::kUnknown
@ kUnknown
impeller::compiler::RuntimeStagesFromCommandLine
static std::vector< TargetPlatform > RuntimeStagesFromCommandLine(const fml::CommandLine &command_line)
Definition: switches.cc:138
impeller::compiler::SourceTypeFromFileName
SourceType SourceTypeFromFileName(const std::string &file_name)
Definition: types.cc:30
impeller::compiler::EntryPointFunctionNameFromSourceName
std::string EntryPointFunctionNameFromSourceName(const std::string &file_name, SourceType type, SourceLanguage source_language, const std::string &entry_point_name)
Definition: types.cc:113
impeller::compiler::kKnownRuntimeStages
static const std::map< std::string, TargetPlatform > kKnownRuntimeStages
Definition: switches.cc:28
impeller::compiler::Utf8FromPath
std::string Utf8FromPath(const std::filesystem::path &path)
Converts a native format path to a utf8 string.
Definition: utilities.cc:30
impeller::compiler::TargetPlatformFromCommandLine
static TargetPlatform TargetPlatformFromCommandLine(const fml::CommandLine &command_line)
Definition: switches.cc:120
impeller::compiler::ToSourceLanguage
SourceLanguage ToSourceLanguage(const std::string &source_language)
Definition: types.cc:64
impeller::compiler::kKnownSourceTypes
static const std::map< std::string, SourceType > kKnownSourceTypes
Definition: switches.cc:36
impeller::compiler::SourceTypeFromCommandLine
static SourceType SourceTypeFromCommandLine(const fml::CommandLine &command_line)
Definition: switches.cc:149
impeller::compiler::TargetPlatform
TargetPlatform
Definition: types.h:28
impeller::compiler::TargetPlatform::kRuntimeStageMetal
@ kRuntimeStageMetal
impeller::compiler::TargetPlatform::kOpenGLES
@ kOpenGLES
impeller::compiler::TargetPlatform::kUnknown
@ kUnknown
impeller::compiler::TargetPlatform::kRuntimeStageVulkan
@ kRuntimeStageVulkan
impeller::compiler::TargetPlatform::kRuntimeStageGLES3
@ kRuntimeStageGLES3
impeller::compiler::TargetPlatform::kVulkan
@ kVulkan
impeller::compiler::TargetPlatform::kMetalDesktop
@ kMetalDesktop
impeller::compiler::TargetPlatform::kMetalIOS
@ kMetalIOS
impeller::compiler::TargetPlatform::kSkSL
@ kSkSL
impeller::compiler::TargetPlatform::kOpenGLDesktop
@ kOpenGLDesktop
impeller::compiler::TargetPlatform::kRuntimeStageGLES
@ kRuntimeStageGLES
impeller
Definition: allocation.cc:12
std
Definition: comparable.h:95
impeller::compiler::IncludeDir
Definition: include_dir.h:16
impeller::compiler::IncludeDir::dir
std::shared_ptr< fml::UniqueFD > dir
Definition: include_dir.h:17
impeller::compiler::IncludeDir::name
std::string name
Definition: include_dir.h:18
impeller::compiler::SourceOptions
Definition: source_options.h:20
impeller::compiler::SourceOptions::gles_language_version
uint32_t gles_language_version
Definition: source_options.h:28
impeller::compiler::SourceOptions::use_half_textures
bool use_half_textures
Whether half-precision textures should be supported, requiring opengl semantics. Only used on metal t...
Definition: source_options.h:35
impeller::compiler::SourceOptions::source_language
SourceLanguage source_language
Definition: source_options.h:23
impeller::compiler::SourceOptions::include_dirs
std::vector< IncludeDir > include_dirs
Definition: source_options.h:25
impeller::compiler::SourceOptions::file_name
std::string file_name
Definition: source_options.h:26
impeller::compiler::SourceOptions::require_framebuffer_fetch
bool require_framebuffer_fetch
Whether the GLSL framebuffer fetch extension will be required.
Definition: source_options.h:40
impeller::compiler::SourceOptions::entry_point_name
std::string entry_point_name
Definition: source_options.h:27
impeller::compiler::SourceOptions::target_platform
TargetPlatform target_platform
Definition: source_options.h:22
impeller::compiler::SourceOptions::type
SourceType type
Definition: source_options.h:21
impeller::compiler::SourceOptions::working_directory
std::shared_ptr< fml::UniqueFD > working_directory
Definition: source_options.h:24
impeller::compiler::SourceOptions::metal_version
std::string metal_version
Definition: source_options.h:31
impeller::compiler::SourceOptions::json_format
bool json_format
Definition: source_options.h:30
impeller::compiler::SourceOptions::defines
std::vector< std::string > defines
Definition: source_options.h:29
utilities.h