| Flutter Impeller |

Namespaces | Classes | Enumerations | Functions | Variables
impeller::compiler Namespace Reference

## Namespaces
| testing

## Classes
class | AutoLogger
class | Compiler
struct | CompilerBackend
class | CompilerSkSL
struct | IncludeDir
class | Includer
struct | IncluderData
struct | KnownType
class | Reflector
class | RuntimeStageData
struct | SourceOptions
class | SPIRVCompiler
struct | SPIRVCompilerOptions
struct | SPIRVCompilerSourceProfile
struct | SPIRVCompilerTargetEnv
struct | StructMember
struct | Switches
struct | UniformDescription
class | UniqueIncluder
| Wraps a shared includer so unique includers may be created to satisfy the shaderc API. This is a simple proxy object and does nothing. More...
struct | VertexType

## Enumerations
enum | SourceType { SourceType::kUnknown, SourceType::kVertexShader, SourceType::kFragmentShader, SourceType::kTessellationControlShader, SourceType::kTessellationEvaluationShader, SourceType::kComputeShader }
enum | TargetPlatform { TargetPlatform::kUnknown, TargetPlatform::kMetalDesktop, TargetPlatform::kMetalIOS, TargetPlatform::kOpenGLES, TargetPlatform::kOpenGLDesktop, TargetPlatform::kVulkan, TargetPlatform::kRuntimeStageMetal, TargetPlatform::kRuntimeStageGLES, TargetPlatform::kRuntimeStageVulkan, TargetPlatform::kSkSL }
enum | SourceLanguage { SourceLanguage::kUnknown, SourceLanguage::kGLSL, SourceLanguage::kHLSL }

## Functions
static uint32_t | ParseMSLVersion (const std::string &msl_version)
static CompilerBackend | CreateMSLCompiler (const spirv_cross::ParsedIR &ir, const SourceOptions &source_options, std::optional< uint32_t > msl_version_override={})
static CompilerBackend | CreateVulkanCompiler (const spirv_cross::ParsedIR &ir, const SourceOptions &source_options)
static CompilerBackend | CreateGLSLCompiler (const spirv_cross::ParsedIR &ir, const SourceOptions &source_options)
static CompilerBackend | CreateSkSLCompiler (const spirv_cross::ParsedIR &ir, const SourceOptions &source_options)
static bool | EntryPointMustBeNamedMain (TargetPlatform platform)
static CompilerBackend | CreateCompiler (const spirv_cross::ParsedIR &ir, const SourceOptions &source_options)
static std::string | JoinStrings (std::vector< std::string > items, const std::string &separator)
static bool | SetPermissiveAccess (const std::filesystem::path &p)
bool | Main (const fml::CommandLine &command_line)
static std::string | BaseTypeToString (spirv_cross::SPIRType::BaseType type)
static std::string | ExecutionModelToString (spv::ExecutionModel model)
static std::string | StringToShaderStage (std::string str)
static std::string | ToString (CompilerBackend::Type type)
static std::string | TypeNameWithPaddingOfSize (size_t size)
static std::optional< KnownType > | ReadKnownScalarType (spirv_cross::SPIRType::BaseType type)
static size_t | GetReflectedStructSize (const std::vector< StructMember > &members)
| Get the reflected struct size. In the vast majority of the cases, this is the same as the declared struct size as given by the compiler. But, additional padding may need to be introduced after the end of the struct to keep in line with the alignment requirement of the individual struct members. This method figures out the actual size of the reflected struct that can be referenced in native code. More...
static VertexType | VertexTypeFromInputResource (const spirv_cross::Compiler &compiler, const spirv_cross::Resource *resource)
static std::optional< fb::Stage > | ToStage (spv::ExecutionModel stage)
static std::optional< uint32_t > | ToJsonStage (spv::ExecutionModel stage)
static std::optional< fb::TargetPlatform > | ToTargetPlatform (TargetPlatform platform)
static std::optional< uint32_t > | ToJsonTargetPlatform (TargetPlatform platform)
static std::optional< fb::UniformDataType > | ToType (spirv_cross::SPIRType::BaseType type)
static std::optional< uint32_t > | ToJsonType (spirv_cross::SPIRType::BaseType type)
static void | SetDefaultLimitations (shaderc::CompileOptions &compiler_opts)
static void | SetBindingBaseOffset (shaderc::CompileOptions &options)
void | report_and_exit (const std::string &msg)
static TargetPlatform | TargetPlatformFromCommandLine (const fml::CommandLine &command_line)
static SourceType | SourceTypeFromCommandLine (const fml::CommandLine &command_line)
static bool | StringEndWith (const std::string &string, const std::string &suffix)
SourceType | SourceTypeFromFileName (const std::string &file_name)
std::string | TargetPlatformToString (TargetPlatform platform)
std::string | SourceLanguageToString (SourceLanguage source_language)
std::string | EntryPointFunctionNameFromSourceName (const std::string &file_name, SourceType type, SourceLanguage source_language, const std::string &entry_point_name)
bool | TargetPlatformNeedsReflection (TargetPlatform platform)
std::string | ShaderCErrorToString (shaderc_compilation_status status)
shaderc_shader_kind | ToShaderCShaderKind (SourceType type)
spv::ExecutionModel | ToExecutionModel (SourceType type)
spirv_cross::CompilerMSL::Options::Platform | TargetPlatformToMSLPlatform (TargetPlatform platform)
std::string | SourceTypeToString (SourceType type)
std::string | TargetPlatformSLExtension (TargetPlatform platform)
bool | TargetPlatformIsOpenGL (TargetPlatform platform)
bool | TargetPlatformIsMetal (TargetPlatform platform)
bool | TargetPlatformIsVulkan (TargetPlatform platform)
bool | TargetPlatformBundlesSkSL (TargetPlatform platform)
std::string | Utf8FromPath (const std::filesystem::path &path)
| Converts a native format path to a utf8 string. More...
std::string | InferShaderNameFromPath (std::string_view path)
std::string | ConvertToCamelCase (std::string_view string)
std::string | ConvertToEntrypointName (std::string_view string)
| Ensure that the entrypoint name is a valid identifier in the target language. More...
bool | StringStartsWith (const std::string &target, const std::string &prefix)

## Variables
constexpr std::string_view | kReflectionHeaderTemplate
constexpr std::string_view | kReflectionCCTemplate
constexpr char | kExternalTexturePrefix [] = "SAMPLER_EXTERNAL_OES_"
static const char * | kStageKey = "stage"
static const char * | kTargetPlatformKey = "target_platform"
static const char * | kEntrypointKey = "entrypoint"
static const char * | kUniformsKey = "uniforms"
static const char * | kShaderKey = "sksl"
static const char * | kUniformNameKey = "name"
static const char * | kUniformLocationKey = "location"
static const char * | kUniformTypeKey = "type"
static const char * | kUniformRowsKey = "rows"
static const char * | kUniformColumnsKey = "columns"
static const char * | kUniformBitWidthKey = "bit_width"
static const char * | kUniformArrayElementsKey = "array_elements"
static const std::map< std::string, TargetPlatform > | kKnownPlatforms
static const std::map< std::string, SourceType > | kKnownSourceTypes

## Enumeration Type Documentation

## ◆ SourceLanguage

enum impeller::compiler::SourceLanguage
| strong

Enumerator
kUnknown |
kGLSL |
kHLSL |

Definition at line 41 of file types.h.

41 {
42 kUnknown,
43 kGLSL,
44 kHLSL,
45 };

## ◆ SourceType

enum impeller::compiler::SourceType
| strong

Enumerator
kUnknown |
kVertexShader |
kFragmentShader |
kTessellationControlShader |
kTessellationEvaluationShader |
kComputeShader |

Definition at line 19 of file types.h.

19 {
20 kUnknown,
21 kVertexShader,
22 kFragmentShader,
23 kTessellationControlShader,
24 kTessellationEvaluationShader,
25 kComputeShader,
26 };

## ◆ TargetPlatform

enum impeller::compiler::TargetPlatform
| strong

Enumerator
kUnknown |
kMetalDesktop |
kMetalIOS |
kOpenGLES |
kOpenGLDesktop |
kVulkan |
kRuntimeStageMetal |
kRuntimeStageGLES |
kRuntimeStageVulkan |
kSkSL |

Definition at line 28 of file types.h.

28 {
29 kUnknown,
30 kMetalDesktop,
31 kMetalIOS,
32 kOpenGLES,
33 kOpenGLDesktop,
34 kVulkan,
35 kRuntimeStageMetal,
36 kRuntimeStageGLES,
37 kRuntimeStageVulkan,
38 kSkSL,
39 };

## Function Documentation

## ◆ BaseTypeToString()

static std::string impeller::compiler::BaseTypeToString | ( | spirv_cross::SPIRType::BaseType | type | ) |
| static

Definition at line 29 of file reflector.cc.

29 {
30 using Type = spirv_cross::SPIRType::BaseType;
31 switch (type) {
32 case Type::Void:
33 return "ShaderType::kVoid";
34 case Type::Boolean:
35 return "ShaderType::kBoolean";
36 case Type::SByte:
37 return "ShaderType::kSignedByte";
38 case Type::UByte:
39 return "ShaderType::kUnsignedByte";
40 case Type::Short:
41 return "ShaderType::kSignedShort";
42 case Type::UShort:
43 return "ShaderType::kUnsignedShort";
44 case Type::Int:
45 return "ShaderType::kSignedInt";
46 case Type::UInt:
47 return "ShaderType::kUnsignedInt";
48 case Type::Int64:
49 return "ShaderType::kSignedInt64";
50 case Type::UInt64:
51 return "ShaderType::kUnsignedInt64";
52 case Type::AtomicCounter:
53 return "ShaderType::kAtomicCounter";
54 case Type::Half:
55 return "ShaderType::kHalfFloat";
56 case Type::Float:
57 return "ShaderType::kFloat";
58 case Type::Double:
59 return "ShaderType::kDouble";
60 case Type::Struct:
61 return "ShaderType::kStruct";
62 case Type::Image:
63 return "ShaderType::kImage";
64 case Type::SampledImage:
65 return "ShaderType::kSampledImage";
66 case Type::Sampler:
67 return "ShaderType::kSampler";
68 default:
69 return "ShaderType::kUnknown";
70 }
71 }

Referenced by VertexTypeFromInputResource().

## ◆ ConvertToCamelCase()

std::string impeller::compiler::ConvertToCamelCase | ( | std::string_view | string | ) |

Definition at line 23 of file utilities.cc.

23 {
24 if (string.empty()) {
25 return "";
26 }
27
28 std::stringstream stream;
29 bool next_upper = true;
30 for (size_t i = 0, count = string.length(); i < count; i++) {
31 auto ch = string.data()[i];
32 if (next_upper) {
33 next_upper = false;
34 stream << static_cast<char>(std::toupper(ch));
35 continue;
36 }
37 if (ch == '_') {
38 next_upper = true;
39 continue;
40 }
41 stream << ch;
42 }
43 return stream.str();
44 }

## ◆ ConvertToEntrypointName()

std::string impeller::compiler::ConvertToEntrypointName | ( | std::string_view | string | ) |

Ensure that the entrypoint name is a valid identifier in the target language.

Definition at line 46 of file utilities.cc.

46 {
47 if (string.empty()) {
48 return "";
49 }
50 std::stringstream stream;
51 // Append a prefix if the first character is not a letter.
52 if (!std::isalpha(string.data()[0])) {
53 stream << "i_";
54 }
55 for (size_t i = 0, count = string.length(); i < count; i++) {
56 auto ch = string.data()[i];
57 if (std::isalnum(ch) || ch == '_') {
58 stream << ch;
59 }
60 }
61 return stream.str();
62 }

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

## ◆ CreateCompiler()

