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

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

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

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

static bool	OutputSLFile (const Compiler &compiler, const Switches &switches)

static bool	OutputReflectionData (const Compiler &compiler, const Switches &switches, const SourceOptions &options)

static bool	OutputDepfile (const Compiler &compiler, const Switches &switches)

bool	Main (const fml::CommandLine &command_line)

static std::string	ExecutionModelToString (spv::ExecutionModel model)

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

static std::optional< 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 bool	StringEndWith (const std::string &string, const std::string &suffix)

SourceType	SourceTypeFromFileName (const std::string &file_name)

SourceType	SourceTypeFromString (std::string name)

SourceLanguage	ToSourceLanguage (const std::string &source_language)

std::string	TargetPlatformToString (TargetPlatform platform)

std::string	SourceLanguageToString (SourceLanguage source_language)

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

bool	TargetPlatformNeedsReflection (TargetPlatform platform)

std::string	ShaderCErrorToString (shaderc_compilation_status status)

shaderc_shader_kind	ToShaderCShaderKind (SourceType type)

spv::ExecutionModel	ToExecutionModel (SourceType type)

spirv_cross::CompilerMSL::Options::Platform	TargetPlatformToMSLPlatform (TargetPlatform platform)

std::string	SourceTypeToString (SourceType type)

std::string	TargetPlatformSLExtension (TargetPlatform platform)

bool	TargetPlatformIsOpenGL (TargetPlatform platform)

bool	TargetPlatformIsMetal (TargetPlatform platform)

bool	TargetPlatformIsVulkan (TargetPlatform platform)

bool	TargetPlatformBundlesSkSL (TargetPlatform platform)

bool	SetPermissiveAccess (const std::filesystem::path &p)
	Sets the file access mode of the file at path 'p' to 0644. More...

std::string	Utf8FromPath (const std::filesystem::path &path)
	Converts a native format path to a utf8 string. More...

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

std::string	ToCamelCase (std::string_view string)

std::string	ToLowerCase (std::string_view string)

std::string	ConvertToEntrypointName (std::string_view string)
	Ensure that the entrypoint name is a valid identifier in the target language. More...

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

Variables
constexpr std::string_view	kReflectionHeaderTemplate

constexpr std::string_view	kReflectionCCTemplate

static const uint32_t	kMaxUniformBufferSize = 6208

constexpr char	kExternalTexturePrefix [] = "SAMPLER_EXTERNAL_OES_"

static const char *	kStageKey = "stage"

static const char *	kTargetPlatformKey = "target_platform"

static const char *	kEntrypointKey = "entrypoint"

static const char *	kUniformsKey = "uniforms"

static const char *	kShaderKey = "shader"

static const char *	kUniformNameKey = "name"

static const char *	kUniformLocationKey = "location"

static const char *	kUniformTypeKey = "type"

static const char *	kUniformRowsKey = "rows"

static const char *	kUniformColumnsKey = "columns"

static const char *	kUniformBitWidthKey = "bit_width"

static const char *	kUniformArrayElementsKey = "array_elements"

static const std::map< std::string, TargetPlatform >	kKnownPlatforms

static const std::map< 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 82 of file types.h.

Enumeration Type Documentation

◆ SourceLanguage

enum impeller::compiler::SourceLanguage

strong

Enumerator
kUnknown
kGLSL
kHLSL

Definition at line 42 of file types.h.

                           {
   kUnknown,
   kGLSL,
   kHLSL,
 };

◆ SourceType

enum impeller::compiler::SourceType

strong

Enumerator
kUnknown
kVertexShader
kFragmentShader
kComputeShader

Definition at line 21 of file types.h.

                       {
   kUnknown,
   kVertexShader,
   kFragmentShader,
   kComputeShader,
 };

◆ TargetPlatform

enum impeller::compiler::TargetPlatform

strong

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

Definition at line 28 of file types.h.

                           {
   kUnknown,
   kMetalDesktop,
   kMetalIOS,
   kOpenGLES,
   kOpenGLDesktop,
   kVulkan,
   kRuntimeStageMetal,
   kRuntimeStageGLES,
   kRuntimeStageGLES3,
   kRuntimeStageVulkan,
   kSkSL,
 };

Function Documentation

◆ CompileSkSL()

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

static

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

Definition at line 37 of file impellerc_main.cc.

                               {
   auto options = switches.CreateSourceOptions(TargetPlatform::kSkSL);
  
   Reflector::Options sksl_reflector_options =
       CreateReflectorOptions(options, switches);
   sksl_reflector_options.target_platform = TargetPlatform::kSkSL;
  
   Compiler sksl_compiler =
       Compiler(std::move(source_file_mapping), options, sksl_reflector_options);
   if (!sksl_compiler.IsValid()) {
     std::cerr << "Compilation to SkSL failed." << std::endl;
     std::cerr << sksl_compiler.GetErrorMessages() << std::endl;
     return nullptr;
   }
   return sksl_compiler.GetReflector()->GetRuntimeStageShaderData();
 }

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

Referenced by OutputIPLR().

◆ ConvertToEntrypointName()

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

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

Definition at line 69 of file utilities.cc.

                                                          {
   if (string.empty()) {
     return "";
   }
   std::stringstream stream;
   // Append a prefix if the first character is not a letter.
   if (!std::isalpha(string.data()[0])) {
     stream << "i_";
   }
   for (size_t i = 0, count = string.length(); i < count; i++) {
     auto ch = string.data()[i];
     if (std::isalnum(ch) || ch == '_') {
       stream << ch;
     }
   }
   return stream.str();
 }

References data.

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

                                                                            {
   CompilerBackend compiler;
   switch (source_options.target_platform) {
     case TargetPlatform::kMetalDesktop:
     case TargetPlatform::kMetalIOS:
     case TargetPlatform::kRuntimeStageMetal:
       compiler = CreateMSLCompiler(ir, source_options);
       break;
     case TargetPlatform::kVulkan:
     case TargetPlatform::kRuntimeStageVulkan:
       compiler = CreateVulkanCompiler(ir, source_options);
       break;
     case TargetPlatform::kUnknown:
     case TargetPlatform::kOpenGLES:
     case TargetPlatform::kOpenGLDesktop:
     case TargetPlatform::kRuntimeStageGLES:
     case TargetPlatform::kRuntimeStageGLES3:
       compiler = CreateGLSLCompiler(ir, source_options);
       break;
     case TargetPlatform::kSkSL:
       compiler = CreateSkSLCompiler(ir, source_options);
   }
   if (!compiler) {
     return {};
   }
   auto* backend = compiler.GetCompiler();
   if (!EntryPointMustBeNamedMain(source_options.target_platform) &&
       source_options.source_language == SourceLanguage::kGLSL) {
     backend->rename_entry_point("main", source_options.entry_point_name,
                                 ToExecutionModel(source_options.type));
   }
   return compiler;
 }

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

◆ CreateGLSLCompiler()

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

static

Definition at line 146 of file compiler.cc.

                                                                                {
   auto gl_compiler = std::make_shared<spirv_cross::CompilerGLSL>(ir);
  
   // Walk the variables and insert the external image extension if any of them
   // begins with the external texture prefix. Unfortunately, we can't walk
   // `gl_compiler->get_shader_resources().separate_samplers` until the compiler
   // is further along.
   //
   // Unfortunately, we can't just let the shader author add this extension and
   // use `samplerExternalOES` directly because compiling to spirv requires the
   // source language profile to be at least 310 ES, but this extension is
   // incompatible with ES 310+.
   for (auto& id : ir.ids_for_constant_or_variable) {
     if (StringStartsWith(ir.get_name(id), kExternalTexturePrefix)) {
       if (source_options.gles_language_version >= 300) {
         gl_compiler->require_extension(kEGLImageExternalExtension300);
       } else {
         gl_compiler->require_extension(kEGLImageExternalExtension);
       }
       break;
     }
   }
  
   spirv_cross::CompilerGLSL::Options sl_options;
   sl_options.force_zero_initialized_variables = true;
   sl_options.vertex.fixup_clipspace = true;
   if (source_options.target_platform == TargetPlatform::kOpenGLES ||
       source_options.target_platform == TargetPlatform::kRuntimeStageGLES ||
       source_options.target_platform == TargetPlatform::kRuntimeStageGLES3) {
     sl_options.version = source_options.gles_language_version > 0
                              ? source_options.gles_language_version
                              : 100;
     sl_options.es = true;
     if (source_options.target_platform == TargetPlatform::kRuntimeStageGLES3) {
       sl_options.version = 300;
     }
     if (source_options.require_framebuffer_fetch &&
         source_options.type == SourceType::kFragmentShader) {
       gl_compiler->remap_ext_framebuffer_fetch(0, 0, true);
     }
     gl_compiler->set_variable_type_remap_callback(
         [&](const spirv_cross::SPIRType& type, const std::string& var_name,
             std::string& name_of_type) {
           if (StringStartsWith(var_name, kExternalTexturePrefix)) {
             name_of_type = "samplerExternalOES";
           }
         });
   } else {
     sl_options.version = source_options.gles_language_version > 0
                              ? source_options.gles_language_version
                              : 120;
     sl_options.es = false;
   }
   gl_compiler->set_common_options(sl_options);
   return CompilerBackend(gl_compiler);
 }

