Flutter Impeller
impeller::compiler Namespace Reference

Namespaces

 testing
 

Classes

class  AutoLogger
 
class  Compiler
 
struct  CompilerBackend
 
class  CompilerSkSL
 
struct  IncludeDir
 
class  Includer
 
struct  IncluderData
 
struct  InputDescription
 
struct  KnownType
 
class  Reflector
 
class  RuntimeStageData
 
class  ShaderBundleData
 
struct  ShaderConfig
 A shader config parsed as part of a ShaderBundleConfig. More...
 
struct  SourceOptions
 
class  SPIRVCompiler
 
struct  SPIRVCompilerOptions
 
struct  SPIRVCompilerSourceProfile
 
struct  SPIRVCompilerTargetEnv
 
struct  StructMember
 
class  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
 

Typedefs

using ShaderBundleConfig = std::unordered_map< std::string, ShaderConfig >
 

Enumerations

enum  SourceType {
  SourceType::kUnknown,
  SourceType::kVertexShader,
  SourceType::kFragmentShader,
  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 Reflector::Options CreateReflectorOptions (const SourceOptions &options, const Switches &switches)
 
static std::shared_ptr< RuntimeStageData::ShaderCompileSkSL (std::shared_ptr< fml::Mapping > source_file_mapping, const Switches &switches)
 
static bool OutputIPLR (const Switches &switches, const std::shared_ptr< fml::Mapping > &source_file_mapping)
 
static bool OutputSLFile (const Compiler &compiler, const Switches &switches)
 
static bool OutputReflectionData (const Compiler &compiler, const Switches &switches, const SourceOptions &options)
 
static bool OutputDepfile (const Compiler &compiler, const Switches &switches)
 
bool Main (const fml::CommandLine &command_line)
 
static std::string ExecutionModelToString (spv::ExecutionModel model)
 
static std::string StringToShaderStage (const std::string &str)
 
static std::optional< RuntimeStageBackendGetRuntimeStageBackend (TargetPlatform target_platform)
 
static std::string ToString (CompilerBackend::Type type)
 
static std::string TypeNameWithPaddingOfSize (size_t size)
 
static std::optional< KnownTypeReadKnownScalarType (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< fb::Stage > ToJsonStage (spv::ExecutionModel stage)
 
static std::optional< fb::UniformDataType > ToUniformType (spirv_cross::SPIRType::BaseType type)
 
static std::optional< fb::InputDataType > ToInputType (spirv_cross::SPIRType::BaseType type)
 
static std::optional< uint32_t > ToJsonType (spirv_cross::SPIRType::BaseType type)
 
static std::string RuntimeStageBackendToString (RuntimeStageBackend backend)
 
std::optional< ShaderBundleConfigParseShaderBundleConfig (const std::string &bundle_config_json, std::ostream &error_stream)
 Parse a shader bundle configuration from a given JSON string. More...
 
static std::unique_ptr< fb::shaderbundle::BackendShaderT > GenerateShaderBackendFB (TargetPlatform target_platform, SourceOptions &options, const std::string &shader_name, const ShaderConfig &shader_config)
 
static std::unique_ptr< fb::shaderbundle::ShaderT > GenerateShaderFB (SourceOptions options, const std::string &shader_name, const ShaderConfig &shader_config)
 
std::optional< fb::shaderbundle::ShaderBundleT > GenerateShaderBundleFlatbuffer (const std::string &bundle_config_json, const SourceOptions &options)
 Parses the JSON shader bundle configuration and invokes the compiler multiple times to produce a shader bundle flatbuffer. More...
 
bool GenerateShaderBundle (Switches &switches)
 Parses the JSON shader bundle configuration and invokes the compiler multiple times to produce a shader bundle flatbuffer, which is then output to the sl file. More...
 
static std::optional< fb::shaderbundle::ShaderStage > ToStage (spv::ExecutionModel stage)
 
static std::optional< fb::shaderbundle::UniformDataType > ToUniformType (spirv_cross::SPIRType::BaseType type)
 
static std::optional< fb::shaderbundle::InputDataType > ToInputType (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 std::vector< TargetPlatformRuntimeStagesFromCommandLine (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)
 
SourceType SourceTypeFromString (std::string name)
 
SourceLanguage ToSourceLanguage (const std::string &source_language)
 
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)
 
bool SetPermissiveAccess (const std::filesystem::path &p)
 Sets the file access mode of the file at path 'p' to 0644. More...
 
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 ToCamelCase (std::string_view string)
 
std::string ToLowerCase (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 = "shader"
 
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, TargetPlatformkKnownPlatforms
 
static const std::map< std::string, TargetPlatformkKnownRuntimeStages
 
static const std::map< std::string, SourceTypekKnownSourceTypes
 

Typedef Documentation

◆ ShaderBundleConfig

using impeller::compiler::ShaderBundleConfig = typedef std::unordered_map<std::string, ShaderConfig>

Definition at line 81 of file types.h.

Enumeration Type Documentation

◆ SourceLanguage

Enumerator
kUnknown 
kGLSL 
kHLSL 

Definition at line 42 of file types.h.

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

◆ SourceType

Enumerator
kUnknown 
kVertexShader 
kFragmentShader 
kComputeShader 

Definition at line 22 of file types.h.

22  {
23  kUnknown,
27 };

◆ TargetPlatform

Enumerator
kUnknown 
kMetalDesktop 
kMetalIOS 
kOpenGLES 
kOpenGLDesktop 
kVulkan 
kRuntimeStageMetal 
kRuntimeStageGLES 
kRuntimeStageVulkan 
kSkSL 

Definition at line 29 of file types.h.

29  {
30  kUnknown,
32  kMetalIOS,
33  kOpenGLES,
35  kVulkan,
39  kSkSL,
40 };

Function Documentation

◆ CompileSkSL()

static std::shared_ptr<RuntimeStageData::Shader> impeller::compiler::CompileSkSL ( std::shared_ptr< fml::Mapping >  source_file_mapping,
const Switches switches 
)
static

Run the shader compiler to geneate SkSL reflection data. If there is an error, prints error text and returns nullptr.

Definition at line 37 of file impellerc_main.cc.

39  {
40  auto options = switches.CreateSourceOptions(TargetPlatform::kSkSL);
41 
42  Reflector::Options sksl_reflector_options =
43  CreateReflectorOptions(options, switches);
44  sksl_reflector_options.target_platform = TargetPlatform::kSkSL;
45 
46  Compiler sksl_compiler =
47  Compiler(std::move(source_file_mapping), options, sksl_reflector_options);
48  if (!sksl_compiler.IsValid()) {
49  std::cerr << "Compilation to SkSL failed." << std::endl;
50  std::cerr << sksl_compiler.GetErrorMessages() << std::endl;
51  return nullptr;
52  }
53  return sksl_compiler.GetReflector()->GetRuntimeStageShaderData();
54 }

References CreateReflectorOptions(), impeller::compiler::Switches::CreateSourceOptions(), impeller::compiler::Compiler::GetErrorMessages(), impeller::compiler::Compiler::GetReflector(), impeller::compiler::Reflector::GetRuntimeStageShaderData(), impeller::compiler::Compiler::IsValid(), kSkSL, and impeller::compiler::Reflector::Options::target_platform.

Referenced by OutputIPLR().

◆ 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 69 of file utilities.cc.

69  {
70  if (string.empty()) {
71  return "";
72  }
73  std::stringstream stream;
74  // Append a prefix if the first character is not a letter.
75  if (!std::isalpha(string.data()[0])) {
76  stream << "i_";
77  }
78  for (size_t i = 0, count = string.length(); i < count; i++) {
79  auto ch = string.data()[i];
80  if (std::isalnum(ch) || ch == '_') {
81  stream << ch;
82  }
83  }
84  return stream.str();
85 }

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 210 of file compiler.cc.

211  {
212  CompilerBackend compiler;
213  switch (source_options.target_platform) {
214  case TargetPlatform::kMetalDesktop:
215  case TargetPlatform::kMetalIOS:
216  case TargetPlatform::kRuntimeStageMetal:
217  compiler = CreateMSLCompiler(ir, source_options);
218  break;
219  case TargetPlatform::kVulkan:
220  case TargetPlatform::kRuntimeStageVulkan:
221  compiler = CreateVulkanCompiler(ir, source_options);
222  break;
223  case TargetPlatform::kUnknown:
224  case TargetPlatform::kOpenGLES:
225  case TargetPlatform::kOpenGLDesktop:
226  case TargetPlatform::kRuntimeStageGLES:
227  compiler = CreateGLSLCompiler(ir, source_options);
228  break;
229  case TargetPlatform::kSkSL:
230  compiler = CreateSkSLCompiler(ir, source_options);
231  }
232  if (!compiler) {
233  return {};
234  }
235  auto* backend = compiler.GetCompiler();
236  if (!EntryPointMustBeNamedMain(source_options.target_platform) &&
237  source_options.source_language == SourceLanguage::kGLSL) {
238  backend->rename_entry_point("main", source_options.entry_point_name,
239  ToExecutionModel(source_options.type));
240  }
241  return compiler;
242 }

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 135 of file compiler.cc.

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

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

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 52 of file compiler.cc.

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

Referenced by CreateCompiler().

◆ CreateReflectorOptions()

static Reflector::Options impeller::compiler::CreateReflectorOptions ( const SourceOptions options,
const Switches switches 
)
static

Definition at line 23 of file impellerc_main.cc.

24  {
25  Reflector::Options reflector_options;
26  reflector_options.target_platform = options.target_platform;
27  reflector_options.entry_point_name = options.entry_point_name;
28  reflector_options.shader_name =
29  InferShaderNameFromPath(switches.source_file_name);
30  reflector_options.header_file_name = Utf8FromPath(
31  std::filesystem::path{switches.reflection_header_name}.filename());
32  return reflector_options;
33 }

References impeller::compiler::SourceOptions::entry_point_name, impeller::compiler::Reflector::Options::entry_point_name, impeller::compiler::Reflector::Options::header_file_name, InferShaderNameFromPath(), impeller::compiler::Switches::reflection_header_name, impeller::compiler::Reflector::Options::shader_name, impeller::compiler::Switches::source_file_name, impeller::compiler::SourceOptions::target_platform, impeller::compiler::Reflector::Options::target_platform, and Utf8FromPath().

Referenced by CompileSkSL(), Main(), and OutputIPLR().

◆ CreateSkSLCompiler()

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

Definition at line 185 of file compiler.cc.

186  {
187  auto sksl_compiler = std::make_shared<CompilerSkSL>(ir);
188  return CompilerBackend(sksl_compiler);
189 }

Referenced by CreateCompiler().

◆ CreateVulkanCompiler()

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

Definition at line 123 of file compiler.cc.

125  {
126  auto gl_compiler = std::make_shared<spirv_cross::CompilerGLSL>(ir);
127  spirv_cross::CompilerGLSL::Options sl_options;
128  sl_options.force_zero_initialized_variables = true;
129  sl_options.vertex.fixup_clipspace = true;
130  sl_options.vulkan_semantics = true;
131  gl_compiler->set_common_options(sl_options);
132  return CompilerBackend(gl_compiler);
133 }

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 111 of file types.cc.

115  {
116  if (source_language == SourceLanguage::kHLSL) {
117  return entry_point_name;
118  }
119 
120  std::stringstream stream;
121  std::filesystem::path file_path(file_name);
122  stream << ConvertToEntrypointName(Utf8FromPath(file_path.stem())) << "_";
123  switch (type) {
124  case SourceType::kUnknown:
125  stream << "unknown";
126  break;
127  case SourceType::kVertexShader:
128  stream << "vertex";
129  break;
130  case SourceType::kFragmentShader:
131  stream << "fragment";
132  break;
133  case SourceType::kComputeShader:
134  stream << "compute";
135  break;
136  }
137  stream << "_main";
138  return stream.str();
139 }

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

Referenced by impeller::compiler::testing::CompilerTest::CanCompileAndReflect(), impeller::compiler::Switches::CreateSourceOptions(), and GenerateShaderBackendFB().

◆ EntryPointMustBeNamedMain()

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

Definition at line 191 of file compiler.cc.

191  {
192  switch (platform) {
193  case TargetPlatform::kUnknown:
194  FML_UNREACHABLE();
195  case TargetPlatform::kMetalDesktop:
196  case TargetPlatform::kMetalIOS:
197  case TargetPlatform::kVulkan:
198  case TargetPlatform::kRuntimeStageMetal:
199  case TargetPlatform::kRuntimeStageVulkan:
200  return false;
201  case TargetPlatform::kSkSL:
202  case TargetPlatform::kOpenGLES:
203  case TargetPlatform::kOpenGLDesktop:
204  case TargetPlatform::kRuntimeStageGLES:
205  return true;
206  }
207  FML_UNREACHABLE();
208 }

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 33 of file reflector.cc.

33  {
34  switch (model) {
35  case spv::ExecutionModel::ExecutionModelVertex:
36  return "vertex";
37  case spv::ExecutionModel::ExecutionModelFragment:
38  return "fragment";
39  case spv::ExecutionModel::ExecutionModelGLCompute:
40  return "compute";
41  default:
42  return "unsupported";
43  }
44 }

◆ GenerateShaderBackendFB()

static std::unique_ptr<fb::shaderbundle::BackendShaderT> impeller::compiler::GenerateShaderBackendFB ( TargetPlatform  target_platform,
SourceOptions options,
const std::string &  shader_name,
const ShaderConfig shader_config 
)
static

Override options.

Definition at line 85 of file shader_bundle.cc.

88  {
89  auto result = std::make_unique<fb::shaderbundle::BackendShaderT>();
90 
91  std::shared_ptr<fml::FileMapping> source_file_mapping =
92  fml::FileMapping::CreateReadOnly(shader_config.source_file_name);
93  if (!source_file_mapping) {
94  std::cerr << "Could not open file for bundled shader \"" << shader_name
95  << "\"." << std::endl;
96  return nullptr;
97  }
98 
99  /// Override options.
100  options.target_platform = target_platform;
101  options.file_name = shader_name; // This is just used for error messages.
102  options.type = shader_config.type;
103  options.source_language = shader_config.language;
104  options.entry_point_name = EntryPointFunctionNameFromSourceName(
105  shader_config.source_file_name, options.type, options.source_language,
106  shader_config.entry_point);
107 
108  Reflector::Options reflector_options;
109  reflector_options.target_platform = options.target_platform;
110  reflector_options.entry_point_name = options.entry_point_name;
111  reflector_options.shader_name = shader_name;
112 
113  Compiler compiler(source_file_mapping, options, reflector_options);
114  if (!compiler.IsValid()) {
115  std::cerr << "Compilation failed for bundled shader \"" << shader_name
116  << "\"." << std::endl;
117  std::cerr << compiler.GetErrorMessages() << std::endl;
118  return nullptr;
119  }
120 
121  auto reflector = compiler.GetReflector();
122  if (reflector == nullptr) {
123  std::cerr << "Could not create reflector for bundled shader \""
124  << shader_name << "\"." << std::endl;
125  return nullptr;
126  }
127 
128  auto bundle_data = reflector->GetShaderBundleData();
129  if (!bundle_data) {
130  std::cerr << "Bundled shader information was nil for \"" << shader_name
131  << "\"." << std::endl;
132  return nullptr;
133  }
134 
135  result = bundle_data->CreateFlatbuffer();
136  if (!result) {
137  std::cerr << "Failed to create flatbuffer for bundled shader \""
138  << shader_name << "\"." << std::endl;
139  return nullptr;
140  }
141 
142  return result;
143 }

References impeller::compiler::ShaderConfig::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::Compiler::GetReflector(), impeller::compiler::Reflector::GetShaderBundleData(), impeller::compiler::Compiler::IsValid(), impeller::compiler::ShaderConfig::language, impeller::compiler::Reflector::Options::shader_name, impeller::compiler::ShaderConfig::source_file_name, impeller::compiler::SourceOptions::source_language, impeller::compiler::SourceOptions::target_platform, impeller::compiler::Reflector::Options::target_platform, impeller::compiler::SourceOptions::type, and impeller::compiler::ShaderConfig::type.

Referenced by GenerateShaderFB().

◆ GenerateShaderBundle()

bool impeller::compiler::GenerateShaderBundle ( Switches switches)

Parses the JSON shader bundle configuration and invokes the compiler multiple times to produce a shader bundle flatbuffer, which is then output to the sl file.

  1. Parse the shader bundle and generate the flatbuffer result.
  2. Serialize the shader bundle and write to disk.

Definition at line 210 of file shader_bundle.cc.

210  {
211  // --------------------------------------------------------------------------
212  /// 1. Parse the shader bundle and generate the flatbuffer result.
213  ///
214 
215  auto shader_bundle = GenerateShaderBundleFlatbuffer(
216  switches.shader_bundle, switches.CreateSourceOptions());
217  if (!shader_bundle.has_value()) {
218  // Specific error messages are already handled by
219  // GenerateShaderBundleFlatbuffer.
220  return false;
221  }
222 
223  // --------------------------------------------------------------------------
224  /// 2. Serialize the shader bundle and write to disk.
225  ///
226 
227  auto builder = std::make_shared<flatbuffers::FlatBufferBuilder>();
228  builder->Finish(fb::shaderbundle::ShaderBundle::Pack(*builder.get(),
229  &shader_bundle.value()),
230  fb::shaderbundle::ShaderBundleIdentifier());
231  auto mapping = std::make_shared<fml::NonOwnedMapping>(
232  builder->GetBufferPointer(), builder->GetSize(),
233  [builder](auto, auto) {});
234 
235  auto sl_file_name = std::filesystem::absolute(
236  std::filesystem::current_path() / switches.sl_file_name);
237 
238  if (!fml::WriteAtomically(*switches.working_directory, //
239  Utf8FromPath(sl_file_name).c_str(), //
240  *mapping //
241  )) {
242  std::cerr << "Could not write file to " << switches.sl_file_name
243  << std::endl;
244  return false;
245  }
246  // Tools that consume the runtime stage data expect the access mode to
247  // be 0644.
248  if (!SetPermissiveAccess(sl_file_name)) {
249  return false;
250  }
251 
252  return true;
253 }

References impeller::compiler::Switches::CreateSourceOptions(), GenerateShaderBundleFlatbuffer(), SetPermissiveAccess(), impeller::compiler::Switches::shader_bundle, impeller::compiler::Switches::sl_file_name, Utf8FromPath(), and impeller::compiler::Switches::working_directory.

Referenced by Main().

◆ GenerateShaderBundleFlatbuffer()

std::optional< fb::shaderbundle::ShaderBundleT > impeller::compiler::GenerateShaderBundleFlatbuffer ( const std::string &  bundle_config_json,
const SourceOptions options 
)

Parses the JSON shader bundle configuration and invokes the compiler multiple times to produce a shader bundle flatbuffer.

Note
Exposed only for testing purposes. Use GenerateShaderBundle directly.
  1. Parse the bundle configuration.
  2. Build the deserialized shader bundle.

Definition at line 179 of file shader_bundle.cc.

181  {
182  // --------------------------------------------------------------------------
183  /// 1. Parse the bundle configuration.
184  ///
185 
186  std::optional<ShaderBundleConfig> bundle_config =
187  ParseShaderBundleConfig(bundle_config_json, std::cerr);
188  if (!bundle_config) {
189  return std::nullopt;
190  }
191 
192  // --------------------------------------------------------------------------
193  /// 2. Build the deserialized shader bundle.
194  ///
195 
196  fb::shaderbundle::ShaderBundleT shader_bundle;
197 
198  for (const auto& [shader_name, shader_config] : bundle_config.value()) {
199  std::unique_ptr<fb::shaderbundle::ShaderT> shader =
200  GenerateShaderFB(options, shader_name, shader_config);
201  if (!shader) {
202  return std::nullopt;
203  }
204  shader_bundle.shaders.push_back(std::move(shader));
205  }
206 
207  return shader_bundle;
208 }

References GenerateShaderFB(), and ParseShaderBundleConfig().

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

◆ GenerateShaderFB()

static std::unique_ptr<fb::shaderbundle::ShaderT> impeller::compiler::GenerateShaderFB ( SourceOptions  options,
const std::string &  shader_name,
const ShaderConfig shader_config 
)
static

Definition at line 145 of file shader_bundle.cc.

148  {
149  auto result = std::make_unique<fb::shaderbundle::ShaderT>();
150  result->name = shader_name;
151  result->metal_ios = GenerateShaderBackendFB(
152  TargetPlatform::kMetalIOS, options, shader_name, shader_config);
153  if (!result->metal_ios) {
154  return nullptr;
155  }
156  result->metal_desktop = GenerateShaderBackendFB(
157  TargetPlatform::kMetalDesktop, options, shader_name, shader_config);
158  if (!result->metal_desktop) {
159  return nullptr;
160  }
161  result->opengl_es = GenerateShaderBackendFB(
162  TargetPlatform::kOpenGLES, options, shader_name, shader_config);
163  if (!result->opengl_es) {
164  return nullptr;
165  }
166  result->opengl_desktop = GenerateShaderBackendFB(
167  TargetPlatform::kOpenGLDesktop, options, shader_name, shader_config);
168  if (!result->opengl_desktop) {
169  return nullptr;
170  }
171  result->vulkan = GenerateShaderBackendFB(TargetPlatform::kVulkan, options,
172  shader_name, shader_config);
173  if (!result->vulkan) {
174  return nullptr;
175  }
176  return result;
177 }

References GenerateShaderBackendFB(), kMetalDesktop, kMetalIOS, kOpenGLDesktop, kOpenGLES, and kVulkan.

Referenced by GenerateShaderBundleFlatbuffer().

◆ 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]membersThe members
Returns
The reflected structure size.

Definition at line 778 of file reflector.cc.

778  {
779  auto struct_size = 0u;
780  for (const auto& member : members) {
781  struct_size += member.byte_length;
782  }
783  return struct_size;
784 }

◆ GetRuntimeStageBackend()

static std::optional<RuntimeStageBackend> impeller::compiler::GetRuntimeStageBackend ( TargetPlatform  target_platform)
static

Definition at line 301 of file reflector.cc.

302  {
303  switch (target_platform) {
304  case TargetPlatform::kUnknown:
305  case TargetPlatform::kMetalDesktop:
306  case TargetPlatform::kMetalIOS:
307  case TargetPlatform::kOpenGLES:
308  case TargetPlatform::kOpenGLDesktop:
309  case TargetPlatform::kVulkan:
310  return std::nullopt;
311  case TargetPlatform::kRuntimeStageMetal:
312  return RuntimeStageBackend::kMetal;
313  case TargetPlatform::kRuntimeStageGLES:
314  return RuntimeStageBackend::kOpenGLES;
315  case TargetPlatform::kRuntimeStageVulkan:
316  return RuntimeStageBackend::kVulkan;
317  case TargetPlatform::kSkSL:
318  return RuntimeStageBackend::kSkSL;
319  }
320  FML_UNREACHABLE();
321 }

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

◆ InferShaderNameFromPath()

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

Definition at line 34 of file utilities.cc.

34  {
35  auto p = std::filesystem::path{path}.stem();
36  return Utf8FromPath(p);
37 }

References Utf8FromPath().

Referenced by CreateReflectorOptions().

◆ JoinStrings()

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

Definition at line 463 of file compiler.cc.

464  {
465  std::stringstream stream;
466  for (size_t i = 0, count = items.size(); i < count; i++) {
467  const auto is_last = (i == count - 1);
468 
469  stream << items[i];
470  if (!is_last) {
471  stream << separator;
472  }
473  }
474  return stream.str();
475 }

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

◆ Main()

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

Definition at line 233 of file impellerc_main.cc.

233  {
234  fml::InstallCrashHandler();
235  if (command_line.HasOption("help")) {
236  Switches::PrintHelp(std::cout);
237  return true;
238  }
239 
240  Switches switches(command_line);
241  if (!switches.AreValid(std::cerr)) {
242  std::cerr << "Invalid flags specified." << std::endl;
243  Switches::PrintHelp(std::cerr);
244  return false;
245  }
246 
247  if (!switches.shader_bundle.empty()) {
248  // Invoke the compiler multiple times to build a shader bundle with the
249  // given shader_bundle spec.
250  return GenerateShaderBundle(switches);
251  }
252 
253  std::shared_ptr<fml::FileMapping> source_file_mapping =
254  fml::FileMapping::CreateReadOnly(switches.source_file_name);
255  if (!source_file_mapping) {
256  std::cerr << "Could not open input file." << std::endl;
257  return false;
258  }
259 
260  if (switches.iplr && !OutputIPLR(switches, source_file_mapping)) {
261  return false;
262  }
263 
264  // Create at least one compiler to output the SL file, reflection data, and a
265  // depfile.
266  // TODO(dnfield): This seems off. We should more explicitly handle how we
267  // generate reflection and depfile data for the runtime stage case.
268  // https://github.com/flutter/flutter/issues/140841
269 
270  SourceOptions options = switches.CreateSourceOptions();
271 
272  // Invoke the compiler and generate reflection data for a single shader.
273 
274  Reflector::Options reflector_options =
275  CreateReflectorOptions(options, switches);
276 
277  Compiler compiler(source_file_mapping, options, reflector_options);
278  if (!compiler.IsValid()) {
279  std::cerr << "Compilation failed." << std::endl;
280  std::cerr << compiler.GetErrorMessages() << std::endl;
281  return false;
282  }
283 
284  auto spriv_file_name = std::filesystem::absolute(
285  std::filesystem::current_path() / switches.spirv_file_name);
286  if (!fml::WriteAtomically(*switches.working_directory,
287  Utf8FromPath(spriv_file_name).c_str(),
288  *compiler.GetSPIRVAssembly())) {
289  std::cerr << "Could not write file to " << switches.spirv_file_name
290  << std::endl;
291  return false;
292  }
293 
294  if (!switches.iplr && !OutputSLFile(compiler, switches)) {
295  return false;
296  }
297 
298  if (!OutputReflectionData(compiler, switches, options)) {
299  return false;
300  }
301 
302  if (!OutputDepfile(compiler, switches)) {
303  return false;
304  }
305 
306  return true;
307 }

References impeller::compiler::Switches::AreValid(), CreateReflectorOptions(), impeller::compiler::Switches::CreateSourceOptions(), GenerateShaderBundle(), impeller::compiler::Compiler::GetErrorMessages(), impeller::compiler::Compiler::GetSPIRVAssembly(), impeller::compiler::Switches::iplr, impeller::compiler::Compiler::IsValid(), OutputDepfile(), OutputIPLR(), OutputReflectionData(), OutputSLFile(), impeller::compiler::Switches::PrintHelp(), impeller::compiler::Switches::shader_bundle, impeller::compiler::Switches::source_file_name, impeller::compiler::Switches::spirv_file_name, Utf8FromPath(), and impeller::compiler::Switches::working_directory.

Referenced by main().

◆ OutputDepfile()

static bool impeller::compiler::OutputDepfile ( const Compiler compiler,
const Switches switches 
)
static
  1. Output a depfile.

Definition at line 196 of file impellerc_main.cc.

196  {
197  // --------------------------------------------------------------------------
198  /// 4. Output a depfile.
199  ///
200 
201  if (!switches.depfile_path.empty()) {
202  std::string result_file;
203  switch (switches.SelectDefaultTargetPlatform()) {
204  case TargetPlatform::kMetalDesktop:
205  case TargetPlatform::kMetalIOS:
206  case TargetPlatform::kOpenGLES:
207  case TargetPlatform::kOpenGLDesktop:
208  case TargetPlatform::kRuntimeStageMetal:
209  case TargetPlatform::kRuntimeStageGLES:
210  case TargetPlatform::kRuntimeStageVulkan:
211  case TargetPlatform::kSkSL:
212  case TargetPlatform::kVulkan:
213  result_file = switches.sl_file_name;
214  break;
215  case TargetPlatform::kUnknown:
216  result_file = switches.spirv_file_name;
217  break;
218  }
219  auto depfile_path = std::filesystem::absolute(
220  std::filesystem::current_path() / switches.depfile_path.c_str());
221  if (!fml::WriteAtomically(*switches.working_directory,
222  Utf8FromPath(depfile_path).c_str(),
223  *compiler.CreateDepfileContents({result_file}))) {
224  std::cerr << "Could not write depfile to " << switches.depfile_path
225  << std::endl;
226  return false;
227  }
228  }
229 
230  return true;
231 }

References impeller::compiler::Compiler::CreateDepfileContents(), impeller::compiler::Switches::depfile_path, kMetalDesktop, kMetalIOS, kOpenGLDesktop, kOpenGLES, kRuntimeStageGLES, kRuntimeStageMetal, kRuntimeStageVulkan, kSkSL, kUnknown, kVulkan, impeller::compiler::Switches::SelectDefaultTargetPlatform(), impeller::compiler::Switches::sl_file_name, impeller::compiler::Switches::spirv_file_name, Utf8FromPath(), and impeller::compiler::Switches::working_directory.

Referenced by Main().

◆ OutputIPLR()

static bool impeller::compiler::OutputIPLR ( const Switches switches,
const std::shared_ptr< fml::Mapping > &  source_file_mapping 
)
static

Definition at line 56 of file impellerc_main.cc.

58  {
59  FML_DCHECK(switches.iplr);
60 
61  RuntimeStageData stages;
62  std::shared_ptr<RuntimeStageData::Shader> sksl_shader;
63  if (TargetPlatformBundlesSkSL(switches.SelectDefaultTargetPlatform())) {
64  sksl_shader = CompileSkSL(source_file_mapping, switches);
65  if (!sksl_shader) {
66  return false;
67  }
68  stages.AddShader(sksl_shader);
69  }
70 
71  for (const auto& platform : switches.PlatformsToCompile()) {
72  if (platform == TargetPlatform::kSkSL) {
73  // Already handled above.
74  continue;
75  }
76  SourceOptions options = switches.CreateSourceOptions(platform);
77 
78  // Invoke the compiler and generate reflection data for a single shader.
79 
80  Reflector::Options reflector_options =
81  CreateReflectorOptions(options, switches);
82  Compiler compiler(source_file_mapping, options, reflector_options);
83  if (!compiler.IsValid()) {
84  std::cerr << "Compilation failed." << std::endl;
85  std::cerr << compiler.GetErrorMessages() << std::endl;
86  return false;
87  }
88 
89  auto reflector = compiler.GetReflector();
90  if (reflector == nullptr) {
91  std::cerr << "Could not create reflector." << std::endl;
92  return false;
93  }
94 
95  auto stage_data = reflector->GetRuntimeStageShaderData();
96  if (!stage_data) {
97  std::cerr << "Runtime stage information was nil." << std::endl;
98  return false;
99  }
100 
101  stages.AddShader(stage_data);
102  }
103 
104  auto stage_data_mapping = switches.json_format ? stages.CreateJsonMapping()
105  : stages.CreateMapping();
106  if (!stage_data_mapping) {
107  std::cerr << "Runtime stage data could not be created." << std::endl;
108  return false;
109  }
110  if (!fml::WriteAtomically(*switches.working_directory, //
111  Utf8FromPath(switches.sl_file_name).c_str(), //
112  *stage_data_mapping //
113  )) {
114  std::cerr << "Could not write file to " << switches.sl_file_name
115  << std::endl;
116  return false;
117  }
118  // Tools that consume the runtime stage data expect the access mode to
119  // be 0644.
120  if (!SetPermissiveAccess(switches.sl_file_name)) {
121  return false;
122  }
123  return true;
124 }

References impeller::compiler::RuntimeStageData::AddShader(), CompileSkSL(), impeller::compiler::RuntimeStageData::CreateJsonMapping(), impeller::compiler::RuntimeStageData::CreateMapping(), CreateReflectorOptions(), impeller::compiler::Switches::CreateSourceOptions(), impeller::compiler::Compiler::GetErrorMessages(), impeller::compiler::Compiler::GetReflector(), impeller::compiler::Reflector::GetRuntimeStageShaderData(), impeller::compiler::Switches::iplr, impeller::compiler::Compiler::IsValid(), impeller::compiler::Switches::json_format, kSkSL, impeller::compiler::Switches::PlatformsToCompile(), impeller::compiler::Switches::SelectDefaultTargetPlatform(), SetPermissiveAccess(), impeller::compiler::Switches::sl_file_name, TargetPlatformBundlesSkSL(), Utf8FromPath(), and impeller::compiler::Switches::working_directory.

Referenced by Main().

◆ OutputReflectionData()

static bool impeller::compiler::OutputReflectionData ( const Compiler compiler,
const Switches switches,
const SourceOptions options 
)
static
  1. Output shader reflection data. May include a JSON file, a C++ header, and/or a C++ TU.

Definition at line 144 of file impellerc_main.cc.

146  {
147  // --------------------------------------------------------------------------
148  /// 3. Output shader reflection data.
149  /// May include a JSON file, a C++ header, and/or a C++ TU.
150  ///
151 
152  if (TargetPlatformNeedsReflection(options.target_platform)) {
153  if (!switches.reflection_json_name.empty()) {
154  auto reflection_json_name = std::filesystem::absolute(
155  std::filesystem::current_path() / switches.reflection_json_name);
156  if (!fml::WriteAtomically(
157  *switches.working_directory,
158  Utf8FromPath(reflection_json_name).c_str(),
159  *compiler.GetReflector()->GetReflectionJSON())) {
160  std::cerr << "Could not write reflection json to "
161  << switches.reflection_json_name << std::endl;
162  return false;
163  }
164  }
165 
166  if (!switches.reflection_header_name.empty()) {
167  auto reflection_header_name =
168  std::filesystem::absolute(std::filesystem::current_path() /
169  switches.reflection_header_name.c_str());
170  if (!fml::WriteAtomically(
171  *switches.working_directory,
172  Utf8FromPath(reflection_header_name).c_str(),
173  *compiler.GetReflector()->GetReflectionHeader())) {
174  std::cerr << "Could not write reflection header to "
175  << switches.reflection_header_name << std::endl;
176  return false;
177  }
178  }
179 
180  if (!switches.reflection_cc_name.empty()) {
181  auto reflection_cc_name =
182  std::filesystem::absolute(std::filesystem::current_path() /
183  switches.reflection_cc_name.c_str());
184  if (!fml::WriteAtomically(*switches.working_directory,
185  Utf8FromPath(reflection_cc_name).c_str(),
186  *compiler.GetReflector()->GetReflectionCC())) {
187  std::cerr << "Could not write reflection CC to "
188  << switches.reflection_cc_name << std::endl;
189  return false;
190  }
191  }
192  }
193  return true;
194 }

References impeller::compiler::Reflector::GetReflectionCC(), impeller::compiler::Reflector::GetReflectionHeader(), impeller::compiler::Reflector::GetReflectionJSON(), impeller::compiler::Compiler::GetReflector(), impeller::compiler::Switches::reflection_cc_name, impeller::compiler::Switches::reflection_header_name, impeller::compiler::Switches::reflection_json_name, impeller::compiler::SourceOptions::target_platform, TargetPlatformNeedsReflection(), Utf8FromPath(), and impeller::compiler::Switches::working_directory.

Referenced by Main().

◆ OutputSLFile()

static bool impeller::compiler::OutputSLFile ( const Compiler compiler,
const Switches switches 
)
static
  1. Output the source file. When in IPLR/RuntimeStage mode, output the serialized IPLR flatbuffer.

Definition at line 126 of file impellerc_main.cc.

126  {
127  // --------------------------------------------------------------------------
128  /// 2. Output the source file. When in IPLR/RuntimeStage mode, output the
129  /// serialized IPLR flatbuffer.
130  ///
131 
132  auto sl_file_name = std::filesystem::absolute(
133  std::filesystem::current_path() / switches.sl_file_name);
134  if (!fml::WriteAtomically(*switches.working_directory,
135  Utf8FromPath(sl_file_name).c_str(),
136  *compiler.GetSLShaderSource())) {
137  std::cerr << "Could not write file to " << switches.sl_file_name
138  << std::endl;
139  return false;
140  }
141  return true;
142 }

References impeller::compiler::Compiler::GetSLShaderSource(), impeller::compiler::Switches::sl_file_name, Utf8FromPath(), and impeller::compiler::Switches::working_directory.

Referenced by Main().

◆ ParseMSLVersion()

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

Definition at line 29 of file compiler.cc.

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

◆ ParseShaderBundleConfig()

std::optional< ShaderBundleConfig > impeller::compiler::ParseShaderBundleConfig ( const std::string &  bundle_config_json,
std::ostream &  error_stream 
)

Parse a shader bundle configuration from a given JSON string.

Note
Exposed only for testing purposes. Use GenerateShaderBundle directly.

Definition at line 19 of file shader_bundle.cc.

21  {
22  auto json = nlohmann::json::parse(bundle_config_json, nullptr, false);
23  if (json.is_discarded() || !json.is_object()) {
24  error_stream << "The shader bundle is not a valid JSON object."
25  << std::endl;
26  return std::nullopt;
27  }
28 
29  ShaderBundleConfig bundle;
30  for (auto& [shader_name, shader_value] : json.items()) {
31  if (bundle.find(shader_name) != bundle.end()) {
32  error_stream << "Duplicate shader \"" << shader_name << "\"."
33  << std::endl;
34  return std::nullopt;
35  }
36  if (!shader_value.is_object()) {
37  error_stream << "Invalid shader entry \"" << shader_name
38  << "\": Entry is not a JSON object." << std::endl;
39  return std::nullopt;
40  }
41 
42  ShaderConfig shader;
43 
44  if (!shader_value.contains("file")) {
45  error_stream << "Invalid shader entry \"" << shader_name
46  << "\": Missing required \"file\" field." << std::endl;
47  return std::nullopt;
48  }
49  shader.source_file_name = shader_value["file"];
50 
51  if (!shader_value.contains("type")) {
52  error_stream << "Invalid shader entry \"" << shader_name
53  << "\": Missing required \"type\" field." << std::endl;
54  return std::nullopt;
55  }
56  shader.type = SourceTypeFromString(shader_value["type"]);
57  if (shader.type == SourceType::kUnknown) {
58  error_stream << "Invalid shader entry \"" << shader_name
59  << "\": Shader type " << shader_value["type"]
60  << " is unknown." << std::endl;
61  return std::nullopt;
62  }
63 
64  shader.language = shader_value.contains("language")
65  ? ToSourceLanguage(shader_value["language"])
67  if (shader.language == SourceLanguage::kUnknown) {
68  error_stream << "Invalid shader entry \"" << shader_name
69  << "\": Unknown language type " << shader_value["language"]
70  << "." << std::endl;
71  return std::nullopt;
72  }
73 
74  shader.entry_point = shader_value.contains("entry_point")
75  ? shader_value["entry_point"]
76  : "main";
77 
78  bundle[shader_name] = shader;
79  }
80 
81  return bundle;
82 }

References impeller::compiler::ShaderConfig::entry_point, kGLSL, kUnknown, impeller::compiler::ShaderConfig::language, impeller::compiler::ShaderConfig::source_file_name, SourceTypeFromString(), ToSourceLanguage(), and impeller::compiler::ShaderConfig::type.

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

◆ ReadKnownScalarType()

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

Definition at line 731 of file reflector.cc.

732  {
733  switch (type) {
734  case spirv_cross::SPIRType::BaseType::Boolean:
735  return KnownType{
736  .name = "bool",
737  .byte_size = sizeof(bool),
738  };
739  case spirv_cross::SPIRType::BaseType::Float:
740  return KnownType{
741  .name = "Scalar",
742  .byte_size = sizeof(Scalar),
743  };
744  case spirv_cross::SPIRType::BaseType::Half:
745  return KnownType{
746  .name = "Half",
747  .byte_size = sizeof(Half),
748  };
749  case spirv_cross::SPIRType::BaseType::UInt:
750  return KnownType{
751  .name = "uint32_t",
752  .byte_size = sizeof(uint32_t),
753  };
754  case spirv_cross::SPIRType::BaseType::Int:
755  return KnownType{
756  .name = "int32_t",
757  .byte_size = sizeof(int32_t),
758  };
759  default:
760  break;
761  }
762  return std::nullopt;
763 }

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 }

◆ RuntimeStageBackendToString()

static std::string impeller::compiler::RuntimeStageBackendToString ( RuntimeStageBackend  backend)
static

Definition at line 197 of file runtime_stage_data.cc.

197  {
198  switch (backend) {
199  case RuntimeStageBackend::kSkSL:
200  return "sksl";
201  case RuntimeStageBackend::kMetal:
202  return "metal";
203  case RuntimeStageBackend::kOpenGLES:
204  return "opengles";
205  case RuntimeStageBackend::kVulkan:
206  return "vulkan";
207  }
208 }

References impeller::kMetal, impeller::kOpenGLES, impeller::kSkSL, and impeller::kVulkan.

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

◆ RuntimeStagesFromCommandLine()

static std::vector<TargetPlatform> impeller::compiler::RuntimeStagesFromCommandLine ( const fml::CommandLine &  command_line)
static

Definition at line 137 of file switches.cc.

138  {
139  std::vector<TargetPlatform> stages;
140  for (const auto& platform : kKnownRuntimeStages) {
141  if (command_line.HasOption(platform.first)) {
142  stages.push_back(platform.second);
143  }
144  }
145  return stages;
146 }

References kKnownRuntimeStages.

◆ 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()

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

Sets the file access mode of the file at path 'p' to 0644.

Definition at line 16 of file utilities.cc.

16  {
17  auto permissions =
18  std::filesystem::perms::owner_read | std::filesystem::perms::owner_write |
19  std::filesystem::perms::group_read | std::filesystem::perms::others_read;
20  std::error_code error;
21  std::filesystem::permissions(p, permissions, error);
22  if (error) {
23  std::cerr << "Failed to set access on file '" << p
24  << "': " << error.message() << std::endl;
25  return false;
26  }
27  return true;
28 }

Referenced by GenerateShaderBundle(), and OutputIPLR().

◆ ShaderCErrorToString()

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

Definition at line 159 of file types.cc.

159  {
160  using Status = shaderc_compilation_status;
161  switch (status) {
162  case Status::shaderc_compilation_status_success:
163  return "Success";
164  case Status::shaderc_compilation_status_invalid_stage:
165  return "Invalid shader stage specified";
166  case Status::shaderc_compilation_status_compilation_error:
167  return "Compilation error";
168  case Status::shaderc_compilation_status_internal_error:
169  return "Internal error";
170  case Status::shaderc_compilation_status_null_result_object:
171  return "Internal error. Null result object";
172  case Status::shaderc_compilation_status_invalid_assembly:
173  return "Invalid assembly";
174  case Status::shaderc_compilation_status_validation_error:
175  return "Validation error";
176  case Status::shaderc_compilation_status_transformation_error:
177  return "Transform error";
178  case Status::shaderc_compilation_status_configuration_error:
179  return "Configuration error";
180  }
181  return "Unknown internal error";
182 }

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

◆ SourceLanguageToString()

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

Definition at line 100 of file types.cc.

100  {
101  switch (source_language) {
102  case SourceLanguage::kUnknown:
103  return "Unknown";
104  case SourceLanguage::kGLSL:
105  return "GLSL";
106  case SourceLanguage::kHLSL:
107  return "HLSL";
108  }
109 }

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 148 of file switches.cc.

149  {
150  auto source_type_option =
151  command_line.GetOptionValueWithDefault("input-type", "");
152  auto source_type_search = kKnownSourceTypes.find(source_type_option);
153  if (source_type_search == kKnownSourceTypes.end()) {
154  return SourceType::kUnknown;
155  }
156  return source_type_search->second;
157 }

References kKnownSourceTypes, and kUnknown.

◆ SourceTypeFromFileName()

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

Definition at line 30 of file types.cc.

30  {
31  if (StringEndWith(file_name, ".vert")) {
32  return SourceType::kVertexShader;
33  }
34 
35  if (StringEndWith(file_name, ".frag")) {
36  return SourceType::kFragmentShader;
37  }
38 
39  if (StringEndWith(file_name, ".comp")) {
40  return SourceType::kComputeShader;
41  }
42 
43  return SourceType::kUnknown;
44 }

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

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

◆ SourceTypeFromString()

SourceType impeller::compiler::SourceTypeFromString ( std::string  name)

Definition at line 46 of file types.cc.

46  {
47  name = ToLowerCase(name);
48 
49  if (name == "vertex") {
50  return SourceType::kVertexShader;
51  }
52 
53  if (name == "fragment") {
54  return SourceType::kFragmentShader;
55  }
56 
57  if (name == "compute") {
58  return SourceType::kComputeShader;
59  }
60 
61  return SourceType::kUnknown;
62 }

References kComputeShader, kFragmentShader, kUnknown, kVertexShader, and ToLowerCase().

Referenced by ParseShaderBundleConfig().

◆ SourceTypeToString()

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

Definition at line 232 of file types.cc.

232  {
233  switch (type) {
234  case SourceType::kUnknown:
235  return "unknown";
236  case SourceType::kVertexShader:
237  return "vert";
238  case SourceType::kFragmentShader:
239  return "frag";
240  case SourceType::kComputeShader:
241  return "comp";
242  }
243  FML_UNREACHABLE();
244 }

References kComputeShader, kFragmentShader, kUnknown, and kVertexShader.

◆ StringEndWith()

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

Definition at line 17 of file types.cc.

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

Referenced by SourceTypeFromFileName().

◆ StringStartsWith()

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

Definition at line 87 of file utilities.cc.

87  {
88  if (prefix.length() > target.length()) {
89  return false;
90  }
91  for (size_t i = 0; i < prefix.length(); i++) {
92  if (target[i] != prefix[i]) {
93  return false;
94  }
95  }
96  return true;
97 }

Referenced by CreateGLSLCompiler().

◆ StringToShaderStage()

static std::string impeller::compiler::StringToShaderStage ( const std::string &  str)
static

Definition at line 46 of file reflector.cc.

46  {
47  if (str == "vertex") {
48  return "ShaderStage::kVertex";
49  }
50 
51  if (str == "fragment") {
52  return "ShaderStage::kFragment";
53  }
54 
55  if (str == "compute") {
56  return "ShaderStage::kCompute";
57  }
58 
59  return "ShaderStage::kUnknown";
60 }

◆ TargetPlatformBundlesSkSL()

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

Definition at line 320 of file types.cc.

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

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

Referenced by OutputIPLR().

◆ TargetPlatformFromCommandLine()

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

Definition at line 119 of file switches.cc.

120  {
121  auto target = TargetPlatform::kUnknown;
122  for (const auto& platform : kKnownPlatforms) {
123  if (command_line.HasOption(platform.first)) {
124  // If the platform has already been determined, the caller may have
125  // specified multiple platforms. This is an error and only one must be
126  // selected.
127  if (target != TargetPlatform::kUnknown) {
128  return TargetPlatform::kUnknown;
129  }
130  target = platform.second;
131  // Keep going to detect duplicates.
132  }
133  }
134  return target;
135 }

References kKnownPlatforms, and kUnknown.

◆ TargetPlatformIsMetal()

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

Definition at line 284 of file types.cc.

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

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 266 of file types.cc.

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

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

◆ TargetPlatformIsVulkan()

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

Definition at line 302 of file types.cc.

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

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 141 of file types.cc.

141  {
142  switch (platform) {
143  case TargetPlatform::kMetalIOS:
144  case TargetPlatform::kMetalDesktop:
145  case TargetPlatform::kOpenGLES:
146  case TargetPlatform::kOpenGLDesktop:
147  case TargetPlatform::kRuntimeStageMetal:
148  case TargetPlatform::kRuntimeStageGLES:
149  case TargetPlatform::kRuntimeStageVulkan:
150  case TargetPlatform::kVulkan:
151  return true;
152  case TargetPlatform::kUnknown:
153  case TargetPlatform::kSkSL:
154  return false;
155  }
156  FML_UNREACHABLE();
157 }

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

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

◆ TargetPlatformSLExtension()

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

Definition at line 246 of file types.cc.

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

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 212 of file types.cc.

213  {
214  switch (platform) {
215  case TargetPlatform::kMetalIOS:
216  case TargetPlatform::kRuntimeStageMetal:
217  return spirv_cross::CompilerMSL::Options::Platform::iOS;
218  case TargetPlatform::kMetalDesktop:
219  return spirv_cross::CompilerMSL::Options::Platform::macOS;
220  case TargetPlatform::kSkSL:
221  case TargetPlatform::kOpenGLES:
222  case TargetPlatform::kOpenGLDesktop:
223  case TargetPlatform::kRuntimeStageGLES:
224  case TargetPlatform::kRuntimeStageVulkan:
225  case TargetPlatform::kVulkan:
226  case TargetPlatform::kUnknown:
227  return spirv_cross::CompilerMSL::Options::Platform::macOS;
228  }
229  FML_UNREACHABLE();
230 }

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

◆ TargetPlatformToString()

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

Definition at line 74 of file types.cc.

74  {
75  switch (platform) {
76  case TargetPlatform::kUnknown:
77  return "Unknown";
78  case TargetPlatform::kMetalDesktop:
79  return "MetalDesktop";
80  case TargetPlatform::kMetalIOS:
81  return "MetaliOS";
82  case TargetPlatform::kOpenGLES:
83  return "OpenGLES";
84  case TargetPlatform::kOpenGLDesktop:
85  return "OpenGLDesktop";
86  case TargetPlatform::kVulkan:
87  return "Vulkan";
88  case TargetPlatform::kRuntimeStageMetal:
89  return "RuntimeStageMetal";
90  case TargetPlatform::kRuntimeStageGLES:
91  return "RuntimeStageGLES";
92  case TargetPlatform::kRuntimeStageVulkan:
93  return "RuntimeStageVulkan";
94  case TargetPlatform::kSkSL:
95  return "SkSL";
96  }
97  FML_UNREACHABLE();
98 }

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

◆ ToCamelCase()

std::string impeller::compiler::ToCamelCase ( std::string_view  string)

Definition at line 39 of file utilities.cc.

39  {
40  if (string.empty()) {
41  return "";
42  }
43 
44  std::stringstream stream;
45  bool next_upper = true;
46  for (size_t i = 0, count = string.length(); i < count; i++) {
47  auto ch = string.data()[i];
48  if (next_upper) {
49  next_upper = false;
50  stream << static_cast<char>(std::toupper(ch));
51  continue;
52  }
53  if (ch == '_') {
54  next_upper = true;
55  continue;
56  }
57  stream << ch;
58  }
59  return stream.str();
60 }

◆ ToExecutionModel()

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

Definition at line 198 of file types.cc.

198  {
199  switch (type) {
200  case SourceType::kVertexShader:
201  return spv::ExecutionModel::ExecutionModelVertex;
202  case SourceType::kFragmentShader:
203  return spv::ExecutionModel::ExecutionModelFragment;
204  case SourceType::kComputeShader:
205  return spv::ExecutionModel::ExecutionModelGLCompute;
206  case SourceType::kUnknown:
207  break;
208  }
209  return spv::ExecutionModel::ExecutionModelMax;
210 }

References kComputeShader, kFragmentShader, kUnknown, and kVertexShader.

Referenced by CreateCompiler().

◆ ToInputType() [1/2]

static std::optional<fb::InputDataType> impeller::compiler::ToInputType ( spirv_cross::SPIRType::BaseType  type)
static

Definition at line 95 of file runtime_stage_data.cc.

96  {
97  switch (type) {
98  case spirv_cross::SPIRType::Boolean:
99  return fb::InputDataType::kBoolean;
100  case spirv_cross::SPIRType::SByte:
101  return fb::InputDataType::kSignedByte;
102  case spirv_cross::SPIRType::UByte:
103  return fb::InputDataType::kUnsignedByte;
104  case spirv_cross::SPIRType::Short:
105  return fb::InputDataType::kSignedShort;
106  case spirv_cross::SPIRType::UShort:
107  return fb::InputDataType::kUnsignedShort;
108  case spirv_cross::SPIRType::Int:
109  return fb::InputDataType::kSignedInt;
110  case spirv_cross::SPIRType::UInt:
111  return fb::InputDataType::kUnsignedInt;
112  case spirv_cross::SPIRType::Int64:
113  return fb::InputDataType::kSignedInt64;
114  case spirv_cross::SPIRType::UInt64:
115  return fb::InputDataType::kUnsignedInt64;
116  case spirv_cross::SPIRType::Float:
118  case spirv_cross::SPIRType::Double:
119  return fb::InputDataType::kDouble;
120  case spirv_cross::SPIRType::Unknown:
121  case spirv_cross::SPIRType::Void:
122  case spirv_cross::SPIRType::Half:
123  case spirv_cross::SPIRType::AtomicCounter:
124  case spirv_cross::SPIRType::Struct:
125  case spirv_cross::SPIRType::Image:
126  case spirv_cross::SPIRType::SampledImage:
127  case spirv_cross::SPIRType::Sampler:
128  case spirv_cross::SPIRType::AccelerationStructure:
129  case spirv_cross::SPIRType::RayQuery:
130  case spirv_cross::SPIRType::ControlPointArray:
131  case spirv_cross::SPIRType::Interpolant:
132  case spirv_cross::SPIRType::Char:
133  return std::nullopt;
134  }
135  FML_UNREACHABLE();
136 }

References impeller::kFloat.

Referenced by impeller::compiler::ShaderBundleData::CreateFlatbuffer(), and impeller::compiler::RuntimeStageData::CreateStageFlatbuffer().

◆ ToInputType() [2/2]

static std::optional<fb::shaderbundle::InputDataType> impeller::compiler::ToInputType ( spirv_cross::SPIRType::BaseType  type)
static

Definition at line 100 of file shader_bundle_data.cc.

101  {
102  switch (type) {
103  case spirv_cross::SPIRType::Boolean:
104  return fb::shaderbundle::InputDataType::kBoolean;
105  case spirv_cross::SPIRType::SByte:
106  return fb::shaderbundle::InputDataType::kSignedByte;
107  case spirv_cross::SPIRType::UByte:
108  return fb::shaderbundle::InputDataType::kUnsignedByte;
109  case spirv_cross::SPIRType::Short:
110  return fb::shaderbundle::InputDataType::kSignedShort;
111  case spirv_cross::SPIRType::UShort:
112  return fb::shaderbundle::InputDataType::kUnsignedShort;
113  case spirv_cross::SPIRType::Int:
114  return fb::shaderbundle::InputDataType::kSignedInt;
115  case spirv_cross::SPIRType::UInt:
116  return fb::shaderbundle::InputDataType::kUnsignedInt;
117  case spirv_cross::SPIRType::Int64:
118  return fb::shaderbundle::InputDataType::kSignedInt64;
119  case spirv_cross::SPIRType::UInt64:
120  return fb::shaderbundle::InputDataType::kUnsignedInt64;
121  case spirv_cross::SPIRType::Float:
123  case spirv_cross::SPIRType::Double:
124  return fb::shaderbundle::InputDataType::kDouble;
125  case spirv_cross::SPIRType::Unknown:
126  case spirv_cross::SPIRType::Void:
127  case spirv_cross::SPIRType::Half:
128  case spirv_cross::SPIRType::AtomicCounter:
129  case spirv_cross::SPIRType::Struct:
130  case spirv_cross::SPIRType::Image:
131  case spirv_cross::SPIRType::SampledImage:
132  case spirv_cross::SPIRType::Sampler:
133  case spirv_cross::SPIRType::AccelerationStructure:
134  case spirv_cross::SPIRType::RayQuery:
135  case spirv_cross::SPIRType::ControlPointArray:
136  case spirv_cross::SPIRType::Interpolant:
137  case spirv_cross::SPIRType::Char:
138  return std::nullopt;
139  }
140  FML_UNREACHABLE();
141 }

References impeller::kFloat.

◆ ToJsonStage()

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

Definition at line 47 of file runtime_stage_data.cc.

47  {
48  switch (stage) {
49  case spv::ExecutionModel::ExecutionModelVertex:
50  return fb::Stage::kVertex;
51  case spv::ExecutionModel::ExecutionModelFragment:
52  return fb::Stage::kFragment;
53  case spv::ExecutionModel::ExecutionModelGLCompute:
54  return fb::Stage::kCompute;
55  default:
56  return std::nullopt;
57  }
58  FML_UNREACHABLE();
59 }

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

◆ ToJsonType()

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

Definition at line 138 of file runtime_stage_data.cc.

139  {
140  switch (type) {
141  case spirv_cross::SPIRType::Boolean:
142  return 0; // fb::UniformDataType::kBoolean;
143  case spirv_cross::SPIRType::SByte:
144  return 1; // fb::UniformDataType::kSignedByte;
145  case spirv_cross::SPIRType::UByte:
146  return 2; // fb::UniformDataType::kUnsignedByte;
147  case spirv_cross::SPIRType::Short:
148  return 3; // fb::UniformDataType::kSignedShort;
149  case spirv_cross::SPIRType::UShort:
150  return 4; // fb::UniformDataType::kUnsignedShort;
151  case spirv_cross::SPIRType::Int:
152  return 5; // fb::UniformDataType::kSignedInt;
153  case spirv_cross::SPIRType::UInt:
154  return 6; // fb::UniformDataType::kUnsignedInt;
155  case spirv_cross::SPIRType::Int64:
156  return 7; // fb::UniformDataType::kSignedInt64;
157  case spirv_cross::SPIRType::UInt64:
158  return 8; // fb::UniformDataType::kUnsignedInt64;
159  case spirv_cross::SPIRType::Half:
160  return 9; // b::UniformDataType::kHalfFloat;
161  case spirv_cross::SPIRType::Float:
162  return 10; // fb::UniformDataType::kFloat;
163  case spirv_cross::SPIRType::Double:
164  return 11; // fb::UniformDataType::kDouble;
165  case spirv_cross::SPIRType::SampledImage:
166  return 12; // fb::UniformDataType::kSampledImage;
167  case spirv_cross::SPIRType::Struct:
168  return 13;
169  case spirv_cross::SPIRType::AccelerationStructure:
170  case spirv_cross::SPIRType::AtomicCounter:
171  case spirv_cross::SPIRType::Char:
172  case spirv_cross::SPIRType::ControlPointArray:
173  case spirv_cross::SPIRType::Image:
174  case spirv_cross::SPIRType::Interpolant:
175  case spirv_cross::SPIRType::RayQuery:
176  case spirv_cross::SPIRType::Sampler:
177  case spirv_cross::SPIRType::Unknown:
178  case spirv_cross::SPIRType::Void:
179  return std::nullopt;
180  }
181  FML_UNREACHABLE();
182 }

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

◆ ToLowerCase()

std::string impeller::compiler::ToLowerCase ( std::string_view  string)

Definition at line 62 of file utilities.cc.

62  {
63  std::string result = std::string(string);
64  std::transform(result.begin(), result.end(), result.begin(),
65  [](char x) { return std::tolower(x); });
66  return result;
67 }

Referenced by SourceTypeFromString(), and impeller::compiler::Switches::Switches().

◆ ToShaderCShaderKind()

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

Definition at line 184 of file types.cc.

184  {
185  switch (type) {
186  case SourceType::kVertexShader:
187  return shaderc_shader_kind::shaderc_vertex_shader;
188  case SourceType::kFragmentShader:
189  return shaderc_shader_kind::shaderc_fragment_shader;
190  case SourceType::kComputeShader:
191  return shaderc_shader_kind::shaderc_compute_shader;
192  case SourceType::kUnknown:
193  break;
194  }
195  return shaderc_shader_kind::shaderc_glsl_infer_from_source;
196 }

References kComputeShader, kFragmentShader, kUnknown, and kVertexShader.

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

◆ ToSourceLanguage()

SourceLanguage impeller::compiler::ToSourceLanguage ( const std::string &  source_language)

Definition at line 64 of file types.cc.

64  {
65  if (source_language == "glsl") {
66  return SourceLanguage::kGLSL;
67  }
68  if (source_language == "hlsl") {
69  return SourceLanguage::kHLSL;
70  }
71  return SourceLanguage::kUnknown;
72 }

References kGLSL, kHLSL, and kUnknown.

Referenced by ParseShaderBundleConfig(), and impeller::compiler::Switches::Switches().

◆ ToStage() [1/2]

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

Definition at line 33 of file runtime_stage_data.cc.

33  {
34  switch (stage) {
35  case spv::ExecutionModel::ExecutionModelVertex:
36  return fb::Stage::kVertex;
37  case spv::ExecutionModel::ExecutionModelFragment:
38  return fb::Stage::kFragment;
39  case spv::ExecutionModel::ExecutionModelGLCompute:
40  return fb::Stage::kCompute;
41  default:
42  return std::nullopt;
43  }
44  FML_UNREACHABLE();
45 }

Referenced by impeller::compiler::ShaderBundleData::CreateFlatbuffer(), and impeller::compiler::RuntimeStageData::CreateStageFlatbuffer().

◆ ToStage() [2/2]

static std::optional<fb::shaderbundle::ShaderStage> impeller::compiler::ToStage ( spv::ExecutionModel  stage)
static

Definition at line 41 of file shader_bundle_data.cc.

42  {
43  switch (stage) {
44  case spv::ExecutionModel::ExecutionModelVertex:
45  return fb::shaderbundle::ShaderStage::kVertex;
46  case spv::ExecutionModel::ExecutionModelFragment:
47  return fb::shaderbundle::ShaderStage::kFragment;
48  case spv::ExecutionModel::ExecutionModelGLCompute:
49  return fb::shaderbundle::ShaderStage::kCompute;
50  default:
51  return std::nullopt;
52  }
53  FML_UNREACHABLE();
54 }

◆ ToString()

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

Definition at line 555 of file reflector.cc.

555  {
556  switch (type) {
557  case CompilerBackend::Type::kMSL:
558  return "Metal Shading Language";
559  case CompilerBackend::Type::kGLSL:
560  return "OpenGL Shading Language";
561  case CompilerBackend::Type::kGLSLVulkan:
562  return "OpenGL Shading Language (Relaxed Vulkan Semantics)";
563  case CompilerBackend::Type::kSkSL:
564  return "SkSL Shading Language";
565  }
566  FML_UNREACHABLE();
567 }

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

◆ ToUniformType() [1/2]

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

Definition at line 56 of file shader_bundle_data.cc.

57  {
58  switch (type) {
59  case spirv_cross::SPIRType::Boolean:
60  return fb::shaderbundle::UniformDataType::kBoolean;
61  case spirv_cross::SPIRType::SByte:
62  return fb::shaderbundle::UniformDataType::kSignedByte;
63  case spirv_cross::SPIRType::UByte:
64  return fb::shaderbundle::UniformDataType::kUnsignedByte;
65  case spirv_cross::SPIRType::Short:
66  return fb::shaderbundle::UniformDataType::kSignedShort;
67  case spirv_cross::SPIRType::UShort:
68  return fb::shaderbundle::UniformDataType::kUnsignedShort;
69  case spirv_cross::SPIRType::Int:
70  return fb::shaderbundle::UniformDataType::kSignedInt;
71  case spirv_cross::SPIRType::UInt:
72  return fb::shaderbundle::UniformDataType::kUnsignedInt;
73  case spirv_cross::SPIRType::Int64:
74  return fb::shaderbundle::UniformDataType::kSignedInt64;
75  case spirv_cross::SPIRType::UInt64:
76  return fb::shaderbundle::UniformDataType::kUnsignedInt64;
77  case spirv_cross::SPIRType::Half:
78  return fb::shaderbundle::UniformDataType::kHalfFloat;
79  case spirv_cross::SPIRType::Float:
81  case spirv_cross::SPIRType::Double:
82  return fb::shaderbundle::UniformDataType::kDouble;
83  case spirv_cross::SPIRType::SampledImage:
85  case spirv_cross::SPIRType::AccelerationStructure:
86  case spirv_cross::SPIRType::AtomicCounter:
87  case spirv_cross::SPIRType::Char:
88  case spirv_cross::SPIRType::ControlPointArray:
89  case spirv_cross::SPIRType::Image:
90  case spirv_cross::SPIRType::Interpolant:
91  case spirv_cross::SPIRType::RayQuery:
92  case spirv_cross::SPIRType::Sampler:
93  case spirv_cross::SPIRType::Struct:
94  case spirv_cross::SPIRType::Unknown:
95  case spirv_cross::SPIRType::Void:
96  return std::nullopt;
97  }
98  FML_UNREACHABLE();
99 }

References impeller::kFloat, and impeller::kSampledImage.

◆ ToUniformType() [2/2]

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

Definition at line 61 of file runtime_stage_data.cc.

62  {
63  switch (type) {
64  case spirv_cross::SPIRType::Float:
66  case spirv_cross::SPIRType::SampledImage:
68  case spirv_cross::SPIRType::Struct:
70  case spirv_cross::SPIRType::Boolean:
71  case spirv_cross::SPIRType::SByte:
72  case spirv_cross::SPIRType::UByte:
73  case spirv_cross::SPIRType::Short:
74  case spirv_cross::SPIRType::UShort:
75  case spirv_cross::SPIRType::Int:
76  case spirv_cross::SPIRType::UInt:
77  case spirv_cross::SPIRType::Int64:
78  case spirv_cross::SPIRType::UInt64:
79  case spirv_cross::SPIRType::Half:
80  case spirv_cross::SPIRType::Double:
81  case spirv_cross::SPIRType::AccelerationStructure:
82  case spirv_cross::SPIRType::AtomicCounter:
83  case spirv_cross::SPIRType::Char:
84  case spirv_cross::SPIRType::ControlPointArray:
85  case spirv_cross::SPIRType::Image:
86  case spirv_cross::SPIRType::Interpolant:
87  case spirv_cross::SPIRType::RayQuery:
88  case spirv_cross::SPIRType::Sampler:
89  case spirv_cross::SPIRType::Unknown:
90  case spirv_cross::SPIRType::Void:
91  return std::nullopt;
92  }
93  FML_UNREACHABLE();
94 }

References impeller::kFloat, impeller::kSampledImage, and impeller::kStruct.

Referenced by impeller::compiler::ShaderBundleData::CreateFlatbuffer(), and impeller::compiler::RuntimeStageData::CreateStageFlatbuffer().

◆ TypeNameWithPaddingOfSize()

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

Definition at line 720 of file reflector.cc.

720  {
721  std::stringstream stream;
722  stream << "Padding<" << size << ">";
723  return stream.str();
724 }

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 30 of file utilities.cc.

30  {
31  return reinterpret_cast<const char*>(path.u8string().c_str());
32 }

Referenced by impeller::compiler::Switches::AreValid(), CreateReflectorOptions(), EntryPointFunctionNameFromSourceName(), GenerateShaderBundle(), InferShaderNameFromPath(), impeller::scene::importer::Main(), Main(), OutputDepfile(), OutputIPLR(), OutputReflectionData(), OutputSLFile(), 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 1179 of file reflector.cc.

1181  {
1182  VertexType result;
1183  result.variable_name = resource->name;
1184  const auto& type = compiler.get_type(resource->type_id);
1185  result.base_type = type.basetype;
1186  const auto total_size = type.columns * type.vecsize * type.width / 8u;
1187  result.byte_length = total_size;
1188 
1189  if (type.basetype == spirv_cross::SPIRType::BaseType::Float &&
1190  type.columns == 1u && type.vecsize == 2u &&
1191  type.width == sizeof(float) * 8u) {
1192  result.type_name = "Point";
1193  } else if (type.basetype == spirv_cross::SPIRType::BaseType::Float &&
1194  type.columns == 1u && type.vecsize == 4u &&
1195  type.width == sizeof(float) * 8u) {
1196  result.type_name = "Vector4";
1197  } else if (type.basetype == spirv_cross::SPIRType::BaseType::Float &&
1198  type.columns == 1u && type.vecsize == 3u &&
1199  type.width == sizeof(float) * 8u) {
1200  result.type_name = "Vector3";
1201  } else if (type.basetype == spirv_cross::SPIRType::BaseType::Float &&
1202  type.columns == 1u && type.vecsize == 1u &&
1203  type.width == sizeof(float) * 8u) {
1204  result.type_name = "Scalar";
1205  } else if (type.basetype == spirv_cross::SPIRType::BaseType::Int &&
1206  type.columns == 1u && type.vecsize == 1u &&
1207  type.width == sizeof(int32_t) * 8u) {
1208  result.type_name = "int32_t";
1209  } else {
1210  // Catch all unknown padding.
1211  result.type_name = TypeNameWithPaddingOfSize(total_size);
1212  }
1213 
1214  return result;
1215 }

References impeller::compiler::VertexType::base_type, 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

◆ kExternalTexturePrefix

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

Definition at line 11 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},
}