static CompilerBackend impeller::compiler::CreateCompiler | ( | const spirv_cross::ParsedIR & | ir,
|  | const SourceOptions & | source_options
| ) |  |
| static

Definition at line 200 of file compiler.cc.

201 {
202 CompilerBackend compiler;
203 switch (source_options.target_platform) {
204 case TargetPlatform::kMetalDesktop:
205 case TargetPlatform::kMetalIOS:
206 case TargetPlatform::kRuntimeStageMetal:
207 compiler = CreateMSLCompiler(ir, source_options);
208 break;
209 case TargetPlatform::kVulkan:
210 case TargetPlatform::kRuntimeStageVulkan:
211 compiler = CreateVulkanCompiler(ir, source_options);
212 break;
213 case TargetPlatform::kUnknown:
214 case TargetPlatform::kOpenGLES:
215 case TargetPlatform::kOpenGLDesktop:
216 case TargetPlatform::kRuntimeStageGLES:
217 compiler = CreateGLSLCompiler(ir, source_options);
218 break;
219 case TargetPlatform::kSkSL:
220 compiler = CreateSkSLCompiler(ir, source_options);
221 }
222 if (!compiler) {
223 return {};
224 }
225 auto* backend = compiler.GetCompiler();
226 if (!EntryPointMustBeNamedMain(source_options.target_platform) &&
227 source_options.source_language == SourceLanguage::kGLSL) {
228 backend->rename_entry_point("main", source_options.entry_point_name,
229 ToExecutionModel(source_options.type));
230 }
231 return compiler;
232 }

References CreateGLSLCompiler(), CreateMSLCompiler(), CreateSkSLCompiler(), CreateVulkanCompiler(), impeller::compiler::SourceOptions::entry_point_name, EntryPointMustBeNamedMain(), impeller::compiler::CompilerBackend::GetCompiler(), kGLSL, kMetalDesktop, kMetalIOS, kOpenGLDesktop, kOpenGLES, kRuntimeStageGLES, kRuntimeStageMetal, kRuntimeStageVulkan, kSkSL, kUnknown, kVulkan, impeller::compiler::SourceOptions::source_language, impeller::compiler::SourceOptions::target_platform, ToExecutionModel(), and impeller::compiler::SourceOptions::type.

Referenced by impeller::compiler::Compiler::Compiler().

## ◆ CreateGLSLCompiler()

static CompilerBackend impeller::compiler::CreateGLSLCompiler | ( | const spirv_cross::ParsedIR & | ir,
|  | const SourceOptions & | source_options
| ) |  |
| static

Definition at line 129 of file compiler.cc.

130 {
131 auto gl_compiler = std::make_shared<spirv_cross::CompilerGLSL>(ir);
132
133 // Walk the variables and insert the external image extension if any of them
134 // begins with the external texture prefix. Unfortunately, we can't walk
135 // `gl_compiler->get_shader_resources().separate_samplers` until the compiler
136 // is further along.
137 //
138 // Unfortunately, we can't just let the shader author add this extension and
139 // use `samplerExternalOES` directly because compiling to spirv requires the
140 // source language profile to be at least 310 ES, but this extension is
141 // incompatible with ES 310+.
142 for (auto& id : ir.ids_for_constant_or_variable) {
143 if (StringStartsWith(ir.get_name(id), kExternalTexturePrefix)) {
144 gl_compiler->require_extension("GL_OES_EGL_image_external");
145 break;
146 }
147 }
148
149 spirv_cross::CompilerGLSL::Options sl_options;
150 sl_options.force_zero_initialized_variables = true;
151 sl_options.vertex.fixup_clipspace = true;
152 if (source_options.target_platform == TargetPlatform::kOpenGLES ||
153 source_options.target_platform == TargetPlatform::kRuntimeStageGLES) {
154 sl_options.version = source_options.gles_language_version > 0
155 ? source_options.gles_language_version
156 : 100;
157 sl_options.es = true;
158 gl_compiler->set_variable_type_remap_callback(
159 [&](const spirv_cross::SPIRType& type, const std::string& var_name,
160 std::string& name_of_type) {
161 if (StringStartsWith(var_name, kExternalTexturePrefix)) {
162 name_of_type = "samplerExternalOES";
163 }
164 });
165 } else {
166 sl_options.version = source_options.gles_language_version > 0
167 ? source_options.gles_language_version
168 : 120;
169 sl_options.es = false;
170 }
171 gl_compiler->set_common_options(sl_options);
172 return CompilerBackend(gl_compiler);
173 }

References impeller::compiler::SourceOptions::gles_language_version, kExternalTexturePrefix, kOpenGLES, kRuntimeStageGLES, StringStartsWith(), and impeller::compiler::SourceOptions::target_platform.

Referenced by CreateCompiler().

## ◆ CreateMSLCompiler()

static CompilerBackend impeller::compiler::CreateMSLCompiler | ( | const spirv_cross::ParsedIR & | ir,
|  | const SourceOptions & | source_options,
|  | std::optional< uint32_t > | msl_version_override = `{}`
| ) |  |
| static

Definition at line 50 of file compiler.cc.

53 {}) {
54 auto sl_compiler = std::make_shared<spirv_cross::CompilerMSL>(ir);
55 spirv_cross::CompilerMSL::Options sl_options;
56 sl_options.platform =
57 TargetPlatformToMSLPlatform(source_options.target_platform);
58 sl_options.msl_version = msl_version_override.value_or(
59 ParseMSLVersion(source_options.metal_version));
60 sl_options.ios_use_simdgroup_functions =
61 sl_options.is_ios() &&
62 sl_options.msl_version >=
63 spirv_cross::CompilerMSL::Options::make_msl_version(2, 4, 0);
64 sl_options.use_framebuffer_fetch_subpasses = true;
65 sl_compiler->set_msl_options(sl_options);
66
67 // Sort the float and sampler uniforms according to their declared/decorated
68 // order. For user authored fragment shaders, the API for setting uniform
69 // values uses the index of the uniform in the declared order. By default, the
70 // metal backend of spirv-cross will order uniforms according to usage. To fix
71 // this, we use the sorted order and the add_msl_resource_binding API to force
72 // the ordering to match the declared order. Note that while this code runs
73 // for all compiled shaders, it will only affect fragment shaders due to the
74 // specified stage.
75 auto floats =
76 SortUniforms(&ir, sl_compiler.get(), spirv_cross::SPIRType::Float);
77 auto images =
78 SortUniforms(&ir, sl_compiler.get(), spirv_cross::SPIRType::SampledImage);
79
80 uint32_t buffer_offset = 0;
81 uint32_t sampler_offset = 0;
82 for (auto& float_id : floats) {
83 sl_compiler->add_msl_resource_binding(
84 {.stage = spv::ExecutionModel::ExecutionModelFragment,
85 .basetype = spirv_cross::SPIRType::BaseType::Float,
86 .desc_set = sl_compiler->get_decoration(float_id,
87 spv::DecorationDescriptorSet),
88 .binding =
89 sl_compiler->get_decoration(float_id, spv::DecorationBinding),
90 .count = 1u,
91 .msl_buffer = buffer_offset});
92 buffer_offset++;
93 }
94 for (auto& image_id : images) {
95 sl_compiler->add_msl_resource_binding({
96 .stage = spv::ExecutionModel::ExecutionModelFragment,
97 .basetype = spirv_cross::SPIRType::BaseType::SampledImage,
98 .desc_set =
99 sl_compiler->get_decoration(image_id, spv::DecorationDescriptorSet),
100 .binding =
101 sl_compiler->get_decoration(image_id, spv::DecorationBinding),
102 .count = 1u,
103 // A sampled image is both an image and a sampler, so both
104 // offsets need to be set or depending on the partiular shader
105 // the bindings may be incorrect.
106 .msl_texture = sampler_offset,
107 .msl_sampler = sampler_offset,
108 });
109 sampler_offset++;
110 }
111
112 return CompilerBackend(sl_compiler);
113 }

Referenced by CreateCompiler(), and CreateVulkanCompiler().

## ◆ CreateSkSLCompiler()

static CompilerBackend impeller::compiler::CreateSkSLCompiler | ( | const spirv_cross::ParsedIR & | ir,
|  | const SourceOptions & | source_options
| ) |  |
| static

Definition at line 175 of file compiler.cc.

176 {
177 auto sksl_compiler = std::make_shared<CompilerSkSL>(ir);
178 return CompilerBackend(sksl_compiler);
179 }

Referenced by CreateCompiler().

## ◆ CreateVulkanCompiler()

static CompilerBackend impeller::compiler::CreateVulkanCompiler | ( | const spirv_cross::ParsedIR & | ir,
|  | const SourceOptions & | source_options
| ) |  |
| static

Definition at line 115 of file compiler.cc.

117 {
118 // TODO(dnfield): It seems like what we'd want is a CompilerGLSL with
119 // vulkan_semantics set to true, but that has regressed some things on GLES
120 // somehow. In the mean time, go back to using CompilerMSL, but set the Metal
121 // Language version to something really high so that we don't get weird
122 // complaints about using Metal features while trying to build Vulkan shaders.
123 // https://github.com/flutter/flutter/issues/123795
124 return CreateMSLCompiler(
125 ir, source_options,
126 spirv_cross::CompilerMSL::Options::make_msl_version(3, 0, 0));
127 }

References CreateMSLCompiler().

Referenced by CreateCompiler().

## ◆ EntryPointFunctionNameFromSourceName()

std::string impeller::compiler::EntryPointFunctionNameFromSourceName | ( | const std::string & | file_name,
|  | SourceType | type,
|  | SourceLanguage | source_language,
|  | const std::string & | entry_point_name
| ) |  |

Definition at line 90 of file types.cc.

94 {
95 if (source_language == SourceLanguage::kHLSL) {
96 return entry_point_name;
97 }
98
99 std::stringstream stream;
100 std::filesystem::path file_path(file_name);
101 stream << ConvertToEntrypointName(Utf8FromPath(file_path.stem())) << "_";
102 switch (type) {
103 case SourceType::kUnknown:
104 stream << "unknown";
105 break;
106 case SourceType::kVertexShader:
107 stream << "vertex";
108 break;
109 case SourceType::kFragmentShader:
110 stream << "fragment";
111 break;
112 case SourceType::kTessellationControlShader:
113 stream << "tess_control";
114 break;
115 case SourceType::kTessellationEvaluationShader:
116 stream << "tess_eval";
117 break;
118 case SourceType::kComputeShader:
119 stream << "compute";
120 break;
121 }
122 stream << "_main";
123 return stream.str();
124 }

References ConvertToEntrypointName(), kComputeShader, kFragmentShader, kHLSL, kTessellationControlShader, kTessellationEvaluationShader, kUnknown, kVertexShader, and Utf8FromPath().

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

## ◆ EntryPointMustBeNamedMain()

static bool impeller::compiler::EntryPointMustBeNamedMain | ( | TargetPlatform | platform | ) |
| static

Definition at line 181 of file compiler.cc.

181 {
182 switch (platform) {
183 case TargetPlatform::kUnknown:
184 FML_UNREACHABLE();
185 case TargetPlatform::kMetalDesktop:
186 case TargetPlatform::kMetalIOS:
187 case TargetPlatform::kVulkan:
188 case TargetPlatform::kRuntimeStageMetal:
189 case TargetPlatform::kRuntimeStageVulkan:
190 return false;
191 case TargetPlatform::kSkSL:
192 case TargetPlatform::kOpenGLES:
193 case TargetPlatform::kOpenGLDesktop:
194 case TargetPlatform::kRuntimeStageGLES:
195 return true;
196 }
197 FML_UNREACHABLE();
198 }