References impeller::compiler::SourceOptions::gles_language_version, kExternalTexturePrefix, kFragmentShader, kOpenGLES, kRuntimeStageGLES, kRuntimeStageGLES3, impeller::compiler::SourceOptions::require_framebuffer_fetch, StringStartsWith(), impeller::compiler::SourceOptions::target_platform, impeller::compiler::SourceOptions::type, and 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 63 of file compiler.cc.

                                                  {}) {
   auto sl_compiler = std::make_shared<spirv_cross::CompilerMSL>(ir);
   spirv_cross::CompilerMSL::Options sl_options;
   sl_options.platform =
       TargetPlatformToMSLPlatform(source_options.target_platform);
   sl_options.msl_version = msl_version_override.value_or(
       ParseMSLVersion(source_options.metal_version));
   sl_options.ios_use_simdgroup_functions =
       sl_options.is_ios() &&
       sl_options.msl_version >=
           spirv_cross::CompilerMSL::Options::make_msl_version(2, 4, 0);
   sl_options.use_framebuffer_fetch_subpasses = true;
   sl_compiler->set_msl_options(sl_options);
  
   // Sort the float and sampler uniforms according to their declared/decorated
   // order. For user authored fragment shaders, the API for setting uniform
   // values uses the index of the uniform in the declared order. By default, the
   // metal backend of spirv-cross will order uniforms according to usage. To fix
   // this, we use the sorted order and the add_msl_resource_binding API to force
   // the ordering to match the declared order. Note that while this code runs
   // for all compiled shaders, it will only affect vertex and fragment shaders
   // due to the specified stage.
   auto floats =
       SortUniforms(&ir, sl_compiler.get(), spirv_cross::SPIRType::Float);
   auto images =
       SortUniforms(&ir, sl_compiler.get(), spirv_cross::SPIRType::SampledImage);
  
   spv::ExecutionModel execution_model =
       spv::ExecutionModel::ExecutionModelFragment;
   if (source_options.type == SourceType::kVertexShader) {
     execution_model = spv::ExecutionModel::ExecutionModelVertex;
   }
  
   uint32_t buffer_offset = 0;
   uint32_t sampler_offset = 0;
   for (auto& float_id : floats) {
     sl_compiler->add_msl_resource_binding(
         {.stage = execution_model,
          .basetype = spirv_cross::SPIRType::BaseType::Float,
          .desc_set = sl_compiler->get_decoration(float_id,
                                                  spv::DecorationDescriptorSet),
          .binding =
              sl_compiler->get_decoration(float_id, spv::DecorationBinding),
          .count = 1u,
          .msl_buffer = buffer_offset});
     buffer_offset++;
   }
   for (auto& image_id : images) {
     sl_compiler->add_msl_resource_binding({
         .stage = execution_model,
         .basetype = spirv_cross::SPIRType::BaseType::SampledImage,
         .desc_set =
             sl_compiler->get_decoration(image_id, spv::DecorationDescriptorSet),
         .binding =
             sl_compiler->get_decoration(image_id, spv::DecorationBinding),
         .count = 1u,
         // A sampled image is both an image and a sampler, so both
         // offsets need to be set or depending on the partiular shader
         // the bindings may be incorrect.
         .msl_texture = sampler_offset,
         .msl_sampler = sampler_offset,
     });
     sampler_offset++;
   }
  
   return CompilerBackend(sl_compiler);
 }

Referenced by CreateCompiler().

◆ CreateReflectorOptions()

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

static

Definition at line 23 of file impellerc_main.cc.

                                                                            {
   Reflector::Options reflector_options;
   reflector_options.target_platform = options.target_platform;
   reflector_options.entry_point_name = options.entry_point_name;
   reflector_options.shader_name =
       InferShaderNameFromPath(switches.source_file_name);
   reflector_options.header_file_name = Utf8FromPath(
       std::filesystem::path{switches.reflection_header_name}.filename());
   return reflector_options;
 }

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

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

◆ CreateSkSLCompiler()

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

static

Definition at line 204 of file compiler.cc.

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

Referenced by CreateCompiler().

◆ CreateVulkanCompiler()

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

static

Definition at line 134 of file compiler.cc.

                                          {
   auto gl_compiler = std::make_shared<spirv_cross::CompilerGLSL>(ir);
   spirv_cross::CompilerGLSL::Options sl_options;
   sl_options.force_zero_initialized_variables = true;
   sl_options.vertex.fixup_clipspace = true;
   sl_options.vulkan_semantics = true;
   gl_compiler->set_common_options(sl_options);
   return CompilerBackend(gl_compiler);
 }

Referenced by CreateCompiler().

◆ EntryPointFunctionNameFromSourceName()

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

Definition at line 113 of file types.cc.

                                        {
   if (source_language == SourceLanguage::kHLSL) {
     return entry_point_name;
   }
  
   std::stringstream stream;
   std::filesystem::path file_path(file_name);
   stream << ConvertToEntrypointName(Utf8FromPath(file_path.stem())) << "_";
   switch (type) {
     case SourceType::kUnknown:
       stream << "unknown";
       break;
     case SourceType::kVertexShader:
       stream << "vertex";
       break;
     case SourceType::kFragmentShader:
       stream << "fragment";
       break;
     case SourceType::kComputeShader:
       stream << "compute";
       break;
   }
   stream << "_main";
   return stream.str();
 }

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

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

◆ EntryPointMustBeNamedMain()

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

static

Definition at line 210 of file compiler.cc.

                                                                {
   switch (platform) {
     case TargetPlatform::kUnknown:
       FML_UNREACHABLE();
     case TargetPlatform::kMetalDesktop:
     case TargetPlatform::kMetalIOS:
     case TargetPlatform::kVulkan:
     case TargetPlatform::kRuntimeStageMetal:
     case TargetPlatform::kRuntimeStageVulkan:
       return false;
     case TargetPlatform::kSkSL:
     case TargetPlatform::kOpenGLES:
     case TargetPlatform::kOpenGLDesktop:
     case TargetPlatform::kRuntimeStageGLES:
     case TargetPlatform::kRuntimeStageGLES3:
       return true;
   }
   FML_UNREACHABLE();
 }

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

Referenced by CreateCompiler().

◆ ExecutionModelToString()

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

static

Definition at line 33 of file reflector.cc.

                                                                  {
   switch (model) {
     case spv::ExecutionModel::ExecutionModelVertex:
       return "vertex";
     case spv::ExecutionModel::ExecutionModelFragment:
       return "fragment";
     case spv::ExecutionModel::ExecutionModelGLCompute:
       return "compute";
     default:
       return "unsupported";
   }
 }

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

                                                            {
   auto result = std::make_unique<fb::shaderbundle::BackendShaderT>();
  
   std::shared_ptr<fml::FileMapping> source_file_mapping =
       fml::FileMapping::CreateReadOnly(shader_config.source_file_name);
   if (!source_file_mapping) {
     std::cerr << "Could not open file for bundled shader \"" << shader_name
               << "\"." << std::endl;
     return nullptr;
   }
  
   /// Override options.
   options.target_platform = target_platform;
   options.file_name = shader_name;  // This is just used for error messages.
   options.type = shader_config.type;
   options.source_language = shader_config.language;
   options.entry_point_name = EntryPointFunctionNameFromSourceName(
       shader_config.source_file_name, options.type, options.source_language,
       shader_config.entry_point);
  
   Reflector::Options reflector_options;
   reflector_options.target_platform = options.target_platform;
   reflector_options.entry_point_name = options.entry_point_name;
   reflector_options.shader_name = shader_name;
  
   Compiler compiler(source_file_mapping, options, reflector_options);
   if (!compiler.IsValid()) {
     std::cerr << "Compilation failed for bundled shader \"" << shader_name
               << "\"." << std::endl;
     std::cerr << compiler.GetErrorMessages() << std::endl;
     return nullptr;
   }
  
   auto reflector = compiler.GetReflector();
   if (reflector == nullptr) {
     std::cerr << "Could not create reflector for bundled shader \""
               << shader_name << "\"." << std::endl;
     return nullptr;
   }
  
   auto bundle_data = reflector->GetShaderBundleData();
   if (!bundle_data) {
     std::cerr << "Bundled shader information was nil for \"" << shader_name
               << "\"." << std::endl;
     return nullptr;
   }
  
   result = bundle_data->CreateFlatbuffer();
   if (!result) {
     std::cerr << "Failed to create flatbuffer for bundled shader \""
               << shader_name << "\"." << std::endl;
     return nullptr;
   }
  
   return result;
 }

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.

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

Definition at line 210 of file shader_bundle.cc.

                                               {
   // --------------------------------------------------------------------------
   /// 1. Parse the shader bundle and generate the flatbuffer result.
   ///
  
   auto shader_bundle = GenerateShaderBundleFlatbuffer(
       switches.shader_bundle, switches.CreateSourceOptions());
   if (!shader_bundle.has_value()) {
     // Specific error messages are already handled by
     // GenerateShaderBundleFlatbuffer.
     return false;
   }
  
   // --------------------------------------------------------------------------
   /// 2. Serialize the shader bundle and write to disk.
   ///
  
   auto builder = std::make_shared<flatbuffers::FlatBufferBuilder>();
   builder->Finish(fb::shaderbundle::ShaderBundle::Pack(*builder.get(),
                                                        &shader_bundle.value()),
                   fb::shaderbundle::ShaderBundleIdentifier());
   auto mapping = std::make_shared<fml::NonOwnedMapping>(
       builder->GetBufferPointer(), builder->GetSize(),
       [builder](auto, auto) {});
  
   auto sl_file_name = std::filesystem::absolute(
       std::filesystem::current_path() / switches.sl_file_name);
  
   if (!fml::WriteAtomically(*switches.working_directory,         //
                             Utf8FromPath(sl_file_name).c_str(),  //
                             *mapping                             //
                             )) {
     std::cerr << "Could not write file to " << switches.sl_file_name
               << std::endl;
     return false;
   }
   // Tools that consume the runtime stage data expect the access mode to
   // be 0644.
   if (!SetPermissiveAccess(sl_file_name)) {
     return false;
   }
  
   return true;
 }

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.

Parse the bundle configuration.
Build the deserialized shader bundle.

