Flutter Impeller
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
impeller::compiler Namespace Reference

Namespaces

 testing
 

Classes

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

Typedefs

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

Enumerations

enum class  SourceType {
  kUnknown ,
  kVertexShader ,
  kFragmentShader ,
  kComputeShader
}
 
enum class  TargetPlatform {
  kUnknown ,
  kMetalDesktop ,
  kMetalIOS ,
  kOpenGLES ,
  kOpenGLDesktop ,
  kVulkan ,
  kRuntimeStageMetal ,
  kRuntimeStageGLES ,
  kRuntimeStageGLES3 ,
  kRuntimeStageVulkan ,
  kSkSL
}
 
enum class  SourceLanguage {
  kUnknown ,
  kGLSL ,
  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)
 
bool Main (const fml::CommandLine &command_line)
 
static std::string ExecutionModelToStringName (spv::ExecutionModel model)
 
static std::string StringToShaderStage (const std::string &str)
 
static std::optional< RuntimeStageBackend > GetRuntimeStageBackend (TargetPlatform target_platform)
 
static std::string ToString (CompilerBackend::Type type)
 
static std::string TypeNameWithPaddingOfSize (size_t size)
 
static std::optional< KnownType > ReadKnownScalarType (spirv_cross::SPIRType::BaseType type)
 
static size_t GetReflectedStructSize (const std::vector< StructMember > &members)
 Get the reflected struct size. In the vast majority of the cases, this is the same as the declared struct size as given by the compiler. But, additional padding may need to be introduced after the end of the struct to keep in line with the alignment requirement of the individual struct members. This method figures out the actual size of the reflected struct that can be referenced in native code. More...
 
static VertexType VertexTypeFromInputResource (const spirv_cross::Compiler &compiler, const spirv_cross::Resource *resource)
 
static std::optional< fb::Stage > ToStage (spv::ExecutionModel stage)
 