References kMetalDesktop, kMetalIOS, kOpenGLDesktop, kOpenGLES, kRuntimeStageGLES, kRuntimeStageMetal, kRuntimeStageVulkan, kSkSL, kUnknown, and kVulkan.

Referenced by CreateCompiler().

## ◆ ExecutionModelToString()

static std::string impeller::compiler::ExecutionModelToString | ( | spv::ExecutionModel | model | ) |
| static

Definition at line 73 of file reflector.cc.

73 {
74 switch (model) {
75 case spv::ExecutionModel::ExecutionModelVertex:
76 return "vertex";
77 case spv::ExecutionModel::ExecutionModelFragment:
78 return "fragment";
79 case spv::ExecutionModel::ExecutionModelTessellationControl:
80 return "tessellation_control";
81 case spv::ExecutionModel::ExecutionModelTessellationEvaluation:
82 return "tessellation_evaluation";
83 case spv::ExecutionModel::ExecutionModelGLCompute:
84 return "compute";
85 default:
86 return "unsupported";
87 }
88 }

## ◆ GetReflectedStructSize()

static size_t impeller::compiler::GetReflectedStructSize | ( | const std::vector< StructMember > & | members | ) |
| static

Get the reflected struct size. In the vast majority of the cases, this is the same as the declared struct size as given by the compiler. But, additional padding may need to be introduced after the end of the struct to keep in line with the alignment requirement of the individual struct members. This method figures out the actual size of the reflected struct that can be referenced in native code.

Parameters

  [in] | members | The members

Returns
  The reflected structure size.

Definition at line 579 of file reflector.cc.

579 {
580 auto struct_size = 0u;
581 for (const auto& member : members) {
582 struct_size += member.byte_length;
583 }
584 return struct_size;
585 }

## ◆ InferShaderNameFromPath()

std::string impeller::compiler::InferShaderNameFromPath | ( | std::string_view | path | ) |

Definition at line 18 of file utilities.cc.

18 {
19 auto p = std::filesystem::path{path}.stem();
20 return Utf8FromPath(p);
21 }

References Utf8FromPath().

Referenced by Main().

## ◆ JoinStrings()

static std::string impeller::compiler::JoinStrings | ( | std::vector< std::string > | items,
|  | const std::string & | separator
| ) |  |
| static

Definition at line 447 of file compiler.cc.

448 {
449 std::stringstream stream;
450 for (size_t i = 0, count = items.size(); i < count; i++) {
451 const auto is_last = (i == count - 1);
452
453 stream << items[i];
454 if (!is_last) {
455 stream << separator;
456 }
457 }
458 return stream.str();
459 }

Referenced by impeller::compiler::Compiler::CreateDepfileContents().

## ◆ Main()

bool impeller::compiler::Main | ( | const fml::CommandLine & | command_line | ) |

Definition at line 39 of file impellerc_main.cc.

39 {
40 fml::InstallCrashHandler();
41 if (command_line.HasOption("help")) {
42 Switches::PrintHelp(std::cout);
43 return true;
44 }
45
46 Switches switches(command_line);
47 if (!switches.AreValid(std::cerr)) {
48 std::cerr << "Invalid flags specified." << std::endl;
49 Switches::PrintHelp(std::cerr);
50 return false;
51 }
52
53 std::shared_ptr<fml::FileMapping> source_file_mapping =
54 fml::FileMapping::CreateReadOnly(switches.source_file_name);
55 if (!source_file_mapping) {
56 std::cerr << "Could not open input file." << std::endl;
57 return false;
58 }
59
60 SourceOptions options;
61 options.target_platform = switches.target_platform;
62 options.source_language = switches.source_language;
63 if (switches.input_type == SourceType::kUnknown) {
64 options.type = SourceTypeFromFileName(switches.source_file_name);
65 } else {
66 options.type = switches.input_type;
67 }
68 options.working_directory = switches.working_directory;
69 options.file_name = switches.source_file_name;
70 options.include_dirs = switches.include_directories;
71 options.defines = switches.defines;
72 options.entry_point_name = EntryPointFunctionNameFromSourceName(
73 switches.source_file_name, options.type, options.source_language,
74 switches.entry_point);
75 options.json_format = switches.json_format;
76 options.gles_language_version = switches.gles_language_version;
77 options.metal_version = switches.metal_version;
78 options.use_half_textures = switches.use_half_textures;
79
80 Reflector::Options reflector_options;
81 reflector_options.target_platform = switches.target_platform;
82 reflector_options.entry_point_name = options.entry_point_name;
83 reflector_options.shader_name =
84 InferShaderNameFromPath(switches.source_file_name);
85 reflector_options.header_file_name = Utf8FromPath(
86 std::filesystem::path{switches.reflection_header_name}.filename());
87
88 // Generate SkSL if needed.
89 std::shared_ptr<fml::Mapping> sksl_mapping;
90 if (switches.iplr && TargetPlatformBundlesSkSL(switches.target_platform)) {
91 SourceOptions sksl_options = options;
92 sksl_options.target_platform = TargetPlatform::kSkSL;
93
94 Reflector::Options sksl_reflector_options = reflector_options;
95 sksl_reflector_options.target_platform = TargetPlatform::kSkSL;
96
97 Compiler sksl_compiler =
98 Compiler(source_file_mapping, sksl_options, sksl_reflector_options);
99 if (!sksl_compiler.IsValid()) {
100 std::cerr << "Compilation to SkSL failed." << std::endl;
101 std::cerr << sksl_compiler.GetErrorMessages() << std::endl;
102 return false;
103 }
104 sksl_mapping = sksl_compiler.GetSLShaderSource();
105 }
106
107 Compiler compiler(source_file_mapping, options, reflector_options);
108 if (!compiler.IsValid()) {
109 std::cerr << "Compilation failed." << std::endl;
110 std::cerr << compiler.GetErrorMessages() << std::endl;
111 return false;
112 }
113
114 auto spriv_file_name = std::filesystem::absolute(
115 std::filesystem::current_path() / switches.spirv_file_name);
116 if (!fml::WriteAtomically(*switches.working_directory,
117 Utf8FromPath(spriv_file_name).c_str(),
118 *compiler.GetSPIRVAssembly())) {
119 std::cerr << "Could not write file to " << switches.spirv_file_name
120 << std::endl;
121 return false;
122 }
123
124 auto sl_file_name = std::filesystem::absolute(
125 std::filesystem::current_path() / switches.sl_file_name);
126 if (switches.iplr) {
127 auto reflector = compiler.GetReflector();
128 if (reflector == nullptr) {
129 std::cerr << "Could not create reflector." << std::endl;
130 return false;
131 }
132 auto stage_data = reflector->GetRuntimeStageData();
133 if (!stage_data) {
134 std::cerr << "Runtime stage information was nil." << std::endl;
135 return false;
136 }
137 if (sksl_mapping) {
138 stage_data->SetSkSLData(sksl_mapping);
139 }
140 auto stage_data_mapping = options.json_format
141 ? stage_data->CreateJsonMapping()
142 : stage_data->CreateMapping();
143 if (!stage_data_mapping) {
144 std::cerr << "Runtime stage data could not be created." << std::endl;
145 return false;
146 }
147 if (!fml::WriteAtomically(*switches.working_directory, //
148 Utf8FromPath(sl_file_name).c_str(), //
149 *stage_data_mapping //
150 )) {
151 std::cerr << "Could not write file to " << switches.sl_file_name
152 << std::endl;
153 return false;
154 }
155 // Tools that consume the runtime stage data expect the access mode to
156 // be 0644.
157 if (!SetPermissiveAccess(sl_file_name)) {
158 return false;
159 }
160 } else {
161 if (!fml::WriteAtomically(*switches.working_directory,
162 Utf8FromPath(sl_file_name).c_str(),
163 *compiler.GetSLShaderSource())) {
164 std::cerr << "Could not write file to " << switches.sl_file_name
165 << std::endl;
166 return false;
167 }
168 }
169
170 if (TargetPlatformNeedsReflection(options.target_platform)) {
171 if (!switches.reflection_json_name.empty()) {
172 auto reflection_json_name = std::filesystem::absolute(
173 std::filesystem::current_path() / switches.reflection_json_name);
174 if (!fml::WriteAtomically(
175 *switches.working_directory,
176 Utf8FromPath(reflection_json_name).c_str(),
177 *compiler.GetReflector()->GetReflectionJSON())) {
178 std::cerr << "Could not write reflection json to "
179 << switches.reflection_json_name << std::endl;
180 return false;
181 }
182 }
183
184 if (!switches.reflection_header_name.empty()) {
185 auto reflection_header_name =
186 std::filesystem::absolute(std::filesystem::current_path() /
187 switches.reflection_header_name.c_str());
188 if (!fml::WriteAtomically(
189 *switches.working_directory,
190 Utf8FromPath(reflection_header_name).c_str(),
191 *compiler.GetReflector()->GetReflectionHeader())) {
192 std::cerr << "Could not write reflection header to "
193 << switches.reflection_header_name << std::endl;
194 return false;
195 }
196 }
197
198 if (!switches.reflection_cc_name.empty()) {
199 auto reflection_cc_name =
200 std::filesystem::absolute(std::filesystem::current_path() /
201 switches.reflection_cc_name.c_str());
202 if (!fml::WriteAtomically(*switches.working_directory,
203 Utf8FromPath(reflection_cc_name).c_str(),
204 *compiler.GetReflector()->GetReflectionCC())) {
205 std::cerr << "Could not write reflection CC to "
206 << switches.reflection_cc_name << std::endl;
207 return false;
208 }
209 }
210 }
211
212 if (!switches.depfile_path.empty()) {
213 std::string result_file;
214 switch (switches.target_platform) {
215 case TargetPlatform::kMetalDesktop:
216 case TargetPlatform::kMetalIOS:
217 case TargetPlatform::kOpenGLES:
218 case TargetPlatform::kOpenGLDesktop:
219 case TargetPlatform::kRuntimeStageMetal:
220 case TargetPlatform::kRuntimeStageGLES:
221 case TargetPlatform::kRuntimeStageVulkan:
222 case TargetPlatform::kSkSL:
223 case TargetPlatform::kVulkan:
224 result_file = switches.sl_file_name;
225 break;
226 case TargetPlatform::kUnknown:
227 result_file = switches.spirv_file_name;
228 break;
229 }
230 auto depfile_path = std::filesystem::absolute(
231 std::filesystem::current_path() / switches.depfile_path.c_str());
232 if (!fml::WriteAtomically(*switches.working_directory,
233 Utf8FromPath(depfile_path).c_str(),
234 *compiler.CreateDepfileContents({result_file}))) {
235 std::cerr << "Could not write depfile to " << switches.depfile_path
236 << std::endl;
237 return false;
238 }
239 }
240
241 return true;
242 }