Definition at line 179 of file shader_bundle.cc.

                                   {
   // --------------------------------------------------------------------------
   /// 1. Parse the bundle configuration.
   ///
  
   std::optional<ShaderBundleConfig> bundle_config =
       ParseShaderBundleConfig(bundle_config_json, std::cerr);
   if (!bundle_config) {
     return std::nullopt;
   }
  
   // --------------------------------------------------------------------------
   /// 2. Build the deserialized shader bundle.
   ///
  
   fb::shaderbundle::ShaderBundleT shader_bundle;
  
   for (const auto& [shader_name, shader_config] : bundle_config.value()) {
     std::unique_ptr<fb::shaderbundle::ShaderT> shader =
         GenerateShaderFB(options, shader_name, shader_config);
     if (!shader) {
       return std::nullopt;
     }
     shader_bundle.shaders.push_back(std::move(shader));
   }
  
   return shader_bundle;
 }

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.

                                        {
   auto result = std::make_unique<fb::shaderbundle::ShaderT>();
   result->name = shader_name;
   result->metal_ios = GenerateShaderBackendFB(
       TargetPlatform::kMetalIOS, options, shader_name, shader_config);
   if (!result->metal_ios) {
     return nullptr;
   }
   result->metal_desktop = GenerateShaderBackendFB(
       TargetPlatform::kMetalDesktop, options, shader_name, shader_config);
   if (!result->metal_desktop) {
     return nullptr;
   }
   result->opengl_es = GenerateShaderBackendFB(
       TargetPlatform::kOpenGLES, options, shader_name, shader_config);
   if (!result->opengl_es) {
     return nullptr;
   }
   result->opengl_desktop = GenerateShaderBackendFB(
       TargetPlatform::kOpenGLDesktop, options, shader_name, shader_config);
   if (!result->opengl_desktop) {
     return nullptr;
   }
   result->vulkan = GenerateShaderBackendFB(TargetPlatform::kVulkan, options,
                                            shader_name, shader_config);
   if (!result->vulkan) {
     return nullptr;
   }
   return result;
 }

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

Referenced by GenerateShaderBundleFlatbuffer().

◆ GetReflectedStructSize()

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

static

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

Parameters

[in] members The members

Returns: The reflected structure size.

Definition at line 801 of file reflector.cc.

                                                                              {
   auto struct_size = 0u;
   for (const auto& member : members) {
     struct_size += member.byte_length;
   }
   return struct_size;
 }

◆ GetRuntimeStageBackend()

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

static

Definition at line 301 of file reflector.cc.

                                     {
   switch (target_platform) {
     case TargetPlatform::kUnknown:
     case TargetPlatform::kMetalDesktop:
     case TargetPlatform::kMetalIOS:
     case TargetPlatform::kOpenGLES:
     case TargetPlatform::kOpenGLDesktop:
     case TargetPlatform::kVulkan:
       return std::nullopt;
     case TargetPlatform::kRuntimeStageMetal:
       return RuntimeStageBackend::kMetal;
     case TargetPlatform::kRuntimeStageGLES:
       return RuntimeStageBackend::kOpenGLES;
     case TargetPlatform::kRuntimeStageGLES3:
       return RuntimeStageBackend::kOpenGLES3;
     case TargetPlatform::kRuntimeStageVulkan:
       return RuntimeStageBackend::kVulkan;
     case TargetPlatform::kSkSL:
       return RuntimeStageBackend::kSkSL;
   }
   FML_UNREACHABLE();
 }

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

◆ InferShaderNameFromPath()

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

Definition at line 34 of file utilities.cc.

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

References Utf8FromPath().

Referenced by CreateReflectorOptions().

◆ JoinStrings()

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

static

Definition at line 512 of file compiler.cc.

                                                            {
   std::stringstream stream;
   for (size_t i = 0, count = items.size(); i < count; i++) {
     const auto is_last = (i == count - 1);
  
     stream << items[i];
     if (!is_last) {
       stream << separator;
     }
   }
   return stream.str();
 }

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

◆ Main()

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

Definition at line 234 of file impellerc_main.cc.

                                               {
   fml::InstallCrashHandler();
   if (command_line.HasOption("help")) {
     Switches::PrintHelp(std::cout);
     return true;
   }
  
   Switches switches(command_line);
   if (!switches.AreValid(std::cerr)) {
     std::cerr << "Invalid flags specified." << std::endl;
     Switches::PrintHelp(std::cerr);
     return false;
   }
  
   if (!switches.shader_bundle.empty()) {
     // Invoke the compiler multiple times to build a shader bundle with the
     // given shader_bundle spec.
     return GenerateShaderBundle(switches);
   }
  
   std::shared_ptr<fml::FileMapping> source_file_mapping =
       fml::FileMapping::CreateReadOnly(switches.source_file_name);
   if (!source_file_mapping) {
     std::cerr << "Could not open input file." << std::endl;
     return false;
   }
  
   if (switches.iplr && !OutputIPLR(switches, source_file_mapping)) {
     return false;
   }
  
   // Create at least one compiler to output the SL file, reflection data, and a
   // depfile.
  
   SourceOptions options = switches.CreateSourceOptions();
  
   // Invoke the compiler and generate reflection data for a single shader.
  
   Reflector::Options reflector_options =
       CreateReflectorOptions(options, switches);
  
   Compiler compiler(source_file_mapping, options, reflector_options);
   if (!compiler.IsValid()) {
     std::cerr << "Compilation failed." << std::endl;
     std::cerr << compiler.GetErrorMessages() << std::endl;
     return false;
   }
  
   auto spriv_file_name = std::filesystem::absolute(
       std::filesystem::current_path() / switches.spirv_file_name);
   if (!fml::WriteAtomically(*switches.working_directory,
                             Utf8FromPath(spriv_file_name).c_str(),
                             *compiler.GetSPIRVAssembly())) {
     std::cerr << "Could not write file to " << switches.spirv_file_name
               << std::endl;
     return false;
   }
  
   if (!switches.iplr && !OutputSLFile(compiler, switches)) {
     return false;
   }
  
   if (!OutputReflectionData(compiler, switches, options)) {
     return false;
   }
  
   if (!OutputDepfile(compiler, switches)) {
     return false;
   }
  
   return true;
 }

Referenced by main().

◆ OutputDepfile()

static bool impeller::compiler::OutputDepfile	(	const Compiler &	compiler,
		const Switches &	switches
	)

static

Output a depfile.

Definition at line 196 of file impellerc_main.cc.

                                                                               {
   // --------------------------------------------------------------------------
   /// 4. Output a depfile.
   ///
  
   if (!switches.depfile_path.empty()) {
     std::string result_file;
     switch (switches.SelectDefaultTargetPlatform()) {
       case TargetPlatform::kMetalDesktop:
       case TargetPlatform::kMetalIOS:
       case TargetPlatform::kOpenGLES:
       case TargetPlatform::kOpenGLDesktop:
       case TargetPlatform::kRuntimeStageMetal:
       case TargetPlatform::kRuntimeStageGLES:
       case TargetPlatform::kRuntimeStageGLES3:
       case TargetPlatform::kRuntimeStageVulkan:
       case TargetPlatform::kSkSL:
       case TargetPlatform::kVulkan:
         result_file = switches.sl_file_name;
         break;
       case TargetPlatform::kUnknown:
         result_file = switches.spirv_file_name;
         break;
     }
     auto depfile_path = std::filesystem::absolute(
         std::filesystem::current_path() / switches.depfile_path.c_str());
     if (!fml::WriteAtomically(*switches.working_directory,
                               Utf8FromPath(depfile_path).c_str(),
                               *compiler.CreateDepfileContents({result_file}))) {
       std::cerr << "Could not write depfile to " << switches.depfile_path
                 << std::endl;
       return false;
     }
   }
  
   return true;
 }

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

Referenced by Main().

◆ OutputIPLR()

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

static

Definition at line 56 of file impellerc_main.cc.

                                                           {
   FML_DCHECK(switches.iplr);
  
   RuntimeStageData stages;
   std::shared_ptr<RuntimeStageData::Shader> sksl_shader;
   if (TargetPlatformBundlesSkSL(switches.SelectDefaultTargetPlatform())) {
     sksl_shader = CompileSkSL(source_file_mapping, switches);
     if (!sksl_shader) {
       return false;
     }
     stages.AddShader(sksl_shader);
   }
  
   for (const auto& platform : switches.PlatformsToCompile()) {
     if (platform == TargetPlatform::kSkSL) {
       // Already handled above.
       continue;
     }
     SourceOptions options = switches.CreateSourceOptions(platform);
  
     // Invoke the compiler and generate reflection data for a single shader.
  
     Reflector::Options reflector_options =
         CreateReflectorOptions(options, switches);
     Compiler compiler(source_file_mapping, options, reflector_options);
     if (!compiler.IsValid()) {
       std::cerr << "Compilation failed." << std::endl;
       std::cerr << compiler.GetErrorMessages() << std::endl;
       return false;
     }
  
     auto reflector = compiler.GetReflector();
     if (reflector == nullptr) {
       std::cerr << "Could not create reflector." << std::endl;
       return false;
     }
  
     auto stage_data = reflector->GetRuntimeStageShaderData();
     if (!stage_data) {
       std::cerr << "Runtime stage information was nil." << std::endl;
       return false;
     }
  
     stages.AddShader(stage_data);
   }
  
   auto stage_data_mapping = switches.json_format ? stages.CreateJsonMapping()
                                                  : stages.CreateMapping();
   if (!stage_data_mapping) {
     std::cerr << "Runtime stage data could not be created." << std::endl;
     return false;
   }
   if (!fml::WriteAtomically(*switches.working_directory,                  //
                             Utf8FromPath(switches.sl_file_name).c_str(),  //
                             *stage_data_mapping                           //
                             )) {
     std::cerr << "Could not write file to " << switches.sl_file_name
               << std::endl;
     return false;
   }
   // Tools that consume the runtime stage data expect the access mode to
   // be 0644.
   if (!SetPermissiveAccess(switches.sl_file_name)) {
     return false;
   }
   return true;
 }

Referenced by Main().

◆ OutputReflectionData()

static bool impeller::compiler::OutputReflectionData	(	const Compiler &	compiler,
		const Switches &	switches,
		const SourceOptions &	options
	)

static

Output shader reflection data. May include a JSON file, a C++ header, and/or a C++ TU.