static std::optional< 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< ShaderBundleConfig > ParseShaderBundleConfig (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< TargetPlatform > RuntimeStagesFromCommandLine (const fml::CommandLine &command_line)
 
static SourceType SourceTypeFromCommandLine (const fml::CommandLine &command_line)
 
static std::filesystem::path GetOptionAsPath (const fml::CommandLine &command_line, const char *arg)
 
SourceType SourceTypeFromFileName (const std::filesystem::path &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::filesystem::path &file_name, SourceType type, SourceLanguage source_language, const std::string &entry_point_name)
 
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 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 (const std::filesystem::path &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
 
static const uint32_t kMaxUniformBufferSize = 6208
 
constexpr char kExternalTexturePrefix [] = "SAMPLER_EXTERNAL_OES_"
 
static const char * kFormatVersionKey = "format_version"
 
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 char * kUniformStructElementsKey = "struct_elements"
 
static const std::map< std::string, TargetPlatform > kKnownPlatforms
 
static const std::vector< std::pair< std::string, TargetPlatform > > kKnownRuntimeStages
 
static const std::map< std::string, SourceType > kKnownSourceTypes
 

Typedef Documentation

◆ ShaderBundleConfig

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

Definition at line 97 of file types.h.

Enumeration Type Documentation

◆ SourceLanguage

enum impeller::compiler::SourceLanguage
strong
Enumerator
kUnknown 
kGLSL 
kHLSL 

Definition at line 44 of file types.h.

44  {
45  kUnknown,
46  kGLSL,
47  kHLSL,
48 };

◆ SourceType

enum impeller::compiler::SourceType
strong
Enumerator
kUnknown 
kVertexShader 
kFragmentShader 
kComputeShader 

Definition at line 23 of file types.h.

23  {
24  kUnknown,
25  kVertexShader,
26  kFragmentShader,
27  kComputeShader,
28 };

◆ TargetPlatform

enum impeller::compiler::TargetPlatform
strong
Enumerator
kUnknown 
kMetalDesktop 
kMetalIOS 
kOpenGLES 
kOpenGLDesktop 
kVulkan 
kRuntimeStageMetal 
kRuntimeStageGLES 
kRuntimeStageGLES3 
kRuntimeStageVulkan 
kSkSL 

Definition at line 30 of file types.h.

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

Function Documentation

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

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

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

234  {
235  CompilerBackend compiler;
236  switch (source_options.target_platform) {
237  case TargetPlatform::kMetalDesktop:
238  case TargetPlatform::kMetalIOS:
239  case TargetPlatform::kRuntimeStageMetal:
240  compiler = CreateMSLCompiler(ir, source_options);
241  break;
242  case TargetPlatform::kVulkan:
243  case TargetPlatform::kRuntimeStageVulkan:
244  compiler = CreateVulkanCompiler(ir, source_options);
245  break;
246  case TargetPlatform::kOpenGLES:
247  case TargetPlatform::kOpenGLDesktop:
248  case TargetPlatform::kRuntimeStageGLES:
249  case TargetPlatform::kRuntimeStageGLES3:
250  compiler = CreateGLSLCompiler(ir, source_options);
251  break;
252  case TargetPlatform::kSkSL:
253  compiler = CreateSkSLCompiler(ir, source_options);
254  break;
255  case TargetPlatform::kUnknown:
256  FML_UNREACHABLE();
257  }
258  if (!compiler) {
259  return {};
260  }
261  auto* backend = compiler.GetCompiler();
262  if (!EntryPointMustBeNamedMain(source_options.target_platform) &&
263  source_options.source_language == SourceLanguage::kGLSL) {
264  backend->rename_entry_point("main", source_options.entry_point_name,
265  ToExecutionModel(source_options.type));
266  }
267  return compiler;
268 }
impeller::compiler::CreateSkSLCompiler
static CompilerBackend CreateSkSLCompiler(const spirv_cross::ParsedIR &ir, const SourceOptions &source_options)
Definition: compiler.cc:207
impeller::compiler::CreateVulkanCompiler
static CompilerBackend CreateVulkanCompiler(const spirv_cross::ParsedIR &ir, const SourceOptions &source_options)
Definition: compiler.cc:137
impeller::compiler::EntryPointMustBeNamedMain
static bool EntryPointMustBeNamedMain(TargetPlatform platform)
Definition: compiler.cc:213
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:66
impeller::compiler::CreateGLSLCompiler
static CompilerBackend CreateGLSLCompiler(const spirv_cross::ParsedIR &ir, const SourceOptions &source_options)
Definition: compiler.cc:149
impeller::compiler::ToExecutionModel
spv::ExecutionModel ToExecutionModel(SourceType type)
Definition: types.cc:169

References CreateGLSLCompiler(), CreateMSLCompiler(), CreateSkSLCompiler(), CreateVulkanCompiler(), impeller::compiler::SourceOptions::entry_point_name, EntryPointMustBeNamedMain(), impeller::compiler::CompilerBackend::GetCompiler(), kGLSL, kMetalDesktop, kMetalIOS, kOpenGLDesktop, kOpenGLES, kRuntimeStageGLES, kRuntimeStageGLES3, 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(), and Main().

◆ CreateGLSLCompiler()

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

Definition at line 149 of file compiler.cc.

150  {
151  auto gl_compiler = std::make_shared<spirv_cross::CompilerGLSL>(ir);
152 
153  // Walk the variables and insert the external image extension if any of them
154  // begins with the external texture prefix. Unfortunately, we can't walk
155  // `gl_compiler->get_shader_resources().separate_samplers` until the compiler
156  // is further along.
157  //
158  // Unfortunately, we can't just let the shader author add this extension and
159  // use `samplerExternalOES` directly because compiling to spirv requires the
160  // source language profile to be at least 310 ES, but this extension is
161  // incompatible with ES 310+.
162  for (auto& id : ir.ids_for_constant_or_variable) {
163  if (StringStartsWith(ir.get_name(id), kExternalTexturePrefix)) {
164  if (source_options.gles_language_version >= 300) {
165  gl_compiler->require_extension(kEGLImageExternalExtension300);
166  } else {
167  gl_compiler->require_extension(kEGLImageExternalExtension);
168  }
169  break;
170  }
171  }
172 
173  spirv_cross::CompilerGLSL::Options sl_options;
174  sl_options.force_zero_initialized_variables = true;
175  sl_options.vertex.fixup_clipspace = true;
176  if (source_options.target_platform == TargetPlatform::kOpenGLES ||
177  source_options.target_platform == TargetPlatform::kRuntimeStageGLES ||
178  source_options.target_platform == TargetPlatform::kRuntimeStageGLES3) {
179  sl_options.version = source_options.gles_language_version > 0
180  ? source_options.gles_language_version
181  : 100;
182  sl_options.es = true;
183  if (source_options.target_platform == TargetPlatform::kRuntimeStageGLES3) {
184  sl_options.version = 300;
185  }
186  if (source_options.require_framebuffer_fetch &&
187  source_options.type == SourceType::kFragmentShader) {
188  gl_compiler->remap_ext_framebuffer_fetch(0, 0, true);
189  }
190  gl_compiler->set_variable_type_remap_callback(
191  [&](const spirv_cross::SPIRType& type, const std::string& var_name,
192  std::string& name_of_type) {
193  if (StringStartsWith(var_name, kExternalTexturePrefix)) {
194  name_of_type = "samplerExternalOES";
195  }
196  });
197  } else {
198  sl_options.version = source_options.gles_language_version > 0
199  ? source_options.gles_language_version
200  : 120;
201  sl_options.es = false;
202  }
203  gl_compiler->set_common_options(sl_options);
204  return CompilerBackend(gl_compiler);
205 }
impeller::compiler::kExternalTexturePrefix
constexpr char kExternalTexturePrefix[]
Definition: constants.h:11
impeller::compiler::StringStartsWith
bool StringStartsWith(const std::string &target, const std::string &prefix)
Definition: utilities.cc:86

References impeller::compiler::SourceOptions::gles_language_version, kExternalTexturePrefix, kFragmentShader, kOpenGLES, kRuntimeStageGLES, kRuntimeStageGLES3, 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 66 of file compiler.cc.

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

Referenced by CreateCompiler().

◆ CreateSkSLCompiler()

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

Definition at line 207 of file compiler.cc.

208  {
209  auto sksl_compiler = std::make_shared<CompilerSkSL>(ir);
210  return CompilerBackend(sksl_compiler);
211 }

Referenced by CreateCompiler().

◆ CreateVulkanCompiler()

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

Definition at line 137 of file compiler.cc.

139  {
140  auto gl_compiler = std::make_shared<spirv_cross::CompilerGLSL>(ir);
141  spirv_cross::CompilerGLSL::Options sl_options;
142  sl_options.force_zero_initialized_variables = true;
143  sl_options.vertex.fixup_clipspace = true;
144  sl_options.vulkan_semantics = true;
145  gl_compiler->set_common_options(sl_options);
146  return CompilerBackend(gl_compiler);
147 }

Referenced by CreateCompiler().

◆ EntryPointFunctionNameFromSourceName()

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

Definition at line 101 of file types.cc.

105  {
106  if (source_language == SourceLanguage::kHLSL) {
107  return entry_point_name;
108  }
109 
110  std::stringstream stream;
111  stream << ConvertToEntrypointName(Utf8FromPath(file_name.stem())) << "_";
112  switch (type) {
113  case SourceType::kUnknown:
114  stream << "unknown";
115  break;
116  case SourceType::kVertexShader:
117  stream << "vertex";
118  break;
119  case SourceType::kFragmentShader:
120  stream << "fragment";
121  break;
122  case SourceType::kComputeShader:
123  stream << "compute";
124  break;
125  }
126  stream << "_main";
127  return stream.str();
128 }
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:68
impeller::compiler::Utf8FromPath
std::string Utf8FromPath(const std::filesystem::path &path)
Converts a native format path to a utf8 string.
Definition: utilities.cc:30

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

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

◆ EntryPointMustBeNamedMain()

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

Definition at line 213 of file compiler.cc.

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

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

Referenced by CreateCompiler().

◆ ExecutionModelToStringName()

static std::string impeller::compiler::ExecutionModelToStringName ( spv::ExecutionModel  model)
static

Definition at line 35 of file reflector.cc.

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

◆ 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 }
impeller::compiler::EntryPointFunctionNameFromSourceName
std::string EntryPointFunctionNameFromSourceName(const std::filesystem::path &file_name, SourceType type, SourceLanguage source_language, const std::string &entry_point_name)
Definition: types.cc:101

References impeller::compiler::ShaderConfig::entry_point, impeller::compiler::Reflector::Options::entry_point_name, impeller::compiler::SourceOptions::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::Reflector::Options::target_platform, impeller::compiler::SourceOptions::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 212 of file shader_bundle.cc.

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

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  shader_bundle.format_version = static_cast<uint32_t>(
198  fb::shaderbundle::ShaderBundleFormatVersion::kVersion);
199 
200  for (const auto& [shader_name, shader_config] : bundle_config.value()) {
201  std::unique_ptr<fb::shaderbundle::ShaderT> shader =
202  GenerateShaderFB(options, shader_name, shader_config);
203  if (!shader) {
204  return std::nullopt;
205  }
206  shader_bundle.shaders.push_back(std::move(shader));
207  }
208 
209  return shader_bundle;
210 }
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::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

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

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