References impeller::compiler::Switches::AreValid(), impeller::compiler::Compiler::CreateDepfileContents(), impeller::compiler::SourceOptions::defines, impeller::compiler::Switches::defines, impeller::compiler::Switches::depfile_path, impeller::compiler::Switches::entry_point, impeller::compiler::SourceOptions::entry_point_name, impeller::compiler::Reflector::Options::entry_point_name, EntryPointFunctionNameFromSourceName(), impeller::compiler::SourceOptions::file_name, impeller::compiler::Compiler::GetErrorMessages(), impeller::compiler::Reflector::GetReflectionCC(), impeller::compiler::Reflector::GetReflectionHeader(), impeller::compiler::Reflector::GetReflectionJSON(), impeller::compiler::Compiler::GetReflector(), impeller::compiler::Reflector::GetRuntimeStageData(), impeller::compiler::Compiler::GetSLShaderSource(), impeller::compiler::Compiler::GetSPIRVAssembly(), impeller::compiler::SourceOptions::gles_language_version, impeller::compiler::Switches::gles_language_version, impeller::compiler::Reflector::Options::header_file_name, impeller::compiler::Switches::include_directories, impeller::compiler::SourceOptions::include_dirs, InferShaderNameFromPath(), impeller::compiler::Switches::input_type, impeller::compiler::Switches::iplr, impeller::compiler::Compiler::IsValid(), impeller::compiler::SourceOptions::json_format, impeller::compiler::Switches::json_format, kMetalDesktop, kMetalIOS, kOpenGLDesktop, kOpenGLES, kRuntimeStageGLES, kRuntimeStageMetal, kRuntimeStageVulkan, kSkSL, kUnknown, kVulkan, impeller::compiler::SourceOptions::metal_version, impeller::compiler::Switches::metal_version, impeller::compiler::Switches::PrintHelp(), impeller::compiler::Switches::reflection_cc_name, impeller::compiler::Switches::reflection_header_name, impeller::compiler::Switches::reflection_json_name, SetPermissiveAccess(), impeller::compiler::Reflector::Options::shader_name, impeller::compiler::Switches::sl_file_name, impeller::compiler::Switches::source_file_name, impeller::compiler::SourceOptions::source_language, impeller::compiler::Switches::source_language, SourceTypeFromFileName(), impeller::compiler::Switches::spirv_file_name, impeller::compiler::Switches::target_platform, impeller::compiler::SourceOptions::target_platform, impeller::compiler::Reflector::Options::target_platform, TargetPlatformBundlesSkSL(), TargetPlatformNeedsReflection(), impeller::compiler::SourceOptions::type, impeller::compiler::SourceOptions::use_half_textures, impeller::compiler::Switches::use_half_textures, Utf8FromPath(), impeller::compiler::Switches::working_directory, and impeller::compiler::SourceOptions::working_directory.

Referenced by main().

## ◆ ParseMSLVersion()

static uint32_t impeller::compiler::ParseMSLVersion | ( | const std::string & | msl_version | ) |
| static

Definition at line 27 of file compiler.cc.

27 {
28 std::stringstream sstream(msl_version);
29 std::string version_part;
30 uint32_t major = 1;
31 uint32_t minor = 2;
32 uint32_t patch = 0;
33 if (std::getline(sstream, version_part, '.')) {
34 major = std::stoi(version_part);
35 if (std::getline(sstream, version_part, '.')) {
36 minor = std::stoi(version_part);
37 if (std::getline(sstream, version_part, '.')) {
38 patch = std::stoi(version_part);
39 }
40 }
41 }
42 if (major < 1 || (major == 1 && minor < 2)) {
43 std::cerr << "--metal-version version must be at least 1.2. Have "
44 << msl_version << std::endl;
45 }
46 return spirv_cross::CompilerMSL::Options::make_msl_version(major, minor,
47 patch);
48 }

## ◆ ReadKnownScalarType()

static std::optional<KnownType> impeller::compiler::ReadKnownScalarType | ( | spirv_cross::SPIRType::BaseType | type | ) |
| static

Definition at line 532 of file reflector.cc.

533 {
534 switch (type) {
535 case spirv_cross::SPIRType::BaseType::Boolean:
536 return KnownType{
537 .name = "bool",
538 .byte_size = sizeof(bool),
539 };
540 case spirv_cross::SPIRType::BaseType::Float:
541 return KnownType{
542 .name = "Scalar",
543 .byte_size = sizeof(Scalar),
544 };
545 case spirv_cross::SPIRType::BaseType::Half:
546 return KnownType{
547 .name = "Half",
548 .byte_size = sizeof(Half),
549 };
550 case spirv_cross::SPIRType::BaseType::UInt:
551 return KnownType{
552 .name = "uint32_t",
553 .byte_size = sizeof(uint32_t),
554 };
555 case spirv_cross::SPIRType::BaseType::Int:
556 return KnownType{
557 .name = "int32_t",
558 .byte_size = sizeof(int32_t),
559 };
560 default:
561 break;
562 }
563 return std::nullopt;
564 }

References impeller::compiler::KnownType::name.

## ◆ report_and_exit()

void impeller::compiler::report_and_exit | ( | const std::string & | msg | ) |

Definition at line 16 of file spirv_sksl.cc.

16 {
17 fprintf(stderr, "There was a compiler error: %s\n", msg.c_str());
18 fflush(stderr);
19 exit(1);
20 }

## ◆ SetBindingBaseOffset()

static void impeller::compiler::SetBindingBaseOffset | ( | shaderc::CompileOptions & | options | ) |
| static

Definition at line 210 of file spirv_compiler.cc.

210 {
211 constexpr uint32_t kBindingBaseOffset = 64;
212 static const shaderc_uniform_kind kUniformKinds[] = {
213 shaderc_uniform_kind::shaderc_uniform_kind_sampler,
214 shaderc_uniform_kind::shaderc_uniform_kind_texture,
215 shaderc_uniform_kind::shaderc_uniform_kind_image,
216 shaderc_uniform_kind::shaderc_uniform_kind_buffer, // UBOs
217 shaderc_uniform_kind::shaderc_uniform_kind_storage_buffer, // SSBOs
218 };
219
220 for (size_t i = 0u; i < sizeof(kUniformKinds) / sizeof(shaderc_uniform_kind);
221 i++) {
222 options.SetBindingBaseForStage(
223 shaderc_shader_kind::shaderc_fragment_shader, //
224 kUniformKinds[i], //
225 kBindingBaseOffset //
226 );
227 }
228 }

Referenced by impeller::compiler::SPIRVCompilerOptions::BuildShadercOptions().

## ◆ SetDefaultLimitations()

static void impeller::compiler::SetDefaultLimitations | ( | shaderc::CompileOptions & | compiler_opts | ) |
| static

Definition at line 92 of file spirv_compiler.cc.

92 {
93 using Limit = std::pair<shaderc_limit, int>;
94 static constexpr std::array<Limit, 83> limits = {
95 Limit{shaderc_limit::shaderc_limit_max_lights, 8},
96 Limit{shaderc_limit::shaderc_limit_max_clip_planes, 6},
97 Limit{shaderc_limit::shaderc_limit_max_texture_units, 2},
98 Limit{shaderc_limit::shaderc_limit_max_texture_coords, 8},
99 Limit{shaderc_limit::shaderc_limit_max_vertex_attribs, 16},
100 Limit{shaderc_limit::shaderc_limit_max_vertex_uniform_components, 4096},
101 Limit{shaderc_limit::shaderc_limit_max_varying_floats, 60},
102 Limit{shaderc_limit::shaderc_limit_max_vertex_texture_image_units, 16},
103 Limit{shaderc_limit::shaderc_limit_max_combined_texture_image_units, 80},
104 Limit{shaderc_limit::shaderc_limit_max_texture_image_units, 16},
105 Limit{shaderc_limit::shaderc_limit_max_fragment_uniform_components, 1024},
106 Limit{shaderc_limit::shaderc_limit_max_draw_buffers, 8},
107 Limit{shaderc_limit::shaderc_limit_max_vertex_uniform_vectors, 256},
108 Limit{shaderc_limit::shaderc_limit_max_varying_vectors, 15},
109 Limit{shaderc_limit::shaderc_limit_max_fragment_uniform_vectors, 256},
110 Limit{shaderc_limit::shaderc_limit_max_vertex_output_vectors, 16},
111 Limit{shaderc_limit::shaderc_limit_max_fragment_input_vectors, 15},
112 Limit{shaderc_limit::shaderc_limit_min_program_texel_offset, -8},
113 Limit{shaderc_limit::shaderc_limit_max_program_texel_offset, 7},
114 Limit{shaderc_limit::shaderc_limit_max_clip_distances, 8},
115 Limit{shaderc_limit::shaderc_limit_max_compute_work_group_count_x, 65535},
116 Limit{shaderc_limit::shaderc_limit_max_compute_work_group_count_y, 65535},
117 Limit{shaderc_limit::shaderc_limit_max_compute_work_group_count_z, 65535},
118 Limit{shaderc_limit::shaderc_limit_max_compute_work_group_size_x, 1024},
119 Limit{shaderc_limit::shaderc_limit_max_compute_work_group_size_y, 1024},
120 Limit{shaderc_limit::shaderc_limit_max_compute_work_group_size_z, 64},
121 Limit{shaderc_limit::shaderc_limit_max_compute_uniform_components, 512},
122 Limit{shaderc_limit::shaderc_limit_max_compute_texture_image_units, 16},
123 Limit{shaderc_limit::shaderc_limit_max_compute_image_uniforms, 8},
124 Limit{shaderc_limit::shaderc_limit_max_compute_atomic_counters, 8},
125 Limit{shaderc_limit::shaderc_limit_max_compute_atomic_counter_buffers, 1},
126 Limit{shaderc_limit::shaderc_limit_max_varying_components, 60},
127 Limit{shaderc_limit::shaderc_limit_max_vertex_output_components, 64},
128 Limit{shaderc_limit::shaderc_limit_max_geometry_input_components, 64},
129 Limit{shaderc_limit::shaderc_limit_max_geometry_output_components, 128},
130 Limit{shaderc_limit::shaderc_limit_max_fragment_input_components, 128},
131 Limit{shaderc_limit::shaderc_limit_max_image_units, 8},
132 Limit{shaderc_limit::
133 shaderc_limit_max_combined_image_units_and_fragment_outputs,
134 8},
135 Limit{shaderc_limit::shaderc_limit_max_combined_shader_output_resources,
136 8},
137 Limit{shaderc_limit::shaderc_limit_max_image_samples, 0},
138 Limit{shaderc_limit::shaderc_limit_max_vertex_image_uniforms, 0},
139 Limit{shaderc_limit::shaderc_limit_max_tess_control_image_uniforms, 0},
140 Limit{shaderc_limit::shaderc_limit_max_tess_evaluation_image_uniforms, 0},
141 Limit{shaderc_limit::shaderc_limit_max_geometry_image_uniforms, 0},
142 Limit{shaderc_limit::shaderc_limit_max_fragment_image_uniforms, 8},
143 Limit{shaderc_limit::shaderc_limit_max_combined_image_uniforms, 8},
144 Limit{shaderc_limit::shaderc_limit_max_geometry_texture_image_units, 16},
145 Limit{shaderc_limit::shaderc_limit_max_geometry_output_vertices, 256},
146 Limit{shaderc_limit::shaderc_limit_max_geometry_total_output_components,
147 1024},
148 Limit{shaderc_limit::shaderc_limit_max_geometry_uniform_components, 512},
149 Limit{shaderc_limit::shaderc_limit_max_geometry_varying_components, 60},
150 Limit{shaderc_limit::shaderc_limit_max_tess_control_input_components,
151 128},
152 Limit{shaderc_limit::shaderc_limit_max_tess_control_output_components,
153 128},
154 Limit{shaderc_limit::shaderc_limit_max_tess_control_texture_image_units,
155 16},
156 Limit{shaderc_limit::shaderc_limit_max_tess_control_uniform_components,
157 1024},
158 Limit{
159 shaderc_limit::shaderc_limit_max_tess_control_total_output_components,
160 4096},
161 Limit{shaderc_limit::shaderc_limit_max_tess_evaluation_input_components,
162 128},
163 Limit{shaderc_limit::shaderc_limit_max_tess_evaluation_output_components,
164 128},
165 Limit{
166 shaderc_limit::shaderc_limit_max_tess_evaluation_texture_image_units,
167 16},
168 Limit{shaderc_limit::shaderc_limit_max_tess_evaluation_uniform_components,
169 1024},
170 Limit{shaderc_limit::shaderc_limit_max_tess_patch_components, 120},
171 Limit{shaderc_limit::shaderc_limit_max_patch_vertices, 32},
172 Limit{shaderc_limit::shaderc_limit_max_tess_gen_level, 64},
173 Limit{shaderc_limit::shaderc_limit_max_viewports, 16},
174 Limit{shaderc_limit::shaderc_limit_max_vertex_atomic_counters, 0},
175 Limit{shaderc_limit::shaderc_limit_max_tess_control_atomic_counters, 0},
176 Limit{shaderc_limit::shaderc_limit_max_tess_evaluation_atomic_counters,
177 0},
178 Limit{shaderc_limit::shaderc_limit_max_geometry_atomic_counters, 0},
179 Limit{shaderc_limit::shaderc_limit_max_fragment_atomic_counters, 8},
180 Limit{shaderc_limit::shaderc_limit_max_combined_atomic_counters, 8},
181 Limit{shaderc_limit::shaderc_limit_max_atomic_counter_bindings, 1},
182 Limit{shaderc_limit::shaderc_limit_max_vertex_atomic_counter_buffers, 0},
183 Limit{
184 shaderc_limit::shaderc_limit_max_tess_control_atomic_counter_buffers,
185 0},
186 Limit{shaderc_limit::
187 shaderc_limit_max_tess_evaluation_atomic_counter_buffers,
188 0},
189 Limit{shaderc_limit::shaderc_limit_max_geometry_atomic_counter_buffers,
190 0},
191 Limit{shaderc_limit::shaderc_limit_max_fragment_atomic_counter_buffers,
192 0},
193 Limit{shaderc_limit::shaderc_limit_max_combined_atomic_counter_buffers,
194 1},
195 Limit{shaderc_limit::shaderc_limit_max_atomic_counter_buffer_size, 32},
196 Limit{shaderc_limit::shaderc_limit_max_transform_feedback_buffers, 4},
197 Limit{shaderc_limit::
198 shaderc_limit_max_transform_feedback_interleaved_components,
199 64},
200 Limit{shaderc_limit::shaderc_limit_max_cull_distances, 8},
201 Limit{shaderc_limit::shaderc_limit_max_combined_clip_and_cull_distances,
202 8},
203 Limit{shaderc_limit::shaderc_limit_max_samples, 4},
204 };
205 for (auto& [limit, value] : limits) {
206 compiler_opts.SetLimit(limit, value);
207 }
208 }