Definition at line 144 of file impellerc_main.cc.

                                                                {
   // --------------------------------------------------------------------------
   /// 3. Output shader reflection data.
   ///    May include a JSON file, a C++ header, and/or a C++ TU.
   ///
  
   if (TargetPlatformNeedsReflection(options.target_platform)) {
     if (!switches.reflection_json_name.empty()) {
       auto reflection_json_name = std::filesystem::absolute(
           std::filesystem::current_path() / switches.reflection_json_name);
       if (!fml::WriteAtomically(
               *switches.working_directory,
               Utf8FromPath(reflection_json_name).c_str(),
               *compiler.GetReflector()->GetReflectionJSON())) {
         std::cerr << "Could not write reflection json to "
                   << switches.reflection_json_name << std::endl;
         return false;
       }
     }
  
     if (!switches.reflection_header_name.empty()) {
       auto reflection_header_name =
           std::filesystem::absolute(std::filesystem::current_path() /
                                     switches.reflection_header_name.c_str());
       if (!fml::WriteAtomically(
               *switches.working_directory,
               Utf8FromPath(reflection_header_name).c_str(),
               *compiler.GetReflector()->GetReflectionHeader())) {
         std::cerr << "Could not write reflection header to "
                   << switches.reflection_header_name << std::endl;
         return false;
       }
     }
  
     if (!switches.reflection_cc_name.empty()) {
       auto reflection_cc_name =
           std::filesystem::absolute(std::filesystem::current_path() /
                                     switches.reflection_cc_name.c_str());
       if (!fml::WriteAtomically(*switches.working_directory,
                                 Utf8FromPath(reflection_cc_name).c_str(),
                                 *compiler.GetReflector()->GetReflectionCC())) {
         std::cerr << "Could not write reflection CC to "
                   << switches.reflection_cc_name << std::endl;
         return false;
       }
     }
   }
   return true;
 }

Referenced by Main().

◆ OutputSLFile()

static bool impeller::compiler::OutputSLFile	(	const Compiler &	compiler,
		const Switches &	switches
	)

static

Output the source file. When in IPLR/RuntimeStage mode, output the serialized IPLR flatbuffer.

Definition at line 126 of file impellerc_main.cc.

                                                                              {
   // --------------------------------------------------------------------------
   /// 2. Output the source file. When in IPLR/RuntimeStage mode, output the
   ///    serialized IPLR flatbuffer.
   ///
  
   auto sl_file_name = std::filesystem::absolute(
       std::filesystem::current_path() / switches.sl_file_name);
   if (!fml::WriteAtomically(*switches.working_directory,
                             Utf8FromPath(sl_file_name).c_str(),
                             *compiler.GetSLShaderSource())) {
     std::cerr << "Could not write file to " << switches.sl_file_name
               << std::endl;
     return false;
   }
   return true;
 }

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

Referenced by Main().

◆ ParseMSLVersion()

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

static

Definition at line 40 of file compiler.cc.

                                                               {
   std::stringstream sstream(msl_version);
   std::string version_part;
   uint32_t major = 1;
   uint32_t minor = 2;
   uint32_t patch = 0;
   if (std::getline(sstream, version_part, '.')) {
     major = std::stoi(version_part);
     if (std::getline(sstream, version_part, '.')) {
       minor = std::stoi(version_part);
       if (std::getline(sstream, version_part, '.')) {
         patch = std::stoi(version_part);
       }
     }
   }
   if (major < 1 || (major == 1 && minor < 2)) {
     std::cerr << "--metal-version version must be at least 1.2. Have "
               << msl_version << std::endl;
   }
   return spirv_cross::CompilerMSL::Options::make_msl_version(major, minor,
                                                              patch);
 }

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

                               {
   auto json = nlohmann::json::parse(bundle_config_json, nullptr, false);
   if (json.is_discarded() || !json.is_object()) {
     error_stream << "The shader bundle is not a valid JSON object."
                  << std::endl;
     return std::nullopt;
   }
  
   ShaderBundleConfig bundle;
   for (auto& [shader_name, shader_value] : json.items()) {
     if (bundle.find(shader_name) != bundle.end()) {
       error_stream << "Duplicate shader \"" << shader_name << "\"."
                    << std::endl;
       return std::nullopt;
     }
     if (!shader_value.is_object()) {
       error_stream << "Invalid shader entry \"" << shader_name
                    << "\": Entry is not a JSON object." << std::endl;
       return std::nullopt;
     }
  
     ShaderConfig shader;
  
     if (!shader_value.contains("file")) {
       error_stream << "Invalid shader entry \"" << shader_name
                    << "\": Missing required \"file\" field." << std::endl;
       return std::nullopt;
     }
     shader.source_file_name = shader_value["file"];
  
     if (!shader_value.contains("type")) {
       error_stream << "Invalid shader entry \"" << shader_name
                    << "\": Missing required \"type\" field." << std::endl;
       return std::nullopt;
     }
     shader.type = SourceTypeFromString(shader_value["type"]);
     if (shader.type == SourceType::kUnknown) {
       error_stream << "Invalid shader entry \"" << shader_name
                    << "\": Shader type " << shader_value["type"]
                    << " is unknown." << std::endl;
       return std::nullopt;
     }
  
     shader.language = shader_value.contains("language")
                           ? ToSourceLanguage(shader_value["language"])
                           : SourceLanguage::kGLSL;
     if (shader.language == SourceLanguage::kUnknown) {
       error_stream << "Invalid shader entry \"" << shader_name
                    << "\": Unknown language type " << shader_value["language"]
                    << "." << std::endl;
       return std::nullopt;
     }
  
     shader.entry_point = shader_value.contains("entry_point")
                              ? shader_value["entry_point"]
                              : "main";
  
     bundle[shader_name] = shader;
   }
  
   return bundle;
 }

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

                                       {
   switch (type) {
     case spirv_cross::SPIRType::BaseType::Boolean:
       return KnownType{
           .name = "bool",
           .byte_size = sizeof(bool),
       };
     case spirv_cross::SPIRType::BaseType::Float:
       return KnownType{
           .name = "Scalar",
           .byte_size = sizeof(Scalar),
       };
     case spirv_cross::SPIRType::BaseType::Half:
       return KnownType{
           .name = "Half",
           .byte_size = sizeof(Half),
       };
     case spirv_cross::SPIRType::BaseType::UInt:
       return KnownType{
           .name = "uint32_t",
           .byte_size = sizeof(uint32_t),
       };
     case spirv_cross::SPIRType::BaseType::Int:
       return KnownType{
           .name = "int32_t",
           .byte_size = sizeof(int32_t),
       };
     default:
       break;
   }
   return std::nullopt;
 }

References impeller::compiler::KnownType::name, and type.

◆ report_and_exit()

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

Definition at line 16 of file spirv_sksl.cc.

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

◆ RuntimeStageBackendToString()

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

static

Definition at line 197 of file runtime_stage_data.cc.

                                                                           {
   switch (backend) {
     case RuntimeStageBackend::kSkSL:
       return "sksl";
     case RuntimeStageBackend::kMetal:
       return "metal";
     case RuntimeStageBackend::kOpenGLES:
       return "opengles";
     case RuntimeStageBackend::kVulkan:
       return "vulkan";
     case RuntimeStageBackend::kOpenGLES3:
       return "opengles3";
   }
 }

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

                                         {
   std::vector<TargetPlatform> stages;
   for (const auto& platform : kKnownRuntimeStages) {
     if (command_line.HasOption(platform.first)) {
       stages.push_back(platform.second);
     }
   }
   return stages;
 }

References kKnownRuntimeStages.

◆ SetBindingBaseOffset()

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

static

Definition at line 210 of file spirv_compiler.cc.

                                                                  {
   constexpr uint32_t kBindingBaseOffset = 64;
   static const shaderc_uniform_kind kUniformKinds[] = {
       shaderc_uniform_kind::shaderc_uniform_kind_sampler,
       shaderc_uniform_kind::shaderc_uniform_kind_texture,
       shaderc_uniform_kind::shaderc_uniform_kind_image,
       shaderc_uniform_kind::shaderc_uniform_kind_buffer,          // UBOs
       shaderc_uniform_kind::shaderc_uniform_kind_storage_buffer,  // SSBOs
   };
  
   for (size_t i = 0u; i < sizeof(kUniformKinds) / sizeof(shaderc_uniform_kind);
        i++) {
     options.SetBindingBaseForStage(
         shaderc_shader_kind::shaderc_fragment_shader,  //
         kUniformKinds[i],                              //
         kBindingBaseOffset                             //
     );
   }
 }

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

◆ SetDefaultLimitations()

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

static