Referenced by GenerateShaderBundleFlatbuffer().

◆ GetOptionAsPath()

static std::filesystem::path impeller::compiler::GetOptionAsPath ( const fml::CommandLine &  command_line,
const char *  arg 
)
static

Definition at line 171 of file switches.cc.

173  {
174  std::string value = command_line.GetOptionValueWithDefault(arg, "");
175  return std::filesystem::path(std::u8string(value.begin(), value.end()));
176 }
value
int32_t value
Definition: dl_golden_unittests.cc:459

References value.

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

851  {
852  auto struct_size = 0u;
853  for (const auto& member : members) {
854  struct_size += member.byte_length;
855  }
856  return struct_size;
857 }

◆ GetRuntimeStageBackend()

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

Definition at line 317 of file reflector.cc.

318  {
319  switch (target_platform) {
320  case TargetPlatform::kUnknown:
321  case TargetPlatform::kMetalDesktop:
322  case TargetPlatform::kMetalIOS:
323  case TargetPlatform::kOpenGLES:
324  case TargetPlatform::kOpenGLDesktop:
325  case TargetPlatform::kVulkan:
326  return std::nullopt;
327  case TargetPlatform::kRuntimeStageMetal:
328  return RuntimeStageBackend::kMetal;
329  case TargetPlatform::kRuntimeStageGLES:
330  return RuntimeStageBackend::kOpenGLES;
331  case TargetPlatform::kRuntimeStageGLES3:
332  return RuntimeStageBackend::kOpenGLES3;
333  case TargetPlatform::kRuntimeStageVulkan:
334  return RuntimeStageBackend::kVulkan;
335  case TargetPlatform::kSkSL:
336  return RuntimeStageBackend::kSkSL;
337  }
338  FML_UNREACHABLE();
339 }

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

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

◆ InferShaderNameFromPath()

std::string impeller::compiler::InferShaderNameFromPath ( const std::filesystem::path &  path)

Definition at line 34 of file utilities.cc.

34  {
35  return Utf8FromPath(path.stem());
36 }

References Utf8FromPath().

◆ JoinStrings()

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

Definition at line 580 of file compiler.cc.

581  {
582  std::stringstream stream;
583  for (size_t i = 0, count = items.size(); i < count; i++) {
584  const auto is_last = (i == count - 1);
585 
586  stream << items[i];
587  if (!is_last) {
588  stream << separator;
589  }
590  }
591  return stream.str();
592 }

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

◆ Main()