Referenced by impeller::compiler::SPIRVCompilerOptions::BuildShadercOptions().

## ◆ SetPermissiveAccess()

static bool impeller::compiler::SetPermissiveAccess | ( | const std::filesystem::path & | p | ) |
| static

Definition at line 25 of file impellerc_main.cc.

25 {
26 auto permissions =
27 std::filesystem::perms::owner_read | std::filesystem::perms::owner_write |
28 std::filesystem::perms::group_read | std::filesystem::perms::others_read;
29 std::error_code error;
30 std::filesystem::permissions(p, permissions, error);
31 if (error) {
32 std::cerr << "Failed to set access on file '" << p
33 << "': " << error.message() << std::endl;
34 return false;
35 }
36 return true;
37 }

Referenced by Main().

## ◆ ShaderCErrorToString()

std::string impeller::compiler::ShaderCErrorToString | ( | shaderc_compilation_status | status | ) |

Definition at line 144 of file types.cc.

144 {
145 using Status = shaderc_compilation_status;
146 switch (status) {
147 case Status::shaderc_compilation_status_success:
148 return "Success";
149 case Status::shaderc_compilation_status_invalid_stage:
150 return "Invalid shader stage specified";
151 case Status::shaderc_compilation_status_compilation_error:
152 return "Compilation error";
153 case Status::shaderc_compilation_status_internal_error:
154 return "Internal error";
155 case Status::shaderc_compilation_status_null_result_object:
156 return "Internal error. Null result object";
157 case Status::shaderc_compilation_status_invalid_assembly:
158 return "Invalid assembly";
159 case Status::shaderc_compilation_status_validation_error:
160 return "Validation error";
161 case Status::shaderc_compilation_status_transformation_error:
162 return "Transformation error";
163 case Status::shaderc_compilation_status_configuration_error:
164 return "Configuration error";
165 }
166 return "Unknown internal error";
167 }

Referenced by impeller::compiler::SPIRVCompiler::CompileToSPV().

## ◆ SourceLanguageToString()

std::string impeller::compiler::SourceLanguageToString | ( | SourceLanguage | source_language | ) |

Definition at line 79 of file types.cc.

79 {
80 switch (source_language) {
81 case SourceLanguage::kUnknown:
82 return "Unknown";
83 case SourceLanguage::kGLSL:
84 return "GLSL";
85 case SourceLanguage::kHLSL:
86 return "HLSL";
87 }
88 }

References kGLSL, kHLSL, and kUnknown.

Referenced by impeller::compiler::SPIRVCompiler::CompileToSPV().

## ◆ SourceTypeFromCommandLine()

static SourceType impeller::compiler::SourceTypeFromCommandLine | ( | const fml::CommandLine & | command_line | ) |
| static

Definition at line 102 of file switches.cc.

103 {
104 auto source_type_option =
105 command_line.GetOptionValueWithDefault("input-type", "");
106 auto source_type_search = kKnownSourceTypes.find(source_type_option);
107 if (source_type_search == kKnownSourceTypes.end()) {
108 return SourceType::kUnknown;
109 }
110 return source_type_search->second;
111 }

References kKnownSourceTypes, and kUnknown.

## ◆ SourceTypeFromFileName()

SourceType impeller::compiler::SourceTypeFromFileName | ( | const std::string & | file_name | ) |

Definition at line 29 of file types.cc.

29 {
30 if (StringEndWith(file_name, ".vert")) {
31 return SourceType::kVertexShader;
32 }
33
34 if (StringEndWith(file_name, ".frag")) {
35 return SourceType::kFragmentShader;
36 }
37
38 if (StringEndWith(file_name, ".tesc")) {
39 return SourceType::kTessellationControlShader;
40 }
41
42 if (StringEndWith(file_name, ".tese")) {
43 return SourceType::kTessellationEvaluationShader;
44 }
45
46 if (StringEndWith(file_name, ".comp")) {
47 return SourceType::kComputeShader;
48 }
49
50 return SourceType::kUnknown;
51 }

References kComputeShader, kFragmentShader, kTessellationControlShader, kTessellationEvaluationShader, kUnknown, kVertexShader, and StringEndWith().

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

## ◆ SourceTypeToString()

std::string impeller::compiler::SourceTypeToString | ( | SourceType | type | ) |

Definition at line 225 of file types.cc.

225 {
226 switch (type) {
227 case SourceType::kUnknown:
228 return "unknown";
229 case SourceType::kVertexShader:
230 return "vert";
231 case SourceType::kFragmentShader:
232 return "frag";
233 case SourceType::kTessellationControlShader:
234 return "tesc";
235 case SourceType::kTessellationEvaluationShader:
236 return "tese";
237 case SourceType::kComputeShader:
238 return "comp";
239 }
240 FML_UNREACHABLE();
241 }

References kComputeShader, kFragmentShader, kTessellationControlShader, kTessellationEvaluationShader, kUnknown, and kVertexShader.

## ◆ StringEndWith()

static bool impeller::compiler::StringEndWith | ( | const std::string & | string,
|  | const std::string & | suffix
| ) |  |
| static

Definition at line 16 of file types.cc.

17 {
18 if (suffix.size() > string.size()) {
19 return false;
20 }
21
22 if (suffix.empty() || suffix.empty()) {
23 return false;
24 }
25
26 return string.rfind(suffix) == (string.size() - suffix.size());
27 }

Referenced by SourceTypeFromFileName().

## ◆ StringStartsWith()

bool impeller::compiler::StringStartsWith | ( | const std::string & | target,
|  | const std::string & | prefix
| ) |  |

Definition at line 64 of file utilities.cc.

64 {
65 if (prefix.length() > target.length()) {
66 return false;
67 }
68 for (size_t i = 0; i < prefix.length(); i++) {
69 if (target[i] != prefix[i]) {
70 return false;
71 }
72 }
73 return true;
74 }

Referenced by CreateGLSLCompiler().

## ◆ StringToShaderStage()

static std::string impeller::compiler::StringToShaderStage | ( | std::string | str | ) |
| static

Definition at line 90 of file reflector.cc.

90 {
91 if (str == "vertex") {
92 return "ShaderStage::kVertex";
93 }
94
95 if (str == "fragment") {
96 return "ShaderStage::kFragment";
97 }
98
99 if (str == "tessellation_control") {
100 return "ShaderStage::kTessellationControl";
101 }
102
103 if (str == "tessellation_evaluation") {
104 return "ShaderStage::kTessellationEvaluation";
105 }
106
107 if (str == "compute") {
108 return "ShaderStage::kCompute";
109 }
110
111 return "ShaderStage::kUnknown";
112 }

## ◆ TargetPlatformBundlesSkSL()

bool impeller::compiler::TargetPlatformBundlesSkSL | ( | TargetPlatform | platform | ) |

Definition at line 317 of file types.cc.

317 {
318 switch (platform) {
319 case TargetPlatform::kSkSL:
320 case TargetPlatform::kRuntimeStageMetal:
321 case TargetPlatform::kRuntimeStageGLES:
322 case TargetPlatform::kRuntimeStageVulkan:
323 return true;
324 case TargetPlatform::kMetalDesktop:
325 case TargetPlatform::kMetalIOS:
326 case TargetPlatform::kUnknown:
327 case TargetPlatform::kOpenGLES:
328 case TargetPlatform::kOpenGLDesktop:
329 case TargetPlatform::kVulkan:
330 return false;
331 }
332 FML_UNREACHABLE();
333 }

References kMetalDesktop, kMetalIOS, kOpenGLDesktop, kOpenGLES, kRuntimeStageGLES, kRuntimeStageMetal, kRuntimeStageVulkan, kSkSL, kUnknown, and kVulkan.

Referenced by Main().

## ◆ TargetPlatformFromCommandLine()

static TargetPlatform impeller::compiler::TargetPlatformFromCommandLine | ( | const fml::CommandLine & | command_line | ) |
| static

Definition at line 84 of file switches.cc.

85 {
86 auto target = TargetPlatform::kUnknown;
87 for (const auto& platform : kKnownPlatforms) {
88 if (command_line.HasOption(platform.first)) {
89 // If the platform has already been determined, the caller may have
90 // specified multiple platforms. This is an error and only one must be
91 // selected.
92 if (target != TargetPlatform::kUnknown) {
93 return TargetPlatform::kUnknown;
94 }
95 target = platform.second;
96 // Keep going to detect duplicates.
97 }
98 }
99 return target;
100 }

References kKnownPlatforms, and kUnknown.

## ◆ TargetPlatformIsMetal()

bool impeller::compiler::TargetPlatformIsMetal | ( | TargetPlatform | platform | ) |

Definition at line 281 of file types.cc.

281 {
282 switch (platform) {
283 case TargetPlatform::kMetalDesktop:
284 case TargetPlatform::kMetalIOS:
285 case TargetPlatform::kRuntimeStageMetal:
286 return true;
287 case TargetPlatform::kUnknown:
288 case TargetPlatform::kSkSL:
289 case TargetPlatform::kOpenGLES:
290 case TargetPlatform::kOpenGLDesktop:
291 case TargetPlatform::kRuntimeStageGLES:
292 case TargetPlatform::kRuntimeStageVulkan:
293 case TargetPlatform::kVulkan:
294 return false;
295 }
296 FML_UNREACHABLE();
297 }

References kMetalDesktop, kMetalIOS, kOpenGLDesktop, kOpenGLES, kRuntimeStageGLES, kRuntimeStageMetal, kRuntimeStageVulkan, kSkSL, kUnknown, and kVulkan.