Definition at line 20 of file switches.cc.

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

◆ kKnownRuntimeStages

const std::map<std::string, TargetPlatform> impeller::compiler::kKnownRuntimeStages
static
Initial value:
= {
{"sksl", TargetPlatform::kSkSL},
{"runtime-stage-metal", TargetPlatform::kRuntimeStageMetal},
{"runtime-stage-gles", TargetPlatform::kRuntimeStageGLES},
{"runtime-stage-vulkan", TargetPlatform::kRuntimeStageVulkan},
}

Definition at line 28 of file switches.cc.

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

◆ kKnownSourceTypes

const std::map<std::string, SourceType> impeller::compiler::kKnownSourceTypes
static
Initial value:
= {
{"vert", SourceType::kVertexShader},
{"frag", SourceType::kFragmentShader},
{"comp", SourceType::kComputeShader},
}

Definition at line 35 of file switches.cc.

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

◆ kReflectionCCTemplate

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

Definition at line 204 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 = "shader"
static

◆ kStageKey

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

◆ kTargetPlatformKey

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

Definition at line 185 of file runtime_stage_data.cc.

◆ kUniformArrayElementsKey

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

◆ kUniformBitWidthKey

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

◆ kUniformColumnsKey

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

◆ kUniformLocationKey

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

◆ kUniformNameKey

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