bool impeller::compiler::Main ( const fml::CommandLine &  command_line)
  1. Output the source file. When in IPLR/RuntimeStage mode, output the serialized IPLR flatbuffer. Otherwise output the shader source in the target shading language.
  2. Output SPIRV file.
  3. Output shader reflection data. May include a JSON file, a C++ header, and/or a C++ TU.
  4. Output a depfile.

Definition at line 197 of file impellerc_main.cc.

197  {
198  fml::InstallCrashHandler();
199  if (command_line.HasOption("help")) {
200  Switches::PrintHelp(std::cout);
201  return true;
202  }
203 
204  Switches switches(command_line);
205  if (!switches.AreValid(std::cerr)) {
206  std::cerr << "Invalid flags specified." << std::endl;
207  Switches::PrintHelp(std::cerr);
208  return false;
209  }
210 
211  if (!switches.shader_bundle.empty()) {
212  // Invoke the compiler multiple times to build a shader bundle with the
213  // given shader_bundle spec.
214  return GenerateShaderBundle(switches);
215  }
216 
217  std::shared_ptr<fml::FileMapping> source_file_mapping =
218  fml::FileMapping::CreateReadOnly(Utf8FromPath(switches.source_file_name));
219  if (!source_file_mapping) {
220  std::cerr << "Could not open input file." << std::endl;
221  return false;
222  }
223 
224  std::vector<std::shared_ptr<Compiler>> compilers;
225  compilers.reserve(switches.PlatformsToCompile().size());
226  for (const auto& platform : switches.PlatformsToCompile()) {
227  std::shared_ptr<Compiler> compiler =
228  CreateCompiler(platform, source_file_mapping, switches);
229  if (compiler->IsValid()) {
230  compilers.push_back(compiler);
231  } else {
232  std::cerr << "Compilation failed for target: "
233  << TargetPlatformToString(platform) << std::endl;
234 
235  std::string verbose_error_messages = compiler->GetVerboseErrorMessages();
236  if (verbose_error_messages.empty()) {
237  // No verbose error messages. Output the regular error messages.
238  std::cerr << compiler->GetErrorMessages();
239  } else {
240  if (switches.verbose) {
241  // Verbose messages are available and the --verbose flag was set.
242  // Directly output the verbose error messages.
243  std::cerr << verbose_error_messages;
244  } else {
245  // Verbose messages are available and the --verbose flag was not set.
246  // Output the regular error messages and write the verbose error
247  // messages to a file.
248  std::cerr << compiler->GetErrorMessages();
249  OutputVerboseErrorFile(verbose_error_messages, switches);
250  }
251  }
252 
253  return false;
254  }
255  }
256 
257  // --------------------------------------------------------------------------
258  /// 1. Output the source file. When in IPLR/RuntimeStage mode, output the
259  /// serialized IPLR flatbuffer. Otherwise output the shader source in the
260  /// target shading language.
261  ///
262 
263  if (switches.iplr) {
264  if (!OutputIPLR(compilers, switches)) {
265  return false;
266  }
267  } else {
268  // Non-IPLR mode is supported only for single platform targets. There is
269  // exactly 1 created compiler for this case.
270  FML_DCHECK(compilers.size() == 1);
271  if (!OutputSLFile(*compilers.front(), switches)) {
272  return false;
273  }
274  }
275 
276  // Use the first compiler for outputting the SPIRV file, reflection data, and
277  // the depfile. The SPIRV and depfile outputs do not depend on the target
278  // platform, so any valid compiler can be used. Reflection data output is only
279  // supported for single platform targets, so it uses the first (only) valid
280  // compiler as well.
281  auto first_valid_compiler = compilers.front();
282 
283  // --------------------------------------------------------------------------
284  /// 2. Output SPIRV file.
285  ///
286 
287  if (!OutputSPIRV(*first_valid_compiler, switches)) {
288  return false;
289  }
290 
291  // --------------------------------------------------------------------------
292  /// 3. Output shader reflection data.
293  /// May include a JSON file, a C++ header, and/or a C++ TU.
294  ///
295 
296  if (ShouldOutputReflectionData(switches)) {
297  // Outputting reflection data is supported only for single platform targets.
298  FML_DCHECK(compilers.size() == 1);
299  if (!OutputReflectionData(*first_valid_compiler, switches)) {
300  return false;
301  }
302  }
303 
304  // --------------------------------------------------------------------------
305  /// 4. Output a depfile.
306  ///
307 
308  // Dep file output does not depend on the target platform. Any valid compiler
309  // can be used to output it. Arbitrarily pick the first valid compiler.
310  if (!OutputDepfile(*first_valid_compiler, switches)) {
311  return false;
312  }
313 
314  return true;
315 }
impeller::compiler::TargetPlatformToString
std::string TargetPlatformToString(TargetPlatform platform)
Definition: types.cc:62
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:212
impeller::compiler::CreateCompiler
static CompilerBackend CreateCompiler(const spirv_cross::ParsedIR &ir, const SourceOptions &source_options)
Definition: compiler.cc:233

References impeller::compiler::Switches::AreValid(), CreateCompiler(), GenerateShaderBundle(), impeller::compiler::Switches::iplr, impeller::compiler::Switches::PlatformsToCompile(), impeller::compiler::Switches::PrintHelp(), impeller::compiler::Switches::shader_bundle, impeller::compiler::Switches::source_file_name, TargetPlatformToString(), Utf8FromPath(), and impeller::compiler::Switches::verbose.