Referenced by impeller::compiler::testing::TEST_P().

## ◆ TargetPlatformIsOpenGL()

bool impeller::compiler::TargetPlatformIsOpenGL | ( | TargetPlatform | platform | ) |

Definition at line 263 of file types.cc.

263 {
264 switch (platform) {
265 case TargetPlatform::kOpenGLES:
266 case TargetPlatform::kOpenGLDesktop:
267 case TargetPlatform::kRuntimeStageGLES:
268 return true;
269 case TargetPlatform::kMetalDesktop:
270 case TargetPlatform::kRuntimeStageMetal:
271 case TargetPlatform::kRuntimeStageVulkan:
272 case TargetPlatform::kMetalIOS:
273 case TargetPlatform::kUnknown:
274 case TargetPlatform::kSkSL:
275 case TargetPlatform::kVulkan:
276 return false;
277 }
278 FML_UNREACHABLE();
279 }

References kMetalDesktop, kMetalIOS, kOpenGLDesktop, kOpenGLES, kRuntimeStageGLES, kRuntimeStageMetal, kRuntimeStageVulkan, kSkSL, kUnknown, and kVulkan.

## ◆ TargetPlatformIsVulkan()

bool impeller::compiler::TargetPlatformIsVulkan | ( | TargetPlatform | platform | ) |

Definition at line 299 of file types.cc.

299 {
300 switch (platform) {
301 case TargetPlatform::kRuntimeStageVulkan:
302 case TargetPlatform::kVulkan:
303 return true;
304 case TargetPlatform::kMetalDesktop:
305 case TargetPlatform::kMetalIOS:
306 case TargetPlatform::kRuntimeStageMetal:
307 case TargetPlatform::kUnknown:
308 case TargetPlatform::kSkSL:
309 case TargetPlatform::kOpenGLES:
310 case TargetPlatform::kOpenGLDesktop:
311 case TargetPlatform::kRuntimeStageGLES:
312 return false;
313 }
314 FML_UNREACHABLE();
315 }

References kMetalDesktop, kMetalIOS, kOpenGLDesktop, kOpenGLES, kRuntimeStageGLES, kRuntimeStageMetal, kRuntimeStageVulkan, kSkSL, kUnknown, and kVulkan.

Referenced by impeller::compiler::testing::TEST_P().

## ◆ TargetPlatformNeedsReflection()

bool impeller::compiler::TargetPlatformNeedsReflection | ( | TargetPlatform | platform | ) |

Definition at line 126 of file types.cc.

126 {
127 switch (platform) {
128 case TargetPlatform::kMetalIOS:
129 case TargetPlatform::kMetalDesktop:
130 case TargetPlatform::kOpenGLES:
131 case TargetPlatform::kOpenGLDesktop:
132 case TargetPlatform::kRuntimeStageMetal:
133 case TargetPlatform::kRuntimeStageGLES:
134 case TargetPlatform::kRuntimeStageVulkan:
135 case TargetPlatform::kVulkan:
136 return true;
137 case TargetPlatform::kUnknown:
138 case TargetPlatform::kSkSL:
139 return false;
140 }
141 FML_UNREACHABLE();
142 }

References kMetalDesktop, kMetalIOS, kOpenGLDesktop, kOpenGLES, kRuntimeStageGLES, kRuntimeStageMetal, kRuntimeStageVulkan, kSkSL, kUnknown, and kVulkan.

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

## ◆ TargetPlatformSLExtension()

std::string impeller::compiler::TargetPlatformSLExtension | ( | TargetPlatform | platform | ) |

Definition at line 243 of file types.cc.

243 {
244 switch (platform) {
245 case TargetPlatform::kUnknown:
246 return "unknown";
247 case TargetPlatform::kMetalDesktop:
248 case TargetPlatform::kMetalIOS:
249 case TargetPlatform::kRuntimeStageMetal:
250 return "metal";
251 case TargetPlatform::kSkSL:
252 case TargetPlatform::kOpenGLES:
253 case TargetPlatform::kOpenGLDesktop:
254 case TargetPlatform::kRuntimeStageGLES:
255 return "glsl";
256 case TargetPlatform::kVulkan:
257 case TargetPlatform::kRuntimeStageVulkan:
258 return "vk.spirv";
259 }
260 FML_UNREACHABLE();
261 }

References kMetalDesktop, kMetalIOS, kOpenGLDesktop, kOpenGLES, kRuntimeStageGLES, kRuntimeStageMetal, kRuntimeStageVulkan, kSkSL, kUnknown, and kVulkan.

Referenced by impeller::compiler::testing::SLFileName().

## ◆ TargetPlatformToMSLPlatform()

spirv_cross::CompilerMSL::Options::Platform impeller::compiler::TargetPlatformToMSLPlatform | ( | TargetPlatform | platform | ) |

Definition at line 205 of file types.cc.

206 {
207 switch (platform) {
208 case TargetPlatform::kMetalIOS:
209 case TargetPlatform::kRuntimeStageMetal:
210 return spirv_cross::CompilerMSL::Options::Platform::iOS;
211 case TargetPlatform::kMetalDesktop:
212 return spirv_cross::CompilerMSL::Options::Platform::macOS;
213 case TargetPlatform::kSkSL:
214 case TargetPlatform::kOpenGLES:
215 case TargetPlatform::kOpenGLDesktop:
216 case TargetPlatform::kRuntimeStageGLES:
217 case TargetPlatform::kRuntimeStageVulkan:
218 case TargetPlatform::kVulkan:
219 case TargetPlatform::kUnknown:
220 return spirv_cross::CompilerMSL::Options::Platform::macOS;
221 }
222 FML_UNREACHABLE();
223 }

References kMetalDesktop, kMetalIOS, kOpenGLDesktop, kOpenGLES, kRuntimeStageGLES, kRuntimeStageMetal, kRuntimeStageVulkan, kSkSL, kUnknown, and kVulkan.

## ◆ TargetPlatformToString()

std::string impeller::compiler::TargetPlatformToString | ( | TargetPlatform | platform | ) |

Definition at line 53 of file types.cc.

53 {
54 switch (platform) {
55 case TargetPlatform::kUnknown:
56 return "Unknown";
57 case TargetPlatform::kMetalDesktop:
58 return "MetalDesktop";
59 case TargetPlatform::kMetalIOS:
60 return "MetaliOS";
61 case TargetPlatform::kOpenGLES:
62 return "OpenGLES";
63 case TargetPlatform::kOpenGLDesktop:
64 return "OpenGLDesktop";
65 case TargetPlatform::kVulkan:
66 return "Vulkan";
67 case TargetPlatform::kRuntimeStageMetal:
68 return "RuntimeStageMetal";
69 case TargetPlatform::kRuntimeStageGLES:
70 return "RuntimeStageGLES";
71 case TargetPlatform::kRuntimeStageVulkan:
72 return "RuntimeStageVulkan";
73 case TargetPlatform::kSkSL:
74 return "SkSL";
75 }
76 FML_UNREACHABLE();
77 }

References kMetalDesktop, kMetalIOS, kOpenGLDesktop, kOpenGLES, kRuntimeStageGLES, kRuntimeStageMetal, kRuntimeStageVulkan, kSkSL, kUnknown, and kVulkan.

## ◆ ToExecutionModel()

spv::ExecutionModel impeller::compiler::ToExecutionModel | ( | SourceType | type | ) |

Definition at line 187 of file types.cc.

187 {
188 switch (type) {
189 case SourceType::kVertexShader:
190 return spv::ExecutionModel::ExecutionModelVertex;
191 case SourceType::kFragmentShader:
192 return spv::ExecutionModel::ExecutionModelFragment;
193 case SourceType::kTessellationControlShader:
194 return spv::ExecutionModel::ExecutionModelTessellationControl;
195 case SourceType::kTessellationEvaluationShader:
196 return spv::ExecutionModel::ExecutionModelTessellationEvaluation;
197 case SourceType::kComputeShader:
198 return spv::ExecutionModel::ExecutionModelGLCompute;
199 case SourceType::kUnknown:
200 break;
201 }
202 return spv::ExecutionModel::ExecutionModelMax;
203 }

References kComputeShader, kFragmentShader, kTessellationControlShader, kTessellationEvaluationShader, kUnknown, and kVertexShader.

Referenced by CreateCompiler().

## ◆ ToJsonStage()

static std::optional<uint32_t> impeller::compiler::ToJsonStage | ( | spv::ExecutionModel | stage | ) |
| static

Definition at line 57 of file runtime_stage_data.cc.

57 {
58 switch (stage) {
59 case spv::ExecutionModel::ExecutionModelVertex:
60 return 0; // fb::Stage::kVertex;
61 case spv::ExecutionModel::ExecutionModelFragment:
62 return 1; // fb::Stage::kFragment;
63 case spv::ExecutionModel::ExecutionModelGLCompute:
64 return 2; // fb::Stage::kCompute;
65 case spv::ExecutionModel::ExecutionModelTessellationControl:
66 return 3; // fb::Stage::kTessellationControl;
67 case spv::ExecutionModel::ExecutionModelTessellationEvaluation:
68 return 4; // fb::Stage::kTessellationEvaluation;
69 default:
70 return std::nullopt;
71 }
72 FML_UNREACHABLE();
73 }

Referenced by impeller::compiler::RuntimeStageData::CreateJsonMapping().

## ◆ ToJsonTargetPlatform()

static std::optional<uint32_t> impeller::compiler::ToJsonTargetPlatform | ( | TargetPlatform | platform | ) |
| static

Definition at line 97 of file runtime_stage_data.cc.

97 {
98 switch (platform) {
99 case TargetPlatform::kUnknown:
100 case TargetPlatform::kMetalDesktop:
101 case TargetPlatform::kMetalIOS:
102 case TargetPlatform::kOpenGLES:
103 case TargetPlatform::kOpenGLDesktop:
104 case TargetPlatform::kVulkan:
105 return std::nullopt;
106 case TargetPlatform::kSkSL:
107 return static_cast<uint32_t>(fb::TargetPlatform::kSkSL);
108 case TargetPlatform::kRuntimeStageMetal:
109 return static_cast<uint32_t>(fb::TargetPlatform::kMetal);
110 case TargetPlatform::kRuntimeStageGLES:
111 return static_cast<uint32_t>(fb::TargetPlatform::kOpenGLES);
112 case TargetPlatform::kRuntimeStageVulkan:
113 return static_cast<uint32_t>(fb::TargetPlatform::kVulkan);
114 }
115 FML_UNREACHABLE();
116 }

References kMetalDesktop, kMetalIOS, kOpenGLDesktop, kOpenGLES, kRuntimeStageGLES, kRuntimeStageMetal, kRuntimeStageVulkan, kSkSL, kUnknown, and kVulkan.

Referenced by impeller::compiler::RuntimeStageData::CreateJsonMapping().

## ◆ ToJsonType()

static std::optional<uint32_t> impeller::compiler::ToJsonType | ( | spirv_cross::SPIRType::BaseType | type | ) |
| static

Definition at line 163 of file runtime_stage_data.cc.