Definition at line 92 of file spirv_compiler.cc.

                                                                         {
   using Limit = std::pair<shaderc_limit, int>;
   static constexpr std::array<Limit, 83> limits = {
       Limit{shaderc_limit::shaderc_limit_max_lights, 8},
       Limit{shaderc_limit::shaderc_limit_max_clip_planes, 6},
       Limit{shaderc_limit::shaderc_limit_max_texture_units, 2},
       Limit{shaderc_limit::shaderc_limit_max_texture_coords, 8},
       Limit{shaderc_limit::shaderc_limit_max_vertex_attribs, 16},
       Limit{shaderc_limit::shaderc_limit_max_vertex_uniform_components, 4096},
       Limit{shaderc_limit::shaderc_limit_max_varying_floats, 60},
       Limit{shaderc_limit::shaderc_limit_max_vertex_texture_image_units, 16},
       Limit{shaderc_limit::shaderc_limit_max_combined_texture_image_units, 80},
       Limit{shaderc_limit::shaderc_limit_max_texture_image_units, 16},
       Limit{shaderc_limit::shaderc_limit_max_fragment_uniform_components, 1024},
       Limit{shaderc_limit::shaderc_limit_max_draw_buffers, 8},
       Limit{shaderc_limit::shaderc_limit_max_vertex_uniform_vectors, 256},
       Limit{shaderc_limit::shaderc_limit_max_varying_vectors, 15},
       Limit{shaderc_limit::shaderc_limit_max_fragment_uniform_vectors, 256},
       Limit{shaderc_limit::shaderc_limit_max_vertex_output_vectors, 16},
       Limit{shaderc_limit::shaderc_limit_max_fragment_input_vectors, 15},
       Limit{shaderc_limit::shaderc_limit_min_program_texel_offset, -8},
       Limit{shaderc_limit::shaderc_limit_max_program_texel_offset, 7},
       Limit{shaderc_limit::shaderc_limit_max_clip_distances, 8},
       Limit{shaderc_limit::shaderc_limit_max_compute_work_group_count_x, 65535},
       Limit{shaderc_limit::shaderc_limit_max_compute_work_group_count_y, 65535},
       Limit{shaderc_limit::shaderc_limit_max_compute_work_group_count_z, 65535},
       Limit{shaderc_limit::shaderc_limit_max_compute_work_group_size_x, 1024},
       Limit{shaderc_limit::shaderc_limit_max_compute_work_group_size_y, 1024},
       Limit{shaderc_limit::shaderc_limit_max_compute_work_group_size_z, 64},
       Limit{shaderc_limit::shaderc_limit_max_compute_uniform_components, 512},
       Limit{shaderc_limit::shaderc_limit_max_compute_texture_image_units, 16},
       Limit{shaderc_limit::shaderc_limit_max_compute_image_uniforms, 8},
       Limit{shaderc_limit::shaderc_limit_max_compute_atomic_counters, 8},
       Limit{shaderc_limit::shaderc_limit_max_compute_atomic_counter_buffers, 1},
       Limit{shaderc_limit::shaderc_limit_max_varying_components, 60},
       Limit{shaderc_limit::shaderc_limit_max_vertex_output_components, 64},
       Limit{shaderc_limit::shaderc_limit_max_geometry_input_components, 64},
       Limit{shaderc_limit::shaderc_limit_max_geometry_output_components, 128},
       Limit{shaderc_limit::shaderc_limit_max_fragment_input_components, 128},
       Limit{shaderc_limit::shaderc_limit_max_image_units, 8},
       Limit{shaderc_limit::
                 shaderc_limit_max_combined_image_units_and_fragment_outputs,
             8},
       Limit{shaderc_limit::shaderc_limit_max_combined_shader_output_resources,
             8},
       Limit{shaderc_limit::shaderc_limit_max_image_samples, 0},
       Limit{shaderc_limit::shaderc_limit_max_vertex_image_uniforms, 0},
       Limit{shaderc_limit::shaderc_limit_max_tess_control_image_uniforms, 0},
       Limit{shaderc_limit::shaderc_limit_max_tess_evaluation_image_uniforms, 0},
       Limit{shaderc_limit::shaderc_limit_max_geometry_image_uniforms, 0},
       Limit{shaderc_limit::shaderc_limit_max_fragment_image_uniforms, 8},
       Limit{shaderc_limit::shaderc_limit_max_combined_image_uniforms, 8},
       Limit{shaderc_limit::shaderc_limit_max_geometry_texture_image_units, 16},
       Limit{shaderc_limit::shaderc_limit_max_geometry_output_vertices, 256},
       Limit{shaderc_limit::shaderc_limit_max_geometry_total_output_components,
             1024},
       Limit{shaderc_limit::shaderc_limit_max_geometry_uniform_components, 512},
       Limit{shaderc_limit::shaderc_limit_max_geometry_varying_components, 60},
       Limit{shaderc_limit::shaderc_limit_max_tess_control_input_components,
             128},
       Limit{shaderc_limit::shaderc_limit_max_tess_control_output_components,
             128},
       Limit{shaderc_limit::shaderc_limit_max_tess_control_texture_image_units,
             16},
       Limit{shaderc_limit::shaderc_limit_max_tess_control_uniform_components,
             1024},
       Limit{
           shaderc_limit::shaderc_limit_max_tess_control_total_output_components,
           4096},
       Limit{shaderc_limit::shaderc_limit_max_tess_evaluation_input_components,
             128},
       Limit{shaderc_limit::shaderc_limit_max_tess_evaluation_output_components,
             128},
       Limit{
           shaderc_limit::shaderc_limit_max_tess_evaluation_texture_image_units,
           16},
       Limit{shaderc_limit::shaderc_limit_max_tess_evaluation_uniform_components,
             1024},
       Limit{shaderc_limit::shaderc_limit_max_tess_patch_components, 120},
       Limit{shaderc_limit::shaderc_limit_max_patch_vertices, 32},
       Limit{shaderc_limit::shaderc_limit_max_tess_gen_level, 64},
       Limit{shaderc_limit::shaderc_limit_max_viewports, 16},
       Limit{shaderc_limit::shaderc_limit_max_vertex_atomic_counters, 0},
       Limit{shaderc_limit::shaderc_limit_max_tess_control_atomic_counters, 0},
       Limit{shaderc_limit::shaderc_limit_max_tess_evaluation_atomic_counters,
             0},
       Limit{shaderc_limit::shaderc_limit_max_geometry_atomic_counters, 0},
       Limit{shaderc_limit::shaderc_limit_max_fragment_atomic_counters, 8},
       Limit{shaderc_limit::shaderc_limit_max_combined_atomic_counters, 8},
       Limit{shaderc_limit::shaderc_limit_max_atomic_counter_bindings, 1},
       Limit{shaderc_limit::shaderc_limit_max_vertex_atomic_counter_buffers, 0},
       Limit{
           shaderc_limit::shaderc_limit_max_tess_control_atomic_counter_buffers,
           0},
       Limit{shaderc_limit::
                 shaderc_limit_max_tess_evaluation_atomic_counter_buffers,
             0},
       Limit{shaderc_limit::shaderc_limit_max_geometry_atomic_counter_buffers,
             0},
       Limit{shaderc_limit::shaderc_limit_max_fragment_atomic_counter_buffers,
             0},
       Limit{shaderc_limit::shaderc_limit_max_combined_atomic_counter_buffers,
             1},
       Limit{shaderc_limit::shaderc_limit_max_atomic_counter_buffer_size, 32},
       Limit{shaderc_limit::shaderc_limit_max_transform_feedback_buffers, 4},
       Limit{shaderc_limit::
                 shaderc_limit_max_transform_feedback_interleaved_components,
             64},
       Limit{shaderc_limit::shaderc_limit_max_cull_distances, 8},
       Limit{shaderc_limit::shaderc_limit_max_combined_clip_and_cull_distances,
             8},
       Limit{shaderc_limit::shaderc_limit_max_samples, 4},
   };
   for (auto& [limit, value] : limits) {
     compiler_opts.SetLimit(limit, value);
   }
 }

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.

                                                      {
   auto permissions =
       std::filesystem::perms::owner_read | std::filesystem::perms::owner_write |
       std::filesystem::perms::group_read | std::filesystem::perms::others_read;
   std::error_code error;
   std::filesystem::permissions(p, permissions, error);
   if (error) {
     std::cerr << "Failed to set access on file '" << p
               << "': " << error.message() << std::endl;
     return false;
   }
   return true;
 }

Referenced by GenerateShaderBundle(), and OutputIPLR().

◆ ShaderCErrorToString()

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

Definition at line 162 of file types.cc.

                                                                   {
   using Status = shaderc_compilation_status;
   switch (status) {
     case Status::shaderc_compilation_status_success:
       return "Success";
     case Status::shaderc_compilation_status_invalid_stage:
       return "Invalid shader stage specified";
     case Status::shaderc_compilation_status_compilation_error:
       return "Compilation error";
     case Status::shaderc_compilation_status_internal_error:
       return "Internal error";
     case Status::shaderc_compilation_status_null_result_object:
       return "Internal error. Null result object";
     case Status::shaderc_compilation_status_invalid_assembly:
       return "Invalid assembly";
     case Status::shaderc_compilation_status_validation_error:
       return "Validation error";
     case Status::shaderc_compilation_status_transformation_error:
       return "Transform error";
     case Status::shaderc_compilation_status_configuration_error:
       return "Configuration error";
   }
   return "Unknown internal error";
 }

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

◆ SourceLanguageToString()

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

Definition at line 102 of file types.cc.

                                                                  {
   switch (source_language) {
     case SourceLanguage::kUnknown:
       return "Unknown";
     case SourceLanguage::kGLSL:
       return "GLSL";
     case SourceLanguage::kHLSL:
       return "HLSL";
   }
 }

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

                                         {
   auto source_type_option =
       command_line.GetOptionValueWithDefault("input-type", "");
   auto source_type_search = kKnownSourceTypes.find(source_type_option);
   if (source_type_search == kKnownSourceTypes.end()) {
     return SourceType::kUnknown;
   }
   return source_type_search->second;
 }

References kKnownSourceTypes, and kUnknown.

◆ SourceTypeFromFileName()

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

Definition at line 30 of file types.cc.

                                                               {
   if (StringEndWith(file_name, ".vert")) {
     return SourceType::kVertexShader;
   }
  
   if (StringEndWith(file_name, ".frag")) {
     return SourceType::kFragmentShader;
   }
  
   if (StringEndWith(file_name, ".comp")) {
     return SourceType::kComputeShader;
   }
  
   return SourceType::kUnknown;
 }

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

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

◆ SourceTypeFromString()

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

Definition at line 46 of file types.cc.

                                                 {
   name = ToLowerCase(name);
  
   if (name == "vertex") {
     return SourceType::kVertexShader;
   }
  
   if (name == "fragment") {
     return SourceType::kFragmentShader;
   }
  
   if (name == "compute") {
     return SourceType::kComputeShader;
   }
  
   return SourceType::kUnknown;
 }

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

Referenced by ParseShaderBundleConfig().

◆ SourceTypeToString()

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

Definition at line 236 of file types.cc.

                                               {
   switch (type) {
     case SourceType::kUnknown:
       return "unknown";
     case SourceType::kVertexShader:
       return "vert";
     case SourceType::kFragmentShader:
       return "frag";
     case SourceType::kComputeShader:
       return "comp";
   }
   FML_UNREACHABLE();
 }

References kComputeShader, kFragmentShader, kUnknown, kVertexShader, and type.