Referenced by main().

◆ ParseMSLVersion()

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

Definition at line 43 of file compiler.cc.

43  {
44  std::stringstream sstream(msl_version);
45  std::string version_part;
46  uint32_t major = 1;
47  uint32_t minor = 2;
48  uint32_t patch = 0;
49  if (std::getline(sstream, version_part, '.')) {
50  major = std::stoi(version_part);
51  if (std::getline(sstream, version_part, '.')) {
52  minor = std::stoi(version_part);
53  if (std::getline(sstream, version_part, '.')) {
54  patch = std::stoi(version_part);
55  }
56  }
57  }
58  if (major < 1 || (major == 1 && minor < 2)) {
59  std::cerr << "--metal-version version must be at least 1.2. Have "
60  << msl_version << std::endl;
61  }
62  return spirv_cross::CompilerMSL::Options::make_msl_version(major, minor,
63  patch);
64 }

◆ 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"])
66  : SourceLanguage::kGLSL;
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 }
impeller::compiler::ShaderBundleConfig
std::unordered_map< std::string, ShaderConfig > ShaderBundleConfig
Definition: types.h:97
impeller::compiler::SourceTypeFromString
SourceType SourceTypeFromString(std::string name)
Definition: types.cc:34
impeller::compiler::ToSourceLanguage
SourceLanguage ToSourceLanguage(const std::string &source_language)
Definition: types.cc:52

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

805  {
806  switch (type) {
807  case spirv_cross::SPIRType::BaseType::Boolean:
808  return KnownType{
809  .name = "bool",
810  .byte_size = sizeof(bool),
811  };
812  case spirv_cross::SPIRType::BaseType::Float:
813  return KnownType{
814  .name = "Scalar",
815  .byte_size = sizeof(Scalar),
816  };
817  case spirv_cross::SPIRType::BaseType::Half:
818  return KnownType{
819  .name = "Half",
820  .byte_size = sizeof(Half),
821  };
822  case spirv_cross::SPIRType::BaseType::UInt:
823  return KnownType{
824  .name = "uint32_t",
825  .byte_size = sizeof(uint32_t),
826  };
827  case spirv_cross::SPIRType::BaseType::Int:
828  return KnownType{
829  .name = "int32_t",
830  .byte_size = sizeof(int32_t),
831  };
832  default:
833  break;
834  }
835  return std::nullopt;
836 }
impeller::Scalar
float Scalar
Definition: scalar.h:19

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 199 of file runtime_stage_data.cc.

199  {
200  switch (backend) {
201  case RuntimeStageBackend::kSkSL:
202  return "sksl";
203  case RuntimeStageBackend::kMetal:
204  return "metal";
205  case RuntimeStageBackend::kOpenGLES:
206  return "opengles";
207  case RuntimeStageBackend::kVulkan:
208  return "vulkan";
209  case RuntimeStageBackend::kOpenGLES3:
210  return "opengles3";
211  }
212 }

References impeller::kMetal, impeller::kOpenGLES, impeller::kOpenGLES3, 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 147 of file switches.cc.

148  {
149  std::vector<TargetPlatform> stages;
150  for (const auto& platform : kKnownRuntimeStages) {
151  if (command_line.HasOption(platform.first)) {
152  stages.push_back(platform.second);
153  }
154  }
155  return stages;
156 }
impeller::compiler::kKnownRuntimeStages
static const std::vector< std::pair< std::string, TargetPlatform > > kKnownRuntimeStages
Definition: switches.cc:29

References kKnownRuntimeStages.

◆ SetBindingBaseOffset()

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

Definition at line 211 of file spirv_compiler.cc.

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

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

◆ SetDefaultLimitations()

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

Definition at line 93 of file spirv_compiler.cc.

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

References value.

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

◆ ShaderCErrorToString()

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

Definition at line 130 of file types.cc.

130  {
131  using Status = shaderc_compilation_status;
132  switch (status) {
133  case Status::shaderc_compilation_status_success:
134  return "Success";
135  case Status::shaderc_compilation_status_invalid_stage:
136  return "Invalid shader stage specified";
137  case Status::shaderc_compilation_status_compilation_error:
138  return "Compilation error";
139  case Status::shaderc_compilation_status_internal_error:
140  return "Internal error";
141  case Status::shaderc_compilation_status_null_result_object:
142  return "Internal error. Null result object";
143  case Status::shaderc_compilation_status_invalid_assembly:
144  return "Invalid assembly";
145  case Status::shaderc_compilation_status_validation_error:
146  return "Validation error";
147  case Status::shaderc_compilation_status_transformation_error:
148  return "Transform error";
149  case Status::shaderc_compilation_status_configuration_error:
150  return "Configuration error";
151  }
152  return "Unknown internal error";
153 }

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

◆ SourceLanguageToString()

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

Definition at line 90 of file types.cc.

90  {
91  switch (source_language) {
92  case SourceLanguage::kUnknown:
93  return "Unknown";
94  case SourceLanguage::kGLSL:
95  return "GLSL";
96  case SourceLanguage::kHLSL:
97  return "HLSL";
98  }
99 }

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