◆ kUniformRowsKey

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

◆ kUniformsKey

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

◆ kUniformTypeKey

const char* impeller::compiler::kUniformTypeKey = "type"
static
impeller::kFloat
@ kFloat
Definition: runtime_types.h:23
impeller::compiler::CreateVulkanCompiler
static CompilerBackend CreateVulkanCompiler(const spirv_cross::ParsedIR &ir, const SourceOptions &source_options)
Definition: compiler.cc:123
impeller::Scalar
float Scalar
Definition: scalar.h:18
impeller::compiler::CreateSkSLCompiler
static CompilerBackend CreateSkSLCompiler(const spirv_cross::ParsedIR &ir, const SourceOptions &source_options)
Definition: compiler.cc:185
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:69
impeller::compiler::ToLowerCase
std::string ToLowerCase(std::string_view string)
Definition: utilities.cc:62
impeller::compiler::SourceType::kUnknown
@ kUnknown
impeller::compiler::EntryPointMustBeNamedMain
static bool EntryPointMustBeNamedMain(TargetPlatform platform)
Definition: compiler.cc:191
impeller::compiler::ParseMSLVersion
static uint32_t ParseMSLVersion(const std::string &msl_version)
Definition: compiler.cc:29
impeller::compiler::TargetPlatform::kMetalDesktop
@ kMetalDesktop
impeller::compiler::TargetPlatformToMSLPlatform
spirv_cross::CompilerMSL::Options::Platform TargetPlatformToMSLPlatform(TargetPlatform platform)
Definition: types.cc:212
impeller::compiler::OutputDepfile
static bool OutputDepfile(const Compiler &compiler, const Switches &switches)
Definition: impellerc_main.cc:196
impeller::kSampledImage
@ kSampledImage
Definition: runtime_types.h:24
impeller::compiler::CreateGLSLCompiler
static CompilerBackend CreateGLSLCompiler(const spirv_cross::ParsedIR &ir, const SourceOptions &source_options)
Definition: compiler.cc:135
impeller::compiler::TargetPlatformNeedsReflection
bool TargetPlatformNeedsReflection(TargetPlatform platform)
Definition: types.cc:141
impeller::compiler::InferShaderNameFromPath
std::string InferShaderNameFromPath(std::string_view path)
Definition: utilities.cc:34
impeller::compiler::TargetPlatform::kMetalIOS
@ kMetalIOS
impeller::compiler::ParseShaderBundleConfig
std::optional< ShaderBundleConfig > ParseShaderBundleConfig(const std::string &bundle_config_json, std::ostream &error_stream)
Parse a shader bundle configuration from a given JSON string.
Definition: shader_bundle.cc:19
impeller::compiler::kKnownPlatforms
static const std::map< std::string, TargetPlatform > kKnownPlatforms
Definition: switches.cc:20
impeller::compiler::SourceLanguage::kGLSL
@ kGLSL
impeller::compiler::StringEndWith
static bool StringEndWith(const std::string &string, const std::string &suffix)
Definition: types.cc:17
impeller::compiler::kExternalTexturePrefix
constexpr char kExternalTexturePrefix[]
Definition: constants.h:11
impeller::compiler::ToSourceLanguage
SourceLanguage ToSourceLanguage(const std::string &source_language)
Definition: types.cc:64
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:11
impeller::compiler::SourceLanguage::kHLSL
@ kHLSL
impeller::compiler::TargetPlatform::kVulkan
@ kVulkan
impeller::compiler::SourceType::kFragmentShader
@ kFragmentShader
impeller::compiler::TargetPlatform::kRuntimeStageVulkan
@ kRuntimeStageVulkan
impeller::compiler::OutputReflectionData
static bool OutputReflectionData(const Compiler &compiler, const Switches &switches, const SourceOptions &options)
Definition: impellerc_main.cc:144
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:111
impeller::compiler::OutputIPLR
static bool OutputIPLR(const Switches &switches, const std::shared_ptr< fml::Mapping > &source_file_mapping)
Definition: impellerc_main.cc:56
impeller::scene::importer::kKnownSourceTypes
static const std::map< std::string, SourceType > kKnownSourceTypes
Definition: switches.cc:20
impeller::compiler::GenerateShaderBundleFlatbuffer
std::optional< fb::shaderbundle::ShaderBundleT > GenerateShaderBundleFlatbuffer(const std::string &bundle_config_json, const SourceOptions &options)
Parses the JSON shader bundle configuration and invokes the compiler multiple times to produce a shad...
Definition: shader_bundle.cc:179
impeller::compiler::OutputSLFile
static bool OutputSLFile(const Compiler &compiler, const Switches &switches)
Definition: impellerc_main.cc:126
impeller::compiler::CompileSkSL
static std::shared_ptr< RuntimeStageData::Shader > CompileSkSL(std::shared_ptr< fml::Mapping > source_file_mapping, const Switches &switches)
Definition: impellerc_main.cc:37
impeller::kStruct
@ kStruct
Definition: runtime_types.h:25
impeller::compiler::ToExecutionModel
spv::ExecutionModel ToExecutionModel(SourceType type)
Definition: types.cc:198
impeller::compiler::GenerateShaderBackendFB
static std::unique_ptr< fb::shaderbundle::BackendShaderT > GenerateShaderBackendFB(TargetPlatform target_platform, SourceOptions &options, const std::string &shader_name, const ShaderConfig &shader_config)
Definition: shader_bundle.cc:85
impeller::compiler::ShaderBundleConfig
std::unordered_map< std::string, ShaderConfig > ShaderBundleConfig
Definition: types.h:81
impeller::compiler::SourceLanguage
SourceLanguage
Definition: types.h:42
impeller::compiler::GenerateShaderFB
static std::unique_ptr< fb::shaderbundle::ShaderT > GenerateShaderFB(SourceOptions options, const std::string &shader_name, const ShaderConfig &shader_config)
Definition: shader_bundle.cc:145
impeller::compiler::TargetPlatform::kOpenGLDesktop
@ kOpenGLDesktop
impeller::compiler::SourceTypeFromString
SourceType SourceTypeFromString(std::string name)
Definition: types.cc:46
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:52
impeller::compiler::SetPermissiveAccess
bool SetPermissiveAccess(const std::filesystem::path &p)
Sets the file access mode of the file at path 'p' to 0644.
Definition: utilities.cc:16
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::TargetPlatform::kRuntimeStageMetal
@ kRuntimeStageMetal
impeller::compiler::SourceType::kVertexShader
@ kVertexShader
impeller::compiler::StringStartsWith
bool StringStartsWith(const std::string &target, const std::string &prefix)
Definition: utilities.cc:87
impeller::compiler::TargetPlatformBundlesSkSL
bool TargetPlatformBundlesSkSL(TargetPlatform platform)
Definition: types.cc:320
impeller::compiler::GenerateShaderBundle
bool GenerateShaderBundle(Switches &switches)
Parses the JSON shader bundle configuration and invokes the compiler multiple times to produce a shad...
Definition: shader_bundle.cc:210
impeller::compiler::TypeNameWithPaddingOfSize
static std::string TypeNameWithPaddingOfSize(size_t size)
Definition: reflector.cc:720
impeller::compiler::kKnownRuntimeStages
static const std::map< std::string, TargetPlatform > kKnownRuntimeStages
Definition: switches.cc:28
impeller::compiler::TargetPlatform::kSkSL
@ kSkSL
impeller::compiler::TargetPlatform::kRuntimeStageGLES
@ kRuntimeStageGLES
impeller::compiler::CreateReflectorOptions
static Reflector::Options CreateReflectorOptions(const SourceOptions &options, const Switches &switches)
Definition: impellerc_main.cc:23