◆ StringEndWith()

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

static

Definition at line 17 of file types.cc.

                                                    {
   if (suffix.size() > string.size()) {
     return false;
   }
  
   if (suffix.empty() || suffix.empty()) {
     return false;
   }
  
   return string.rfind(suffix) == (string.size() - suffix.size());
 }

Referenced by SourceTypeFromFileName().

◆ StringStartsWith()

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

Definition at line 87 of file utilities.cc.

                                                                         {
   if (prefix.length() > target.length()) {
     return false;
   }
   for (size_t i = 0; i < prefix.length(); i++) {
     if (target[i] != prefix[i]) {
       return false;
     }
   }
   return true;
 }

Referenced by CreateGLSLCompiler().

◆ StringToShaderStage()

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

static

Definition at line 46 of file reflector.cc.

                                                            {
   if (str == "vertex") {
     return "ShaderStage::kVertex";
   }
  
   if (str == "fragment") {
     return "ShaderStage::kFragment";
   }
  
   if (str == "compute") {
     return "ShaderStage::kCompute";
   }
  
   return "ShaderStage::kUnknown";
 }

◆ TargetPlatformBundlesSkSL()

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

Definition at line 328 of file types.cc.

                                                         {
   switch (platform) {
     case TargetPlatform::kSkSL:
     case TargetPlatform::kRuntimeStageMetal:
     case TargetPlatform::kRuntimeStageGLES:
     case TargetPlatform::kRuntimeStageGLES3:
     case TargetPlatform::kRuntimeStageVulkan:
       return true;
     case TargetPlatform::kMetalDesktop:
     case TargetPlatform::kMetalIOS:
     case TargetPlatform::kUnknown:
     case TargetPlatform::kOpenGLES:
     case TargetPlatform::kOpenGLDesktop:
     case TargetPlatform::kVulkan:
       return false;
   }
   FML_UNREACHABLE();
 }

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

Referenced by OutputIPLR().

◆ TargetPlatformFromCommandLine()

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

static

Definition at line 120 of file switches.cc.

                                         {
   auto target = TargetPlatform::kUnknown;
   for (const auto& platform : kKnownPlatforms) {
     if (command_line.HasOption(platform.first)) {
       // If the platform has already been determined, the caller may have
       // specified multiple platforms. This is an error and only one must be
       // selected.
       if (target != TargetPlatform::kUnknown) {
         return TargetPlatform::kUnknown;
       }
       target = platform.second;
       // Keep going to detect duplicates.
     }
   }
   return target;
 }

References kKnownPlatforms, and kUnknown.

◆ TargetPlatformIsMetal()

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

Definition at line 290 of file types.cc.

                                                     {
   switch (platform) {
     case TargetPlatform::kMetalDesktop:
     case TargetPlatform::kMetalIOS:
     case TargetPlatform::kRuntimeStageMetal:
       return true;
     case TargetPlatform::kUnknown:
     case TargetPlatform::kSkSL:
     case TargetPlatform::kOpenGLES:
     case TargetPlatform::kOpenGLDesktop:
     case TargetPlatform::kRuntimeStageGLES:
     case TargetPlatform::kRuntimeStageGLES3:
     case TargetPlatform::kRuntimeStageVulkan:
     case TargetPlatform::kVulkan:
       return false;
   }
   FML_UNREACHABLE();
 }

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

                                                      {
   switch (platform) {
     case TargetPlatform::kOpenGLES:
     case TargetPlatform::kOpenGLDesktop:
     case TargetPlatform::kRuntimeStageGLES:
     case TargetPlatform::kRuntimeStageGLES3:
       return true;
     case TargetPlatform::kMetalDesktop:
     case TargetPlatform::kRuntimeStageMetal:
     case TargetPlatform::kRuntimeStageVulkan:
     case TargetPlatform::kMetalIOS:
     case TargetPlatform::kUnknown:
     case TargetPlatform::kSkSL:
     case TargetPlatform::kVulkan:
       return false;
   }
   FML_UNREACHABLE();
 }

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

◆ TargetPlatformIsVulkan()

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

Definition at line 309 of file types.cc.

                                                      {
   switch (platform) {
     case TargetPlatform::kRuntimeStageVulkan:
     case TargetPlatform::kVulkan:
       return true;
     case TargetPlatform::kMetalDesktop:
     case TargetPlatform::kMetalIOS:
     case TargetPlatform::kRuntimeStageMetal:
     case TargetPlatform::kUnknown:
     case TargetPlatform::kSkSL:
     case TargetPlatform::kOpenGLES:
     case TargetPlatform::kOpenGLDesktop:
     case TargetPlatform::kRuntimeStageGLES:
     case TargetPlatform::kRuntimeStageGLES3:
       return false;
   }
   FML_UNREACHABLE();
 }

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

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

◆ TargetPlatformNeedsReflection()

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

Definition at line 143 of file types.cc.

                                                             {
   switch (platform) {
     case TargetPlatform::kMetalIOS:
     case TargetPlatform::kMetalDesktop:
     case TargetPlatform::kOpenGLES:
     case TargetPlatform::kOpenGLDesktop:
     case TargetPlatform::kRuntimeStageMetal:
     case TargetPlatform::kRuntimeStageGLES:
     case TargetPlatform::kRuntimeStageGLES3:
     case TargetPlatform::kRuntimeStageVulkan:
     case TargetPlatform::kVulkan:
       return true;
     case TargetPlatform::kUnknown:
     case TargetPlatform::kSkSL:
       return false;
   }
   FML_UNREACHABLE();
 }

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

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

◆ TargetPlatformSLExtension()

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

Definition at line 250 of file types.cc.

                                                              {
   switch (platform) {
     case TargetPlatform::kUnknown:
       return "unknown";
     case TargetPlatform::kMetalDesktop:
     case TargetPlatform::kMetalIOS:
     case TargetPlatform::kRuntimeStageMetal:
       return "metal";
     case TargetPlatform::kSkSL:
     case TargetPlatform::kOpenGLES:
     case TargetPlatform::kOpenGLDesktop:
     case TargetPlatform::kRuntimeStageGLES:
     case TargetPlatform::kRuntimeStageGLES3:
       return "glsl";
     case TargetPlatform::kVulkan:
     case TargetPlatform::kRuntimeStageVulkan:
       return "vk.spirv";
   }
   FML_UNREACHABLE();
 }

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

                              {
   switch (platform) {
     case TargetPlatform::kMetalIOS:
     case TargetPlatform::kRuntimeStageMetal:
       return spirv_cross::CompilerMSL::Options::Platform::iOS;
     case TargetPlatform::kMetalDesktop:
       return spirv_cross::CompilerMSL::Options::Platform::macOS;
     case TargetPlatform::kSkSL:
     case TargetPlatform::kOpenGLES:
     case TargetPlatform::kOpenGLDesktop:
     case TargetPlatform::kRuntimeStageGLES:
     case TargetPlatform::kRuntimeStageGLES3:
     case TargetPlatform::kRuntimeStageVulkan:
     case TargetPlatform::kVulkan:
     case TargetPlatform::kUnknown:
       return spirv_cross::CompilerMSL::Options::Platform::macOS;
   }
   FML_UNREACHABLE();
 }

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

◆ TargetPlatformToString()

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

Definition at line 74 of file types.cc.

                                                           {
   switch (platform) {
     case TargetPlatform::kUnknown:
       return "Unknown";
     case TargetPlatform::kMetalDesktop:
       return "MetalDesktop";
     case TargetPlatform::kMetalIOS:
       return "MetaliOS";
     case TargetPlatform::kOpenGLES:
       return "OpenGLES";
     case TargetPlatform::kOpenGLDesktop:
       return "OpenGLDesktop";
     case TargetPlatform::kVulkan:
       return "Vulkan";
     case TargetPlatform::kRuntimeStageMetal:
       return "RuntimeStageMetal";
     case TargetPlatform::kRuntimeStageGLES:
       return "RuntimeStageGLES";
     case TargetPlatform::kRuntimeStageGLES3:
       return "RuntimeStageGLES3";
     case TargetPlatform::kRuntimeStageVulkan:
       return "RuntimeStageVulkan";
     case TargetPlatform::kSkSL:
       return "SkSL";
   }
   FML_UNREACHABLE();
 }

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

◆ ToCamelCase()

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

Definition at line 39 of file utilities.cc.

                                              {
   if (string.empty()) {
     return "";
   }
  
   std::stringstream stream;
   bool next_upper = true;
   for (size_t i = 0, count = string.length(); i < count; i++) {
     auto ch = string.data()[i];
     if (next_upper) {
       next_upper = false;
       stream << static_cast<char>(std::toupper(ch));
       continue;
     }
     if (ch == '_') {
       next_upper = true;
       continue;
     }
     stream << ch;
   }
   return stream.str();
 }

◆ ToExecutionModel()

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

Definition at line 201 of file types.cc.

                                                     {
   switch (type) {
     case SourceType::kVertexShader:
       return spv::ExecutionModel::ExecutionModelVertex;
     case SourceType::kFragmentShader:
       return spv::ExecutionModel::ExecutionModelFragment;
     case SourceType::kComputeShader:
       return spv::ExecutionModel::ExecutionModelGLCompute;
     case SourceType::kUnknown:
       break;
   }
   return spv::ExecutionModel::ExecutionModelMax;
 }