159  {
160  auto source_type_option =
161  command_line.GetOptionValueWithDefault("input-type", "");
162  auto source_type_search = kKnownSourceTypes.find(source_type_option);
163  if (source_type_search == kKnownSourceTypes.end()) {
164  return SourceType::kUnknown;
165  }
166  return source_type_search->second;
167 }
impeller::compiler::kKnownSourceTypes
static const std::map< std::string, SourceType > kKnownSourceTypes
Definition: switches.cc:37

References kKnownSourceTypes, and kUnknown.

◆ SourceTypeFromFileName()

SourceType impeller::compiler::SourceTypeFromFileName ( const std::filesystem::path &  file_name)

Definition at line 17 of file types.cc.

17  {
18  std::string extension = file_name.extension().string();
19  if (extension == ".vert") {
20  return SourceType::kVertexShader;
21  }
22 
23  if (extension == ".frag") {
24  return SourceType::kFragmentShader;
25  }
26 
27  if (extension == ".comp") {
28  return SourceType::kComputeShader;
29  }
30 
31  return SourceType::kUnknown;
32 }

References kComputeShader, kFragmentShader, kUnknown, and kVertexShader.

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

◆ SourceTypeFromString()

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

Definition at line 34 of file types.cc.

34  {
35  name = ToLowerCase(name);
36 
37  if (name == "vertex") {
38  return SourceType::kVertexShader;
39  }
40 
41  if (name == "fragment") {
42  return SourceType::kFragmentShader;
43  }
44 
45  if (name == "compute") {
46  return SourceType::kComputeShader;
47  }
48 
49  return SourceType::kUnknown;
50 }
impeller::compiler::ToLowerCase
std::string ToLowerCase(std::string_view string)
Definition: utilities.cc:61

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

Referenced by ParseShaderBundleConfig().

◆ SourceTypeToString()

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

Definition at line 204 of file types.cc.

204  {
205  switch (type) {
206  case SourceType::kUnknown:
207  return "unknown";
208  case SourceType::kVertexShader:
209  return "vert";
210  case SourceType::kFragmentShader:
211  return "frag";
212  case SourceType::kComputeShader:
213  return "comp";
214  }
215  FML_UNREACHABLE();
216 }

References kComputeShader, kFragmentShader, kUnknown, and kVertexShader.

◆ StringStartsWith()

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

Definition at line 86 of file utilities.cc.

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

Referenced by CreateGLSLCompiler().

◆ StringToShaderStage()

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

Definition at line 48 of file reflector.cc.

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

◆ TargetPlatformFromCommandLine()

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

Definition at line 129 of file switches.cc.

130  {
131  auto target = TargetPlatform::kUnknown;
132  for (const auto& platform : kKnownPlatforms) {
133  if (command_line.HasOption(platform.first)) {
134  // If the platform has already been determined, the caller may have
135  // specified multiple platforms. This is an error and only one must be
136  // selected.
137  if (target != TargetPlatform::kUnknown) {
138  return TargetPlatform::kUnknown;
139  }
140  target = platform.second;
141  // Keep going to detect duplicates.
142  }
143  }
144  return target;
145 }
impeller::compiler::kKnownPlatforms
static const std::map< std::string, TargetPlatform > kKnownPlatforms
Definition: switches.cc:20

References kKnownPlatforms, and kUnknown.

◆ TargetPlatformIsMetal()

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

Definition at line 258 of file types.cc.

258  {
259  switch (platform) {
260  case TargetPlatform::kMetalDesktop:
261  case TargetPlatform::kMetalIOS:
262  case TargetPlatform::kRuntimeStageMetal:
263  return true;
264  case TargetPlatform::kUnknown:
265  case TargetPlatform::kSkSL:
266  case TargetPlatform::kOpenGLES:
267  case TargetPlatform::kOpenGLDesktop:
268  case TargetPlatform::kRuntimeStageGLES:
269  case TargetPlatform::kRuntimeStageGLES3:
270  case TargetPlatform::kRuntimeStageVulkan:
271  case TargetPlatform::kVulkan:
272  return false;
273  }
274  FML_UNREACHABLE();
275 }

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

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

◆ TargetPlatformIsOpenGL()

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

Definition at line 239 of file types.cc.

239  {
240  switch (platform) {
241  case TargetPlatform::kOpenGLES:
242  case TargetPlatform::kOpenGLDesktop:
243  case TargetPlatform::kRuntimeStageGLES:
244  case TargetPlatform::kRuntimeStageGLES3:
245  return true;
246  case TargetPlatform::kMetalDesktop:
247  case TargetPlatform::kRuntimeStageMetal:
248  case TargetPlatform::kRuntimeStageVulkan:
249  case TargetPlatform::kMetalIOS:
250  case TargetPlatform::kUnknown:
251  case TargetPlatform::kSkSL:
252  case TargetPlatform::kVulkan:
253  return false;
254  }
255  FML_UNREACHABLE();
256 }

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

◆ TargetPlatformIsVulkan()

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

Definition at line 277 of file types.cc.

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

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

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

◆ TargetPlatformSLExtension()

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

Definition at line 218 of file types.cc.

218  {
219  switch (platform) {
220  case TargetPlatform::kUnknown:
221  return "unknown";
222  case TargetPlatform::kMetalDesktop:
223  case TargetPlatform::kMetalIOS:
224  case TargetPlatform::kRuntimeStageMetal:
225  return "metal";
226  case TargetPlatform::kSkSL:
227  case TargetPlatform::kOpenGLES:
228  case TargetPlatform::kOpenGLDesktop:
229  case TargetPlatform::kRuntimeStageGLES:
230  case TargetPlatform::kRuntimeStageGLES3:
231  return "glsl";
232  case TargetPlatform::kVulkan:
233  case TargetPlatform::kRuntimeStageVulkan:
234  return "vk.spirv";
235  }
236  FML_UNREACHABLE();
237 }