164 {
165 switch (type) {
166 case spirv_cross::SPIRType::Boolean:
167 return 0; // fb::UniformDataType::kBoolean;
168 case spirv_cross::SPIRType::SByte:
169 return 1; // fb::UniformDataType::kSignedByte;
170 case spirv_cross::SPIRType::UByte:
171 return 2; // fb::UniformDataType::kUnsignedByte;
172 case spirv_cross::SPIRType::Short:
173 return 3; // fb::UniformDataType::kSignedShort;
174 case spirv_cross::SPIRType::UShort:
175 return 4; // fb::UniformDataType::kUnsignedShort;
176 case spirv_cross::SPIRType::Int:
177 return 5; // fb::UniformDataType::kSignedInt;
178 case spirv_cross::SPIRType::UInt:
179 return 6; // fb::UniformDataType::kUnsignedInt;
180 case spirv_cross::SPIRType::Int64:
181 return 7; // fb::UniformDataType::kSignedInt64;
182 case spirv_cross::SPIRType::UInt64:
183 return 8; // fb::UniformDataType::kUnsignedInt64;
184 case spirv_cross::SPIRType::Half:
185 return 9; // b::UniformDataType::kHalfFloat;
186 case spirv_cross::SPIRType::Float:
187 return 10; // fb::UniformDataType::kFloat;
188 case spirv_cross::SPIRType::Double:
189 return 11; // fb::UniformDataType::kDouble;
190 case spirv_cross::SPIRType::SampledImage:
191 return 12; // fb::UniformDataType::kSampledImage;
192 case spirv_cross::SPIRType::AccelerationStructure:
193 case spirv_cross::SPIRType::AtomicCounter:
194 case spirv_cross::SPIRType::Char:
195 case spirv_cross::SPIRType::ControlPointArray:
196 case spirv_cross::SPIRType::Image:
197 case spirv_cross::SPIRType::Interpolant:
198 case spirv_cross::SPIRType::RayQuery:
199 case spirv_cross::SPIRType::Sampler:
200 case spirv_cross::SPIRType::Struct:
201 case spirv_cross::SPIRType::Unknown:
202 case spirv_cross::SPIRType::Void:
203 return std::nullopt;
204 }
205 FML_UNREACHABLE();
206 }

Referenced by impeller::compiler::RuntimeStageData::CreateJsonMapping().

## ◆ ToShaderCShaderKind()

shaderc_shader_kind impeller::compiler::ToShaderCShaderKind | ( | SourceType | type | ) |

Definition at line 169 of file types.cc.

169 {
170 switch (type) {
171 case SourceType::kVertexShader:
172 return shaderc_shader_kind::shaderc_vertex_shader;
173 case SourceType::kFragmentShader:
174 return shaderc_shader_kind::shaderc_fragment_shader;
175 case SourceType::kTessellationControlShader:
176 return shaderc_shader_kind::shaderc_tess_control_shader;
177 case SourceType::kTessellationEvaluationShader:
178 return shaderc_shader_kind::shaderc_tess_evaluation_shader;
179 case SourceType::kComputeShader:
180 return shaderc_shader_kind::shaderc_compute_shader;
181 case SourceType::kUnknown:
182 break;
183 }
184 return shaderc_shader_kind::shaderc_glsl_infer_from_source;
185 }

References kComputeShader, kFragmentShader, kTessellationControlShader, kTessellationEvaluationShader, kUnknown, and kVertexShader.

Referenced by impeller::compiler::SPIRVCompiler::CompileToSPV().

## ◆ ToStage()

static std::optional<fb::Stage> impeller::compiler::ToStage | ( | spv::ExecutionModel | stage | ) |
| static

Definition at line 39 of file runtime_stage_data.cc.

39 {
40 switch (stage) {
41 case spv::ExecutionModel::ExecutionModelVertex:
42 return fb::Stage::kVertex;
43 case spv::ExecutionModel::ExecutionModelFragment:
44 return fb::Stage::kFragment;
45 case spv::ExecutionModel::ExecutionModelGLCompute:
46 return fb::Stage::kCompute;
47 case spv::ExecutionModel::ExecutionModelTessellationControl:
48 return fb::Stage::kTessellationControl;
49 case spv::ExecutionModel::ExecutionModelTessellationEvaluation:
50 return fb::Stage::kTessellationEvaluation;
51 default:
52 return std::nullopt;
53 }
54 FML_UNREACHABLE();
55 }

Referenced by impeller::compiler::RuntimeStageData::CreateMapping().

## ◆ ToString()

static std::string impeller::compiler::ToString | ( | CompilerBackend::Type | type | ) |
| static

Definition at line 368 of file reflector.cc.

368 {
369 switch (type) {
370 case CompilerBackend::Type::kMSL:
371 return "Metal Shading Language";
372 case CompilerBackend::Type::kGLSL:
373 return "OpenGL Shading Language";
374 case CompilerBackend::Type::kSkSL:
375 return "SkSL Shading Language";
376 }
377 FML_UNREACHABLE();
378 }

References impeller::compiler::CompilerBackend::kGLSL, impeller::compiler::CompilerBackend::kMSL, and impeller::compiler::CompilerBackend::kSkSL.

## ◆ ToTargetPlatform()

static std::optional<fb::TargetPlatform> impeller::compiler::ToTargetPlatform | ( | TargetPlatform | platform | ) |
| static

Definition at line 75 of file runtime_stage_data.cc.

76 {
77 switch (platform) {
78 case TargetPlatform::kUnknown:
79 case TargetPlatform::kMetalDesktop:
80 case TargetPlatform::kMetalIOS:
81 case TargetPlatform::kOpenGLES:
82 case TargetPlatform::kOpenGLDesktop:
83 case TargetPlatform::kVulkan:
84 return std::nullopt;
85 case TargetPlatform::kSkSL:
86 return fb::TargetPlatform::kSkSL;
87 case TargetPlatform::kRuntimeStageMetal:
88 return fb::TargetPlatform::kMetal;
89 case TargetPlatform::kRuntimeStageGLES:
90 return fb::TargetPlatform::kOpenGLES;
91 case TargetPlatform::kRuntimeStageVulkan:
92 return fb::TargetPlatform::kVulkan;
93 }
94 FML_UNREACHABLE();
95 }

References kMetalDesktop, kMetalIOS, kOpenGLDesktop, kOpenGLES, kRuntimeStageGLES, kRuntimeStageMetal, kRuntimeStageVulkan, kSkSL, kUnknown, and kVulkan.

Referenced by impeller::compiler::RuntimeStageData::CreateMapping().

## ◆ ToType()

static std::optional<fb::UniformDataType> impeller::compiler::ToType | ( | spirv_cross::SPIRType::BaseType | type | ) |
| static

Definition at line 118 of file runtime_stage_data.cc.

119 {
120 switch (type) {
121 case spirv_cross::SPIRType::Boolean:
122 return fb::UniformDataType::kBoolean;
123 case spirv_cross::SPIRType::SByte:
124 return fb::UniformDataType::kSignedByte;
125 case spirv_cross::SPIRType::UByte:
126 return fb::UniformDataType::kUnsignedByte;
127 case spirv_cross::SPIRType::Short:
128 return fb::UniformDataType::kSignedShort;
129 case spirv_cross::SPIRType::UShort:
130 return fb::UniformDataType::kUnsignedShort;
131 case spirv_cross::SPIRType::Int:
132 return fb::UniformDataType::kSignedInt;
133 case spirv_cross::SPIRType::UInt:
134 return fb::UniformDataType::kUnsignedInt;
135 case spirv_cross::SPIRType::Int64:
136 return fb::UniformDataType::kSignedInt64;
137 case spirv_cross::SPIRType::UInt64:
138 return fb::UniformDataType::kUnsignedInt64;
139 case spirv_cross::SPIRType::Half:
140 return fb::UniformDataType::kHalfFloat;
141 case spirv_cross::SPIRType::Float:
142 return fb::UniformDataType::kFloat;
143 case spirv_cross::SPIRType::Double:
144 return fb::UniformDataType::kDouble;
145 case spirv_cross::SPIRType::SampledImage:
146 return fb::UniformDataType::kSampledImage;
147 case spirv_cross::SPIRType::AccelerationStructure:
148 case spirv_cross::SPIRType::AtomicCounter:
149 case spirv_cross::SPIRType::Char:
150 case spirv_cross::SPIRType::ControlPointArray:
151 case spirv_cross::SPIRType::Image:
152 case spirv_cross::SPIRType::Interpolant:
153 case spirv_cross::SPIRType::RayQuery:
154 case spirv_cross::SPIRType::Sampler:
155 case spirv_cross::SPIRType::Struct:
156 case spirv_cross::SPIRType::Unknown:
157 case spirv_cross::SPIRType::Void:
158 return std::nullopt;
159 }
160 FML_UNREACHABLE();
161 }

References impeller::kBoolean, impeller::kDouble, impeller::kFloat, impeller::kHalfFloat, impeller::kSampledImage, impeller::kSignedByte, impeller::kSignedInt, impeller::kSignedInt64, impeller::kSignedShort, impeller::kUnsignedByte, impeller::kUnsignedInt, impeller::kUnsignedInt64, and impeller::kUnsignedShort.

Referenced by impeller::compiler::RuntimeStageData::CreateMapping().

## ◆ TypeNameWithPaddingOfSize()

static std::string impeller::compiler::TypeNameWithPaddingOfSize | ( | size_t | size | ) |
| static

Definition at line 521 of file reflector.cc.

521 {
522 std::stringstream stream;
523 stream << "Padding<" << size << ">";
524 return stream.str();
525 }

Referenced by VertexTypeFromInputResource().

## ◆ Utf8FromPath()

std::string impeller::compiler::Utf8FromPath | ( | const std::filesystem::path & | path | ) |

Converts a native format path to a utf8 string.

        This utility uses `path::u8string()` to convert native paths to
        utf8. If the given path doesn't match the underlying native path
        format, and the native path format isn't utf8 (i.e. Windows, which
        has utf16 paths), the path will get mangled.

Definition at line 14 of file utilities.cc.

14 {
15 return reinterpret_cast<const char*>(path.u8string().c_str());
16 }

Referenced by impeller::compiler::Switches::AreValid(), EntryPointFunctionNameFromSourceName(), InferShaderNameFromPath(), Main(), impeller::scene::importer::Main(), and impeller::compiler::Switches::Switches().

## ◆ VertexTypeFromInputResource()

static VertexType impeller::compiler::VertexTypeFromInputResource | ( | const spirv_cross::Compiler & | compiler,
|  | const spirv_cross::Resource * | resource
| ) |  |
| static

Definition at line 980 of file reflector.cc.

982 {
983 VertexType result;
984 result.variable_name = resource->name;
985 const auto type = compiler.get_type(resource->type_id);
986 result.base_type_name = BaseTypeToString(type.basetype);
987 const auto total_size = type.columns * type.vecsize * type.width / 8u;
988 result.byte_length = total_size;
989
990 if (type.basetype == spirv_cross::SPIRType::BaseType::Float &&
991 type.columns == 1u && type.vecsize == 2u &&
992 type.width == sizeof(float) * 8u) {
993 result.type_name = "Point";
994 } else if (type.basetype == spirv_cross::SPIRType::BaseType::Float &&
995 type.columns == 1u && type.vecsize == 4u &&
996 type.width == sizeof(float) * 8u) {
997 result.type_name = "Vector4";
998 } else if (type.basetype == spirv_cross::SPIRType::BaseType::Float &&
999 type.columns == 1u && type.vecsize == 3u &&
1000 type.width == sizeof(float) * 8u) {
1001 result.type_name = "Vector3";
1002 } else if (type.basetype == spirv_cross::SPIRType::BaseType::Float &&
1003 type.columns == 1u && type.vecsize == 1u &&
1004 type.width == sizeof(float) * 8u) {
1005 result.type_name = "Scalar";
1006 } else if (type.basetype == spirv_cross::SPIRType::BaseType::Int &&
1007 type.columns == 1u && type.vecsize == 1u &&
1008 type.width == sizeof(int32_t) * 8u) {
1009 result.type_name = "int32_t";
1010 } else {
1011 // Catch all unknown padding.
1012 result.type_name = TypeNameWithPaddingOfSize(total_size);
1013 }
1014
1015 return result;
1016 }