References kComputeShader, kFragmentShader, kUnknown, kVertexShader, and type.

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.

                                       {
   switch (type) {
     case spirv_cross::SPIRType::Boolean:
       return fb::InputDataType::kBoolean;
     case spirv_cross::SPIRType::SByte:
       return fb::InputDataType::kSignedByte;
     case spirv_cross::SPIRType::UByte:
       return fb::InputDataType::kUnsignedByte;
     case spirv_cross::SPIRType::Short:
       return fb::InputDataType::kSignedShort;
     case spirv_cross::SPIRType::UShort:
       return fb::InputDataType::kUnsignedShort;
     case spirv_cross::SPIRType::Int:
       return fb::InputDataType::kSignedInt;
     case spirv_cross::SPIRType::UInt:
       return fb::InputDataType::kUnsignedInt;
     case spirv_cross::SPIRType::Int64:
       return fb::InputDataType::kSignedInt64;
     case spirv_cross::SPIRType::UInt64:
       return fb::InputDataType::kUnsignedInt64;
     case spirv_cross::SPIRType::Float:
       return fb::InputDataType::kFloat;
     case spirv_cross::SPIRType::Double:
       return fb::InputDataType::kDouble;
     case spirv_cross::SPIRType::Unknown:
     case spirv_cross::SPIRType::Void:
     case spirv_cross::SPIRType::Half:
     case spirv_cross::SPIRType::AtomicCounter:
     case spirv_cross::SPIRType::Struct:
     case spirv_cross::SPIRType::Image:
     case spirv_cross::SPIRType::SampledImage:
     case spirv_cross::SPIRType::Sampler:
     case spirv_cross::SPIRType::AccelerationStructure:
     case spirv_cross::SPIRType::RayQuery:
     case spirv_cross::SPIRType::ControlPointArray:
     case spirv_cross::SPIRType::Interpolant:
     case spirv_cross::SPIRType::Char:
       return std::nullopt;
   }
   FML_UNREACHABLE();
 }

References impeller::kFloat, and type.

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.

                                       {
   switch (type) {
     case spirv_cross::SPIRType::Boolean:
       return fb::shaderbundle::InputDataType::kBoolean;
     case spirv_cross::SPIRType::SByte:
       return fb::shaderbundle::InputDataType::kSignedByte;
     case spirv_cross::SPIRType::UByte:
       return fb::shaderbundle::InputDataType::kUnsignedByte;
     case spirv_cross::SPIRType::Short:
       return fb::shaderbundle::InputDataType::kSignedShort;
     case spirv_cross::SPIRType::UShort:
       return fb::shaderbundle::InputDataType::kUnsignedShort;
     case spirv_cross::SPIRType::Int:
       return fb::shaderbundle::InputDataType::kSignedInt;
     case spirv_cross::SPIRType::UInt:
       return fb::shaderbundle::InputDataType::kUnsignedInt;
     case spirv_cross::SPIRType::Int64:
       return fb::shaderbundle::InputDataType::kSignedInt64;
     case spirv_cross::SPIRType::UInt64:
       return fb::shaderbundle::InputDataType::kUnsignedInt64;
     case spirv_cross::SPIRType::Float:
       return fb::shaderbundle::InputDataType::kFloat;
     case spirv_cross::SPIRType::Double:
       return fb::shaderbundle::InputDataType::kDouble;
     case spirv_cross::SPIRType::Unknown:
     case spirv_cross::SPIRType::Void:
     case spirv_cross::SPIRType::Half:
     case spirv_cross::SPIRType::AtomicCounter:
     case spirv_cross::SPIRType::Struct:
     case spirv_cross::SPIRType::Image:
     case spirv_cross::SPIRType::SampledImage:
     case spirv_cross::SPIRType::Sampler:
     case spirv_cross::SPIRType::AccelerationStructure:
     case spirv_cross::SPIRType::RayQuery:
     case spirv_cross::SPIRType::ControlPointArray:
     case spirv_cross::SPIRType::Interpolant:
     case spirv_cross::SPIRType::Char:
       return std::nullopt;
   }
   FML_UNREACHABLE();
 }

References impeller::kFloat, and type.

◆ ToJsonStage()

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

static

Definition at line 47 of file runtime_stage_data.cc.

                                                                  {
   switch (stage) {
     case spv::ExecutionModel::ExecutionModelVertex:
       return fb::Stage::kVertex;
     case spv::ExecutionModel::ExecutionModelFragment:
       return fb::Stage::kFragment;
     case spv::ExecutionModel::ExecutionModelGLCompute:
       return fb::Stage::kCompute;
     default:
       return std::nullopt;
   }
   FML_UNREACHABLE();
 }

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.

                                       {
   switch (type) {
     case spirv_cross::SPIRType::Boolean:
       return 0;  // fb::UniformDataType::kBoolean;
     case spirv_cross::SPIRType::SByte:
       return 1;  // fb::UniformDataType::kSignedByte;
     case spirv_cross::SPIRType::UByte:
       return 2;  // fb::UniformDataType::kUnsignedByte;
     case spirv_cross::SPIRType::Short:
       return 3;  // fb::UniformDataType::kSignedShort;
     case spirv_cross::SPIRType::UShort:
       return 4;  // fb::UniformDataType::kUnsignedShort;
     case spirv_cross::SPIRType::Int:
       return 5;  // fb::UniformDataType::kSignedInt;
     case spirv_cross::SPIRType::UInt:
       return 6;  // fb::UniformDataType::kUnsignedInt;
     case spirv_cross::SPIRType::Int64:
       return 7;  // fb::UniformDataType::kSignedInt64;
     case spirv_cross::SPIRType::UInt64:
       return 8;  // fb::UniformDataType::kUnsignedInt64;
     case spirv_cross::SPIRType::Half:
       return 9;  // b::UniformDataType::kHalfFloat;
     case spirv_cross::SPIRType::Float:
       return 10;  // fb::UniformDataType::kFloat;
     case spirv_cross::SPIRType::Double:
       return 11;  // fb::UniformDataType::kDouble;
     case spirv_cross::SPIRType::SampledImage:
       return 12;  // fb::UniformDataType::kSampledImage;
     case spirv_cross::SPIRType::Struct:
       return 13;
     case spirv_cross::SPIRType::AccelerationStructure:
     case spirv_cross::SPIRType::AtomicCounter:
     case spirv_cross::SPIRType::Char:
     case spirv_cross::SPIRType::ControlPointArray:
     case spirv_cross::SPIRType::Image:
     case spirv_cross::SPIRType::Interpolant:
     case spirv_cross::SPIRType::RayQuery:
     case spirv_cross::SPIRType::Sampler:
     case spirv_cross::SPIRType::Unknown:
     case spirv_cross::SPIRType::Void:
       return std::nullopt;
   }
   FML_UNREACHABLE();
 }

References type.

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

◆ ToLowerCase()

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

Definition at line 62 of file utilities.cc.

                                              {
   std::string result = std::string(string);
   std::transform(result.begin(), result.end(), result.begin(),
                  [](char x) { return std::tolower(x); });
   return result;
 }

References transform, and x.

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

◆ ToShaderCShaderKind()

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

Definition at line 187 of file types.cc.

                                                          {
   switch (type) {
     case SourceType::kVertexShader:
       return shaderc_shader_kind::shaderc_vertex_shader;
     case SourceType::kFragmentShader:
       return shaderc_shader_kind::shaderc_fragment_shader;
     case SourceType::kComputeShader:
       return shaderc_shader_kind::shaderc_compute_shader;
     case SourceType::kUnknown:
       break;
   }
   return shaderc_shader_kind::shaderc_glsl_infer_from_source;
 }

References kComputeShader, kFragmentShader, kUnknown, kVertexShader, and type.

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

◆ ToSourceLanguage()

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

Definition at line 64 of file types.cc.

                                                                   {
   if (source_language == "glsl") {
     return SourceLanguage::kGLSL;
   }
   if (source_language == "hlsl") {
     return SourceLanguage::kHLSL;
   }
   return SourceLanguage::kUnknown;
 }

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.

                                                              {
   switch (stage) {
     case spv::ExecutionModel::ExecutionModelVertex:
       return fb::Stage::kVertex;
     case spv::ExecutionModel::ExecutionModelFragment:
       return fb::Stage::kFragment;
     case spv::ExecutionModel::ExecutionModelGLCompute:
       return fb::Stage::kCompute;
     default:
       return std::nullopt;
   }
   FML_UNREACHABLE();
 }

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.

                              {
   switch (stage) {
     case spv::ExecutionModel::ExecutionModelVertex:
       return fb::shaderbundle::ShaderStage::kVertex;
     case spv::ExecutionModel::ExecutionModelFragment:
       return fb::shaderbundle::ShaderStage::kFragment;
     case spv::ExecutionModel::ExecutionModelGLCompute:
       return fb::shaderbundle::ShaderStage::kCompute;
     default:
       return std::nullopt;
   }
   FML_UNREACHABLE();
 }

◆ ToString()

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

static