References kMetalDesktop, kMetalIOS, kOpenGLDesktop, kOpenGLES, kRuntimeStageGLES, kRuntimeStageGLES3, 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 183 of file types.cc.

184  {
185  switch (platform) {
186  case TargetPlatform::kMetalIOS:
187  case TargetPlatform::kRuntimeStageMetal:
188  return spirv_cross::CompilerMSL::Options::Platform::iOS;
189  case TargetPlatform::kMetalDesktop:
190  return spirv_cross::CompilerMSL::Options::Platform::macOS;
191  case TargetPlatform::kSkSL:
192  case TargetPlatform::kOpenGLES:
193  case TargetPlatform::kOpenGLDesktop:
194  case TargetPlatform::kRuntimeStageGLES:
195  case TargetPlatform::kRuntimeStageGLES3:
196  case TargetPlatform::kRuntimeStageVulkan:
197  case TargetPlatform::kVulkan:
198  case TargetPlatform::kUnknown:
199  return spirv_cross::CompilerMSL::Options::Platform::macOS;
200  }
201  FML_UNREACHABLE();
202 }

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

◆ TargetPlatformToString()

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

Definition at line 62 of file types.cc.

62  {
63  switch (platform) {
64  case TargetPlatform::kUnknown:
65  return "Unknown";
66  case TargetPlatform::kMetalDesktop:
67  return "MetalDesktop";
68  case TargetPlatform::kMetalIOS:
69  return "MetaliOS";
70  case TargetPlatform::kOpenGLES:
71  return "OpenGLES";
72  case TargetPlatform::kOpenGLDesktop:
73  return "OpenGLDesktop";
74  case TargetPlatform::kVulkan:
75  return "Vulkan";
76  case TargetPlatform::kRuntimeStageMetal:
77  return "RuntimeStageMetal";
78  case TargetPlatform::kRuntimeStageGLES:
79  return "RuntimeStageGLES";
80  case TargetPlatform::kRuntimeStageGLES3:
81  return "RuntimeStageGLES3";
82  case TargetPlatform::kRuntimeStageVulkan:
83  return "RuntimeStageVulkan";
84  case TargetPlatform::kSkSL:
85  return "SkSL";
86  }
87  FML_UNREACHABLE();
88 }

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

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

◆ ToCamelCase()

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

Definition at line 38 of file utilities.cc.

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

◆ ToExecutionModel()

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

Definition at line 169 of file types.cc.

169  {
170  switch (type) {
171  case SourceType::kVertexShader:
172  return spv::ExecutionModel::ExecutionModelVertex;
173  case SourceType::kFragmentShader:
174  return spv::ExecutionModel::ExecutionModelFragment;
175  case SourceType::kComputeShader:
176  return spv::ExecutionModel::ExecutionModelGLCompute;
177  case SourceType::kUnknown:
178  break;
179  }
180  return spv::ExecutionModel::ExecutionModelMax;
181 }

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:
117  return fb::InputDataType::kFloat;
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:
122  return fb::shaderbundle::InputDataType::kFloat;
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 61 of file utilities.cc.

61  {
62  std::string result = std::string(string);
63  std::transform(result.begin(), result.end(), result.begin(),
64  [](char x) { return std::tolower(x); });
65  return result;
66 }
x
int32_t x
Definition: dl_golden_unittests.cc:458
transform
Matrix transform
Definition: gaussian_blur_filter_contents.cc:312

References transform, and x.

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

◆ ToShaderCShaderKind()

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

Definition at line 155 of file types.cc.

155  {
156  switch (type) {
157  case SourceType::kVertexShader:
158  return shaderc_shader_kind::shaderc_vertex_shader;
159  case SourceType::kFragmentShader:
160  return shaderc_shader_kind::shaderc_fragment_shader;
161  case SourceType::kComputeShader:
162  return shaderc_shader_kind::shaderc_compute_shader;
163  case SourceType::kUnknown:
164  break;
165  }
166  return shaderc_shader_kind::shaderc_glsl_infer_from_source;
167 }

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

52  {
53  if (source_language == "glsl") {
54  return SourceLanguage::kGLSL;
55  }
56  if (source_language == "hlsl") {
57  return SourceLanguage::kHLSL;
58  }
59  return SourceLanguage::kUnknown;
60 }

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

620  {
621  switch (type) {
622  case CompilerBackend::Type::kMSL:
623  return "Metal Shading Language";
624  case CompilerBackend::Type::kGLSL:
625  return "OpenGL Shading Language";
626  case CompilerBackend::Type::kGLSLVulkan:
627  return "OpenGL Shading Language (Relaxed Vulkan Semantics)";
628  case CompilerBackend::Type::kSkSL:
629  return "SkSL Shading Language";
630  }
631  FML_UNREACHABLE();
632 }

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::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:
65  return fb::UniformDataType::kFloat;
66  case spirv_cross::SPIRType::SampledImage:
67  return fb::UniformDataType::kSampledImage;
68  case spirv_cross::SPIRType::Struct:
69  return fb::UniformDataType::kStruct;
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().