References impeller::compiler::VertexType::base_type_name, BaseTypeToString(), impeller::compiler::VertexType::byte_length, impeller::compiler::VertexType::type_name, TypeNameWithPaddingOfSize(), and impeller::compiler::VertexType::variable_name.

## Variable Documentation

## ◆ kEntrypointKey

const char* impeller::compiler::kEntrypointKey = "entrypoint"
| static

Definition at line 210 of file runtime_stage_data.cc.

## ◆ kExternalTexturePrefix

constexpr char impeller::compiler::kExternalTexturePrefix[] = "SAMPLER_EXTERNAL_OES_"
| constexpr

Definition at line 10 of file constants.h.

Referenced by CreateGLSLCompiler().

## ◆ kKnownPlatforms

const std::map<std::string, TargetPlatform> impeller::compiler::kKnownPlatforms
| static

Initial value:
= {
{"metal-desktop", TargetPlatform::kMetalDesktop},
{"metal-ios", TargetPlatform::kMetalIOS},
{"vulkan", TargetPlatform::kVulkan},
{"opengl-es", TargetPlatform::kOpenGLES},
{"opengl-desktop", TargetPlatform::kOpenGLDesktop},
{"sksl", TargetPlatform::kSkSL},
{"runtime-stage-metal", TargetPlatform::kRuntimeStageMetal},
{"runtime-stage-gles", TargetPlatform::kRuntimeStageGLES},
{"runtime-stage-vulkan", TargetPlatform::kRuntimeStageVulkan},
}

Definition at line 19 of file switches.cc.

Referenced by impeller::compiler::Switches::PrintHelp(), and TargetPlatformFromCommandLine().

## ◆ kKnownSourceTypes

const std::map<std::string, SourceType> impeller::compiler::kKnownSourceTypes
| static

Initial value:
= {
{"vert", SourceType::kVertexShader},
{"frag", SourceType::kFragmentShader},
{"tesc", SourceType::kTessellationControlShader},
{"tese", SourceType::kTessellationEvaluationShader},
{"comp", SourceType::kComputeShader},
}

Definition at line 31 of file switches.cc.

Referenced by impeller::compiler::Switches::PrintHelp(), and SourceTypeFromCommandLine().

## ◆ kReflectionCCTemplate

constexpr std::string_view impeller::compiler::kReflectionCCTemplate
| constexpr

Definition at line 198 of file code_gen_template.h.

## ◆ kReflectionHeaderTemplate

constexpr std::string_view impeller::compiler::kReflectionHeaderTemplate
| constexpr

Definition at line 10 of file code_gen_template.h.

## ◆ kShaderKey

const char* impeller::compiler::kShaderKey = "sksl"
| static

Definition at line 212 of file runtime_stage_data.cc.

Referenced by impeller::compiler::RuntimeStageData::CreateJsonMapping().

## ◆ kStageKey

const char* impeller::compiler::kStageKey = "stage"
| static

Definition at line 208 of file runtime_stage_data.cc.

Referenced by impeller::compiler::RuntimeStageData::CreateJsonMapping().

## ◆ kTargetPlatformKey

const char* impeller::compiler::kTargetPlatformKey = "target_platform"
| static

Definition at line 209 of file runtime_stage_data.cc.

Referenced by impeller::compiler::RuntimeStageData::CreateJsonMapping().

## ◆ kUniformArrayElementsKey

const char* impeller::compiler::kUniformArrayElementsKey = "array_elements"
| static

Definition at line 219 of file runtime_stage_data.cc.

Referenced by impeller::compiler::RuntimeStageData::CreateJsonMapping().

## ◆ kUniformBitWidthKey

const char* impeller::compiler::kUniformBitWidthKey = "bit_width"
| static

Definition at line 218 of file runtime_stage_data.cc.

Referenced by impeller::compiler::RuntimeStageData::CreateJsonMapping().

## ◆ kUniformColumnsKey

const char* impeller::compiler::kUniformColumnsKey = "columns"
| static

Definition at line 217 of file runtime_stage_data.cc.

Referenced by impeller::compiler::RuntimeStageData::CreateJsonMapping().

## ◆ kUniformLocationKey

const char* impeller::compiler::kUniformLocationKey = "location"
| static

Definition at line 214 of file runtime_stage_data.cc.

Referenced by impeller::compiler::RuntimeStageData::CreateJsonMapping().

## ◆ kUniformNameKey

const char* impeller::compiler::kUniformNameKey = "name"
| static

Definition at line 213 of file runtime_stage_data.cc.

Referenced by impeller::compiler::RuntimeStageData::CreateJsonMapping().

## ◆ kUniformRowsKey

const char* impeller::compiler::kUniformRowsKey = "rows"
| static

Definition at line 216 of file runtime_stage_data.cc.

Referenced by impeller::compiler::RuntimeStageData::CreateJsonMapping().

## ◆ kUniformsKey

const char* impeller::compiler::kUniformsKey = "uniforms"
| static

Definition at line 211 of file runtime_stage_data.cc.

Referenced by impeller::compiler::RuntimeStageData::CreateJsonMapping().

## ◆ kUniformTypeKey

const char* impeller::compiler::kUniformTypeKey = "type"
| static

Definition at line 215 of file runtime_stage_data.cc.

Referenced by impeller::compiler::RuntimeStageData::CreateJsonMapping().

impeller::kBoolean
@ kBoolean
Definition: runtime_types.h:14
impeller::kFloat
@ kFloat
Definition: runtime_types.h:24
impeller::compiler::CreateVulkanCompiler
static CompilerBackend CreateVulkanCompiler(const spirv_cross::ParsedIR &ir, const SourceOptions &source_options)
Definition: compiler.cc:115
impeller::Scalar
float Scalar
Definition: scalar.h:15
impeller::kUnsignedShort
@ kUnsignedShort
Definition: runtime_types.h:18
impeller::compiler::CreateSkSLCompiler
static CompilerBackend CreateSkSLCompiler(const spirv_cross::ParsedIR &ir, const SourceOptions &source_options)
Definition: compiler.cc:175
impeller::compiler::ConvertToEntrypointName
std::string ConvertToEntrypointName(std::string_view string)
Ensure that the entrypoint name is a valid identifier in the target language.
Definition: utilities.cc:46
impeller::compiler::SourceType::kUnknown
@ kUnknown
impeller::compiler::EntryPointMustBeNamedMain
static bool EntryPointMustBeNamedMain(TargetPlatform platform)
Definition: compiler.cc:181
impeller::compiler::ParseMSLVersion
static uint32_t ParseMSLVersion(const std::string &msl_version)
Definition: compiler.cc:27
impeller::compiler::TargetPlatform::kMetalDesktop
@ kMetalDesktop
impeller::kSignedByte
@ kSignedByte
Definition: runtime_types.h:15
impeller::compiler::TargetPlatformToMSLPlatform
spirv_cross::CompilerMSL::Options::Platform TargetPlatformToMSLPlatform(TargetPlatform platform)
Definition: types.cc:205
impeller::kSampledImage
@ kSampledImage
Definition: runtime_types.h:26
impeller::compiler::CreateGLSLCompiler
static CompilerBackend CreateGLSLCompiler(const spirv_cross::ParsedIR &ir, const SourceOptions &source_options)
Definition: compiler.cc:129
impeller::compiler::TargetPlatformNeedsReflection
bool TargetPlatformNeedsReflection(TargetPlatform platform)
Definition: types.cc:126
impeller::compiler::InferShaderNameFromPath
std::string InferShaderNameFromPath(std::string_view path)
Definition: utilities.cc:18
impeller::compiler::TargetPlatform::kMetalIOS
@ kMetalIOS
impeller::compiler::SourceType::kTessellationControlShader
@ kTessellationControlShader
impeller::compiler::kKnownPlatforms
static const std::map< std::string, TargetPlatform > kKnownPlatforms
Definition: switches.cc:19
impeller::compiler::SourceLanguage::kGLSL
@ kGLSL
impeller::compiler::StringEndWith
static bool StringEndWith(const std::string &string, const std::string &suffix)
Definition: types.cc:16
impeller::kSignedInt
@ kSignedInt
Definition: runtime_types.h:19
impeller::compiler::kExternalTexturePrefix
constexpr char kExternalTexturePrefix[]
Definition: constants.h:10
impeller::SortUniforms
std::vector< spirv_cross::ID > SortUniforms(const spirv_cross::ParsedIR *ir, const spirv_cross::Compiler *compiler, std::optional< spirv_cross::SPIRType::BaseType > type_filter, bool include)
Sorts uniform declarations in an IR according to decoration order.
Definition: uniform_sorter.cc:9
impeller::compiler::SourceLanguage::kHLSL
@ kHLSL
impeller::compiler::TargetPlatform::kVulkan
@ kVulkan
impeller::compiler::SourceType::kFragmentShader
@ kFragmentShader
impeller::compiler::TargetPlatform::kRuntimeStageVulkan
@ kRuntimeStageVulkan
impeller::compiler::SourceType::kComputeShader
@ kComputeShader
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:90
impeller::scene::importer::kKnownSourceTypes
static const std::map< std::string, SourceType > kKnownSourceTypes
Definition: switches.cc:20
impeller::compiler::SetPermissiveAccess
static bool SetPermissiveAccess(const std::filesystem::path &p)
Definition: impellerc_main.cc:25
impeller::kUnsignedByte
@ kUnsignedByte
Definition: runtime_types.h:16
impeller::kUnsignedInt64
@ kUnsignedInt64
Definition: runtime_types.h:22
impeller::kHalfFloat
@ kHalfFloat
Definition: runtime_types.h:23
impeller::kUnsignedInt
@ kUnsignedInt
Definition: runtime_types.h:20
impeller::compiler::ToExecutionModel
spv::ExecutionModel ToExecutionModel(SourceType type)
Definition: types.cc:187
impeller::kSignedShort
@ kSignedShort
Definition: runtime_types.h:17
impeller::compiler::SourceTypeFromFileName
SourceType SourceTypeFromFileName(const std::string &file_name)
Definition: types.cc:29
impeller::kDouble
@ kDouble
Definition: runtime_types.h:25
impeller::compiler::TargetPlatform::kOpenGLDesktop
@ kOpenGLDesktop
impeller::kSignedInt64
@ kSignedInt64
Definition: runtime_types.h:21
impeller::compiler::TargetPlatform::kOpenGLES
@ kOpenGLES
impeller::compiler::CreateMSLCompiler
static CompilerBackend CreateMSLCompiler(const spirv_cross::ParsedIR &ir, const SourceOptions &source_options, std::optional< uint32_t > msl_version_override={})
Definition: compiler.cc:50
impeller::compiler::Utf8FromPath
std::string Utf8FromPath(const std::filesystem::path &path)
Converts a native format path to a utf8 string.
Definition: utilities.cc:14
impeller::compiler::TargetPlatform::kRuntimeStageMetal
@ kRuntimeStageMetal
impeller::compiler::BaseTypeToString
static std::string BaseTypeToString(spirv_cross::SPIRType::BaseType type)
Definition: reflector.cc:29
impeller::compiler::SourceType::kVertexShader
@ kVertexShader
impeller::compiler::StringStartsWith
bool StringStartsWith(const std::string &target, const std::string &prefix)
Definition: utilities.cc:64
impeller::compiler::TargetPlatformBundlesSkSL
bool TargetPlatformBundlesSkSL(TargetPlatform platform)
Definition: types.cc:317
impeller::compiler::SourceType::kTessellationEvaluationShader
@ kTessellationEvaluationShader
impeller::compiler::TypeNameWithPaddingOfSize
static std::string TypeNameWithPaddingOfSize(size_t size)
Definition: reflector.cc:521
impeller::compiler::TargetPlatform::kSkSL
@ kSkSL
impeller::compiler::TargetPlatform::kRuntimeStageGLES
@ kRuntimeStageGLES