Definition at line 575 of file reflector.cc.

                                                     {
   switch (type) {
     case CompilerBackend::Type::kMSL:
       return "Metal Shading Language";
     case CompilerBackend::Type::kGLSL:
       return "OpenGL Shading Language";
     case CompilerBackend::Type::kGLSLVulkan:
       return "OpenGL Shading Language (Relaxed Vulkan Semantics)";
     case CompilerBackend::Type::kSkSL:
       return "SkSL Shading Language";
   }
   FML_UNREACHABLE();
 }

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

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

                                       {
   switch (type) {
     case spirv_cross::SPIRType::Float:
       return fb::UniformDataType::kFloat;
     case spirv_cross::SPIRType::SampledImage:
       return fb::UniformDataType::kSampledImage;
     case spirv_cross::SPIRType::Struct:
       return fb::UniformDataType::kStruct;
     case spirv_cross::SPIRType::Boolean:
     case spirv_cross::SPIRType::SByte:
     case spirv_cross::SPIRType::UByte:
     case spirv_cross::SPIRType::Short:
     case spirv_cross::SPIRType::UShort:
     case spirv_cross::SPIRType::Int:
     case spirv_cross::SPIRType::UInt:
     case spirv_cross::SPIRType::Int64:
     case spirv_cross::SPIRType::UInt64:
     case spirv_cross::SPIRType::Half:
     case spirv_cross::SPIRType::Double:
     case spirv_cross::SPIRType::AccelerationStructure:
     case spirv_cross::SPIRType::AtomicCounter:
     case spirv_cross::SPIRType::Char:
     case spirv_cross::SPIRType::ControlPointArray:
     case spirv_cross::SPIRType::Image:
     case spirv_cross::SPIRType::Interpolant:
     case spirv_cross::SPIRType::RayQuery:
     case spirv_cross::SPIRType::Sampler:
     case spirv_cross::SPIRType::Unknown:
     case spirv_cross::SPIRType::Void:
       return std::nullopt;
   }
   FML_UNREACHABLE();
 }

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

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.

                                       {
   switch (type) {
     case spirv_cross::SPIRType::Boolean:
       return fb::shaderbundle::UniformDataType::kBoolean;
     case spirv_cross::SPIRType::SByte:
       return fb::shaderbundle::UniformDataType::kSignedByte;
     case spirv_cross::SPIRType::UByte:
       return fb::shaderbundle::UniformDataType::kUnsignedByte;
     case spirv_cross::SPIRType::Short:
       return fb::shaderbundle::UniformDataType::kSignedShort;
     case spirv_cross::SPIRType::UShort:
       return fb::shaderbundle::UniformDataType::kUnsignedShort;
     case spirv_cross::SPIRType::Int:
       return fb::shaderbundle::UniformDataType::kSignedInt;
     case spirv_cross::SPIRType::UInt:
       return fb::shaderbundle::UniformDataType::kUnsignedInt;
     case spirv_cross::SPIRType::Int64:
       return fb::shaderbundle::UniformDataType::kSignedInt64;
     case spirv_cross::SPIRType::UInt64:
       return fb::shaderbundle::UniformDataType::kUnsignedInt64;
     case spirv_cross::SPIRType::Half:
       return fb::shaderbundle::UniformDataType::kHalfFloat;
     case spirv_cross::SPIRType::Float:
       return fb::shaderbundle::UniformDataType::kFloat;
     case spirv_cross::SPIRType::Double:
       return fb::shaderbundle::UniformDataType::kDouble;
     case spirv_cross::SPIRType::SampledImage:
       return fb::shaderbundle::UniformDataType::kSampledImage;
     case spirv_cross::SPIRType::AccelerationStructure:
     case spirv_cross::SPIRType::AtomicCounter:
     case spirv_cross::SPIRType::Char:
     case spirv_cross::SPIRType::ControlPointArray:
     case spirv_cross::SPIRType::Image:
     case spirv_cross::SPIRType::Interpolant:
     case spirv_cross::SPIRType::RayQuery:
     case spirv_cross::SPIRType::Sampler:
     case spirv_cross::SPIRType::Struct:
     case spirv_cross::SPIRType::Unknown:
     case spirv_cross::SPIRType::Void:
       return std::nullopt;
   }
   FML_UNREACHABLE();
 }

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

◆ TypeNameWithPaddingOfSize()

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

static

Definition at line 743 of file reflector.cc.

                                                         {
   std::stringstream stream;
   stream << "Padding<" << size << ">";
   return stream.str();
 }

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.

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

Referenced by impeller::compiler::Switches::AreValid(), CreateReflectorOptions(), EntryPointFunctionNameFromSourceName(), GenerateShaderBundle(), InferShaderNameFromPath(), Main(), OutputDepfile(), OutputIPLR(), OutputReflectionData(), OutputSLFile(), and impeller::compiler::Switches::Switches().

◆ VertexTypeFromInputResource()

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

static

Definition at line 1202 of file reflector.cc.

                                          {
   VertexType result;
   result.variable_name = resource->name;
   const auto& type = compiler.get_type(resource->type_id);
   result.base_type = type.basetype;
   const auto total_size = type.columns * type.vecsize * type.width / 8u;
   result.byte_length = total_size;
  
   if (type.basetype == spirv_cross::SPIRType::BaseType::Float &&
       type.columns == 1u && type.vecsize == 2u &&
       type.width == sizeof(float) * 8u) {
     result.type_name = "Point";
   } else if (type.basetype == spirv_cross::SPIRType::BaseType::Float &&
              type.columns == 1u && type.vecsize == 4u &&
              type.width == sizeof(float) * 8u) {
     result.type_name = "Vector4";
   } else if (type.basetype == spirv_cross::SPIRType::BaseType::Float &&
              type.columns == 1u && type.vecsize == 3u &&
              type.width == sizeof(float) * 8u) {
     result.type_name = "Vector3";
   } else if (type.basetype == spirv_cross::SPIRType::BaseType::Float &&
              type.columns == 1u && type.vecsize == 1u &&
              type.width == sizeof(float) * 8u) {
     result.type_name = "Scalar";
   } else if (type.basetype == spirv_cross::SPIRType::BaseType::Int &&
              type.columns == 1u && type.vecsize == 1u &&
              type.width == sizeof(int32_t) * 8u) {
     result.type_name = "int32_t";
   } else {
     // Catch all unknown padding.
     result.type_name = TypeNameWithPaddingOfSize(total_size);
   }
  
   return result;
 }

References impeller::compiler::VertexType::base_type, impeller::compiler::VertexType::byte_length, type, 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 186 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().

◆ kKnownPlatforms

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

static

Initial value:

= {
    {"metal-desktop", TargetPlatform::kMetalDesktop},
    {"metal-ios", TargetPlatform::kMetalIOS},
    {"vulkan", TargetPlatform::kVulkan},
    {"opengl-es", TargetPlatform::kOpenGLES},
    {"opengl-desktop", TargetPlatform::kOpenGLDesktop},
}

Definition at line 20 of file switches.cc.

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

◆ kKnownRuntimeStages

const std::map<std::string, TargetPlatform> impeller::compiler::kKnownRuntimeStages

static

Initial value:

= {
    {"sksl", TargetPlatform::kSkSL},
    {"runtime-stage-metal", TargetPlatform::kRuntimeStageMetal},
    {"runtime-stage-gles", TargetPlatform::kRuntimeStageGLES},
    {"runtime-stage-gles3", TargetPlatform::kRuntimeStageGLES3},
    {"runtime-stage-vulkan", TargetPlatform::kRuntimeStageVulkan},
}

Definition at line 28 of file switches.cc.

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

◆ kKnownSourceTypes

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

static

Initial value:

= {
    {"vert", SourceType::kVertexShader},
    {"frag", SourceType::kFragmentShader},
    {"comp", SourceType::kComputeShader},
}

Definition at line 36 of file switches.cc.

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

◆ kMaxUniformBufferSize

const uint32_t impeller::compiler::kMaxUniformBufferSize = 6208

static

Definition at line 38 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 188 of file runtime_stage_data.cc.

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

◆ kStageKey

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

static

Definition at line 184 of file runtime_stage_data.cc.

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

◆ kTargetPlatformKey

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

static

Definition at line 185 of file runtime_stage_data.cc.

◆ kUniformArrayElementsKey

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

static

Definition at line 195 of file runtime_stage_data.cc.

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

◆ kUniformBitWidthKey

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

static

Definition at line 194 of file runtime_stage_data.cc.

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

◆ kUniformColumnsKey

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

static

Definition at line 193 of file runtime_stage_data.cc.

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

◆ kUniformLocationKey

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

static

Definition at line 190 of file runtime_stage_data.cc.

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

◆ kUniformNameKey

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

static

Definition at line 189 of file runtime_stage_data.cc.

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

◆ kUniformRowsKey

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

static

Definition at line 192 of file runtime_stage_data.cc.

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

◆ kUniformsKey

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

static

Definition at line 187 of file runtime_stage_data.cc.

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

◆ kUniformTypeKey

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

static

Definition at line 191 of file runtime_stage_data.cc.

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

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ ShaderBundleConfig

Enumeration Type Documentation

◆ SourceLanguage

◆ SourceType

◆ TargetPlatform

Function Documentation

◆ CompileSkSL()

◆ ConvertToEntrypointName()

◆ CreateCompiler()

◆ CreateGLSLCompiler()

◆ CreateMSLCompiler()

◆ CreateReflectorOptions()

◆ CreateSkSLCompiler()

◆ CreateVulkanCompiler()

◆ EntryPointFunctionNameFromSourceName()

◆ EntryPointMustBeNamedMain()

◆ ExecutionModelToString()

◆ GenerateShaderBackendFB()

◆ GenerateShaderBundle()

◆ GenerateShaderBundleFlatbuffer()

◆ GenerateShaderFB()

◆ GetReflectedStructSize()

◆ GetRuntimeStageBackend()

◆ InferShaderNameFromPath()

◆ JoinStrings()

◆ Main()

◆ OutputDepfile()

◆ OutputIPLR()

◆ OutputReflectionData()

◆ OutputSLFile()

◆ ParseMSLVersion()

◆ ParseShaderBundleConfig()

◆ ReadKnownScalarType()

◆ report_and_exit()

◆ RuntimeStageBackendToString()

◆ RuntimeStagesFromCommandLine()

◆ SetBindingBaseOffset()

◆ SetDefaultLimitations()

◆ SetPermissiveAccess()

◆ ShaderCErrorToString()

◆ SourceLanguageToString()

◆ SourceTypeFromCommandLine()

◆ SourceTypeFromFileName()

◆ SourceTypeFromString()

◆ SourceTypeToString()

◆ StringEndWith()

◆ StringStartsWith()

◆ StringToShaderStage()

◆ TargetPlatformBundlesSkSL()

◆ TargetPlatformFromCommandLine()

◆ TargetPlatformIsMetal()

◆ TargetPlatformIsOpenGL()

◆ TargetPlatformIsVulkan()

◆ TargetPlatformNeedsReflection()

◆ TargetPlatformSLExtension()

◆ TargetPlatformToMSLPlatform()

◆ TargetPlatformToString()

◆ ToCamelCase()

◆ ToExecutionModel()

◆ ToInputType() [1/2]

◆ ToInputType() [2/2]

◆ ToJsonStage()

◆ ToJsonType()

◆ ToLowerCase()

◆ ToShaderCShaderKind()

◆ ToSourceLanguage()

◆ ToStage() [1/2]

◆ ToStage() [2/2]

◆ ToString()

◆ ToUniformType() [1/2]

◆ ToUniformType() [2/2]

◆ TypeNameWithPaddingOfSize()

◆ Utf8FromPath()