◆ ToUniformType() [2/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:
80  return fb::shaderbundle::UniformDataType::kFloat;
81  case spirv_cross::SPIRType::Double:
82  return fb::shaderbundle::UniformDataType::kDouble;
83  case spirv_cross::SPIRType::SampledImage:
84  return fb::shaderbundle::UniformDataType::kSampledImage;
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.

◆ TypeNameWithPaddingOfSize()

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

Definition at line 793 of file reflector.cc.

793  {
794  std::stringstream stream;
795  stream << "Padding<" << size << ">";
796  return stream.str();
797 }

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(), impeller::compiler::SPIRVCompiler::CompileToSPV(), EntryPointFunctionNameFromSourceName(), GenerateShaderBundle(), InferShaderNameFromPath(), Main(), and impeller::compiler::Switches::Switches().

◆ VertexTypeFromInputResource()

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

Definition at line 1316 of file reflector.cc.

1318  {
1319  VertexType result;
1320  result.variable_name = resource->name;
1321  const auto& type = compiler.get_type(resource->type_id);
1322  result.base_type = type.basetype;
1323  const auto total_size = type.columns * type.vecsize * type.width / 8u;
1324  result.byte_length = total_size;
1325 
1326  if (type.basetype == spirv_cross::SPIRType::BaseType::Float &&
1327  type.columns == 1u && type.vecsize == 2u &&
1328  type.width == sizeof(float) * 8u) {
1329  result.type_name = "Point";
1330  } else if (type.basetype == spirv_cross::SPIRType::BaseType::Float &&
1331  type.columns == 1u && type.vecsize == 4u &&
1332  type.width == sizeof(float) * 8u) {
1333  result.type_name = "Vector4";
1334  } else if (type.basetype == spirv_cross::SPIRType::BaseType::Float &&
1335  type.columns == 1u && type.vecsize == 3u &&
1336  type.width == sizeof(float) * 8u) {
1337  result.type_name = "Vector3";
1338  } else if (type.basetype == spirv_cross::SPIRType::BaseType::Float &&
1339  type.columns == 1u && type.vecsize == 1u &&
1340  type.width == sizeof(float) * 8u) {
1341  result.type_name = "Scalar";
1342  } else if (type.basetype == spirv_cross::SPIRType::BaseType::Int &&
1343  type.columns == 1u && type.vecsize == 1u &&
1344  type.width == sizeof(int32_t) * 8u) {
1345  result.type_name = "int32_t";
1346  } else {
1347  // Catch all unknown padding.
1348  result.type_name = TypeNameWithPaddingOfSize(total_size);
1349  }
1350 
1351  return result;
1352 }
impeller::compiler::TypeNameWithPaddingOfSize
static std::string TypeNameWithPaddingOfSize(size_t size)
Definition: reflector.cc:793

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

Definition at line 187 of file runtime_stage_data.cc.

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

◆ kExternalTexturePrefix

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

Definition at line 11 of file constants.h.

Referenced by CreateGLSLCompiler().

◆ kFormatVersionKey

const char* impeller::compiler::kFormatVersionKey = "format_version"
static

Definition at line 184 of file runtime_stage_data.cc.

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

◆ 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::vector<std::pair<std::string, TargetPlatform> > impeller::compiler::kKnownRuntimeStages
static
Initial value:
= {
{"sksl", TargetPlatform::kSkSL},
{"runtime-stage-metal", TargetPlatform::kRuntimeStageMetal},
{"runtime-stage-gles", TargetPlatform::kRuntimeStageGLES},
{"runtime-stage-gles3", TargetPlatform::kRuntimeStageGLES3},
{"runtime-stage-vulkan", TargetPlatform::kRuntimeStageVulkan},
}

Definition at line 29 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 37 of file switches.cc.

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

◆ kMaxUniformBufferSize

const uint32_t impeller::compiler::kMaxUniformBufferSize = 6208
static

Definition at line 41 of file compiler.cc.

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

◆ kReflectionCCTemplate

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

Definition at line 202 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

Definition at line 189 of file runtime_stage_data.cc.

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

◆ kStageKey

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

Definition at line 185 of file runtime_stage_data.cc.

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

◆ kTargetPlatformKey

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

Definition at line 186 of file runtime_stage_data.cc.

◆ kUniformArrayElementsKey

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

Definition at line 196 of file runtime_stage_data.cc.

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

◆ kUniformBitWidthKey

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

Definition at line 195 of file runtime_stage_data.cc.

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

◆ kUniformColumnsKey

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

Definition at line 194 of file runtime_stage_data.cc.

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

◆ kUniformLocationKey

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

Definition at line 191 of file runtime_stage_data.cc.

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

◆ kUniformNameKey

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

Definition at line 190 of file runtime_stage_data.cc.

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

◆ kUniformRowsKey

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

Definition at line 193 of file runtime_stage_data.cc.

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

◆ kUniformsKey

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

Definition at line 188 of file runtime_stage_data.cc.

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

◆ kUniformStructElementsKey

const char* impeller::compiler::kUniformStructElementsKey = "struct_elements"
static

Definition at line 197 of file runtime_stage_data.cc.

◆ kUniformTypeKey

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

Definition at line 192 of file runtime_stage_data.cc.

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