impeller::compiler Namespace Reference

Namespaces
	testing

Classes
class	Compiler
struct	CompilerBackend
struct	IncludeDir
struct	IncluderData
class	Includer
class	AutoLogger
struct	KnownType
struct	VertexType
struct	StructMember
class	Reflector
class	RuntimeStageData
class	ShaderBundleData
struct	SourceOptions
class	UniqueIncluder
	Wraps a shared includer so unique includers may be created to satisfy the shaderc API. This is a simple proxy object and does nothing. More...
struct	SPIRVCompilerSourceProfile
struct	SPIRVCompilerTargetEnv
struct	SPIRVCompilerOptions
class	SPIRVCompiler
class	CompilerSkSL
class	Switches
struct	StructField
struct	UniformDescription
struct	InputDescription
struct	ShaderConfig
	A shader config parsed as part of a ShaderBundleConfig. More...

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

Enumerations
enum class	SourceType {   kUnknown ,   kVertexShader ,   kFragmentShader ,   kComputeShader }
enum class	TargetPlatform {   kUnknown ,   kMetalDesktop ,   kMetalIOS ,   kOpenGLES ,   kOpenGLDesktop ,   kVulkan ,   kRuntimeStageMetal ,   kRuntimeStageGLES ,   kRuntimeStageGLES3 ,   kRuntimeStageVulkan ,   kSkSL }
enum class	SourceLanguage {   kUnknown ,   kGLSL ,   kHLSL }

Functions
static uint32_t	ParseMSLVersion (const std::string &msl_version)
static CompilerBackend	CreateMSLCompiler (const spirv_cross::ParsedIR &ir, const SourceOptions &source_options, std::optional< uint32_t > msl_version_override={})
static CompilerBackend	CreateVulkanCompiler (const spirv_cross::ParsedIR &ir, const SourceOptions &source_options)
static CompilerBackend	CreateGLSLCompiler (const spirv_cross::ParsedIR &ir, const SourceOptions &source_options)
static CompilerBackend	CreateSkSLCompiler (const spirv_cross::ParsedIR &ir, const SourceOptions &source_options)
static bool	EntryPointMustBeNamedMain (TargetPlatform platform)
static CompilerBackend	CreateCompiler (const spirv_cross::ParsedIR &ir, const SourceOptions &source_options)
static std::string	JoinStrings (std::vector< std::string > items, const std::string &separator)
bool	Main (const fml::CommandLine &command_line)
static std::string	ExecutionModelToStringName (spv::ExecutionModel model)
static std::string	StringToShaderStage (const std::string &str)
static std::optional< RuntimeStageBackend >	GetRuntimeStageBackend (TargetPlatform target_platform)
static std::string	ToString (CompilerBackend::Type type)
static std::string	TypeNameWithPaddingOfSize (size_t size)
static std::optional< KnownType >	ReadKnownScalarType (spirv_cross::SPIRType::BaseType type)
static size_t	GetReflectedStructSize (const std::vector< StructMember > &members)
	Get the reflected struct size. In the vast majority of the cases, this is the same as the declared struct size as given by the compiler. But, additional padding may need to be introduced after the end of the struct to keep in line with the alignment requirement of the individual struct members. This method figures out the actual size of the reflected struct that can be referenced in native code. More...
static VertexType	VertexTypeFromInputResource (const spirv_cross::Compiler &compiler, const spirv_cross::Resource *resource)
static std::optional< fb::Stage >	ToStage (spv::ExecutionModel stage)
static std::optional< fb::Stage >	ToJsonStage (spv::ExecutionModel stage)
static std::optional< fb::UniformDataType >	ToUniformType (spirv_cross::SPIRType::BaseType type)
static std::optional< fb::InputDataType >	ToInputType (spirv_cross::SPIRType::BaseType type)
static std::optional< uint32_t >	ToJsonType (spirv_cross::SPIRType::BaseType type)
static std::string	RuntimeStageBackendToString (RuntimeStageBackend backend)
std::optional< ShaderBundleConfig >	ParseShaderBundleConfig (const std::string &bundle_config_json, std::ostream &error_stream)
	Parse a shader bundle configuration from a given JSON string. More...
std::vector< std::string_view >	GetShaderBundleTargetPlatformDefines (TargetPlatform platform)
	The platform-discriminating preprocessor defines injected when compiling a bundled shader for platform (for example IMPELLER_TARGET_METAL). These let bundled Flutter GPU shaders specialize for the backend they will run on, matching the defines that Impeller's own shaders receive from the build templates. More...
static std::unique_ptr< fb::shaderbundle::BackendShaderT >	GenerateShaderBackendFB (TargetPlatform target_platform, SourceOptions &options, const std::string &shader_name, const ShaderConfig &shader_config, std::set< std::string > *out_dependencies)
static std::unique_ptr< fb::shaderbundle::ShaderT >	GenerateShaderFB (SourceOptions options, const std::string &shader_name, const ShaderConfig &shader_config, std::set< std::string > *out_dependencies)
std::optional< fb::shaderbundle::ShaderBundleT >	GenerateShaderBundleFlatbuffer (const std::string &bundle_config_json, const SourceOptions &options, std::set< std::string > *out_dependencies=nullptr)
	Parses the JSON shader bundle configuration and invokes the compiler multiple times to produce a shader bundle flatbuffer. More...
static bool	OutputBundleDepfile (const Switches &switches, const std::string &target, const std::set< std::string > &dependencies)
bool	GenerateShaderBundle (Switches &switches)
	Parses the JSON shader bundle configuration and invokes the compiler multiple times to produce a shader bundle flatbuffer, which is then output to the sl file. More...
static std::optional< fb::shaderbundle::ShaderStage >	ToStage (spv::ExecutionModel stage)
static std::optional< fb::shaderbundle::UniformDataType >	ToUniformType (spirv_cross::SPIRType::BaseType type)
static std::optional< fb::shaderbundle::InputDataType >	ToInputType (spirv_cross::SPIRType::BaseType type)
static void	SetDefaultLimitations (shaderc::CompileOptions &compiler_opts)
static void	SetBindingBaseOffset (shaderc::CompileOptions &options)
void	report_and_exit (const std::string &msg)
static TargetPlatform	TargetPlatformFromCommandLine (const fml::CommandLine &command_line)
static std::vector< TargetPlatform >	RuntimeStagesFromCommandLine (const fml::CommandLine &command_line)
static SourceType	SourceTypeFromCommandLine (const fml::CommandLine &command_line)
static std::filesystem::path	GetOptionAsPath (const fml::CommandLine &command_line, const char *arg)
SourceType	SourceTypeFromFileName (const std::filesystem::path &file_name)
SourceType	SourceTypeFromString (std::string name)
SourceLanguage	ToSourceLanguage (const std::string &source_language)
std::string	TargetPlatformToString (TargetPlatform platform)
std::string	SourceLanguageToString (SourceLanguage source_language)
std::string	EntryPointFunctionNameFromSourceName (const std::filesystem::path &file_name, SourceType type, SourceLanguage source_language, const std::string &entry_point_name)
std::string	ShaderCErrorToString (shaderc_compilation_status status)
shaderc_shader_kind	ToShaderCShaderKind (SourceType type)
spv::ExecutionModel	ToExecutionModel (SourceType type)
spirv_cross::CompilerMSL::Options::Platform	TargetPlatformToMSLPlatform (TargetPlatform platform)
std::string	SourceTypeToString (SourceType type)
std::string	TargetPlatformSLExtension (TargetPlatform platform)
bool	TargetPlatformIsOpenGL (TargetPlatform platform)
bool	TargetPlatformIsMetal (TargetPlatform platform)
bool	TargetPlatformIsVulkan (TargetPlatform platform)
bool	SetPermissiveAccess (const std::filesystem::path &p)
	Sets the file access mode of the file at path 'p' to 0644. More...
std::string	Utf8FromPath (const std::filesystem::path &path)
	Converts a native format path to a utf8 string. More...
std::string	InferShaderNameFromPath (const std::filesystem::path &path)
std::string	ToCamelCase (std::string_view string)
std::string	ToLowerCase (std::string_view string)
std::string	ConvertToEntrypointName (std::string_view string)
	Ensure that the entrypoint name is a valid identifier in the target language. More...
bool	StringStartsWith (const std::string &target, const std::string &prefix)

Variables
constexpr std::string_view	kReflectionHeaderTemplate
constexpr std::string_view	kReflectionCCTemplate
static const uint32_t	kMaxUniformBufferSize = 6208
constexpr char	kExternalTexturePrefix [] = "SAMPLER_EXTERNAL_OES_"
static const char *	kFormatVersionKey = "format_version"
static const char *	kStageKey = "stage"
static const char *	kTargetPlatformKey = "target_platform"
static const char *	kEntrypointKey = "entrypoint"
static const char *	kUniformsKey = "uniforms"
static const char *	kShaderKey = "shader"
static const char *	kUniformNameKey = "name"
static const char *	kUniformLocationKey = "location"
static const char *	kUniformTypeKey = "type"
static const char *	kUniformRowsKey = "rows"
static const char *	kUniformColumnsKey = "columns"
static const char *	kUniformBitWidthKey = "bit_width"
static const char *	kUniformArrayElementsKey = "array_elements"
static const char *	kUniformStructElementsKey = "struct_elements"
static const std::map< std::string, TargetPlatform >	kKnownPlatforms
static const std::vector< std::pair< std::string, TargetPlatform > >	kKnownRuntimeStages
static const std::map< std::string, SourceType >	kKnownSourceTypes

Typedef Documentation

ShaderBundleConfig

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

Definition at line 97 of file types.h.

Enumeration Type Documentation

SourceLanguage

enum impeller::compiler::SourceLanguage

strong

Enumerator
kUnknown
kGLSL
kHLSL

Definition at line 44 of file types.h.

                          {
  kUnknown,
  kGLSL,
  kHLSL,
};

SourceType

enum impeller::compiler::SourceType

strong

Enumerator
kUnknown
kVertexShader
kFragmentShader
kComputeShader

Definition at line 23 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 30 of file types.h.

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

Function Documentation

ConvertToEntrypointName()

std::string impeller::compiler::ConvertToEntrypointName

(

std::string_view

string

)

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

Definition at line 68 of file utilities.cc.

                                                         {
  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();
}

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 306 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::kOpenGLES:
    case TargetPlatform::kOpenGLDesktop:
    case TargetPlatform::kRuntimeStageGLES:
    case TargetPlatform::kRuntimeStageGLES3:
      compiler = CreateGLSLCompiler(ir, source_options);
      break;
    case TargetPlatform::kSkSL:
      compiler = CreateSkSLCompiler(ir, source_options);
      break;
    case TargetPlatform::kUnknown:
      FML_UNREACHABLE();
  }
  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(), and Main().

CreateGLSLCompiler()

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

static

Definition at line 211 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;
    // If we have requested GLES3 and/or Compute Shaders,
    // promote the language version accordingly
    if (source_options.type == SourceType::kComputeShader &&
        sl_options.version < 310) {
      sl_options.version = 310;
    } else if (source_options.target_platform ==
                   TargetPlatform::kRuntimeStageGLES3 &&
               sl_options.version < 300) {
      sl_options.version = 300;
    }
    sl_options.es = true;
    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;
    if (source_options.type == SourceType::kComputeShader &&
        sl_options.version < 430) {
      sl_options.version = 430;
    }
    sl_options.es = false;
  }
  gl_compiler->set_common_options(sl_options);
  return CompilerBackend(gl_compiler);
}

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

Referenced by CreateCompiler().

CreateMSLCompiler()

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

static

Definition at line 128 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().

CreateSkSLCompiler()

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

static

Definition at line 280 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 199 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::filesystem::path &	file_name,
		SourceType	type,
		SourceLanguage	source_language,
		const std::string &	entry_point_name
	)

Definition at line 101 of file types.cc.

                                       {
  if (source_language == SourceLanguage::kHLSL) {
    return entry_point_name;
  }
 
  std::stringstream stream;
  stream << ConvertToEntrypointName(Utf8FromPath(file_name.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, and Utf8FromPath().

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

EntryPointMustBeNamedMain()

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

static

Definition at line 286 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().

ExecutionModelToStringName()

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

static

Definition at line 35 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, std::set< std::string > *  out_dependencies  )

static

Override options.

Definition at line 115 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);
 
  // Inject the platform-discriminating defines (e.g. IMPELLER_TARGET_METAL) so
  // bundled shaders can specialize per backend. These are added to a local copy
  // because `options` is shared across every backend compiled here; pushing
  // onto it directly would accumulate defines from previously compiled
  // backends.
  SourceOptions backend_options = options;
  backend_options.target_platform = target_platform;
  for (const auto& define :
       GetShaderBundleTargetPlatformDefines(target_platform)) {
    backend_options.defines.emplace_back(define);
  }
 
  Reflector::Options reflector_options;
  reflector_options.target_platform = target_platform;
  reflector_options.entry_point_name = options.entry_point_name;
  reflector_options.shader_name = shader_name;
 
  Compiler compiler(source_file_mapping, backend_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;
  }
 
  // Record dependencies so the caller can emit a depfile. The shader's
  // source file plus every transitive `#include` that contributed to
  // the compilation. The same source is compiled across multiple
  // target platforms; the std::set dedupes naturally.
  if (out_dependencies) {
    out_dependencies->insert(shader_config.source_file_name);
    for (const auto& included : compiler.GetIncludedFileNames()) {
      out_dependencies->insert(included);
    }
  }
 
  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;
}

References impeller::compiler::SourceOptions::defines, impeller::compiler::ShaderConfig::entry_point, impeller::compiler::Reflector::Options::entry_point_name, impeller::compiler::SourceOptions::entry_point_name, EntryPointFunctionNameFromSourceName(), impeller::compiler::SourceOptions::file_name, impeller::compiler::Compiler::GetErrorMessages(), impeller::compiler::Compiler::GetIncludedFileNames(), impeller::compiler::Compiler::GetReflector(), impeller::compiler::Reflector::GetShaderBundleData(), GetShaderBundleTargetPlatformDefines(), impeller::compiler::Compiler::IsValid(), impeller::compiler::ShaderConfig::language, impeller::compiler::Reflector::Options::shader_name, impeller::compiler::ShaderConfig::source_file_name, impeller::compiler::SourceOptions::source_language, impeller::compiler::Reflector::Options::target_platform, impeller::compiler::SourceOptions::target_platform, impeller::compiler::SourceOptions::type, and impeller::compiler::ShaderConfig::type.

Referenced by GenerateShaderFB().

GenerateShaderBundle()

bool impeller::compiler::GenerateShaderBundle

(

Switches &

switches

)

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

1. Parse the shader bundle and generate the flatbuffer result.

Collect dependencies along the way so a depfile can be emitted after the bundle is written. The same source file is compiled across multiple target platforms; the std::set dedupes naturally.

1. Serialize the shader bundle and write to disk.
2. Output a depfile if one was requested.

Lets build systems (notably Dart's hooks framework, which flutter_gpu_shaders' buildShaderBundleJson consumer goes through) rerun the bundle build when any contributing source file or #included header changes.

Definition at line 309 of file shader_bundle.cc.

                                              {
  // --------------------------------------------------------------------------
  /// 1. Parse the shader bundle and generate the flatbuffer result.
  ///
  /// Collect dependencies along the way so a depfile can be emitted
  /// after the bundle is written. The same source file is compiled
  /// across multiple target platforms; the std::set dedupes naturally.
  ///
 
  std::set<std::string> dependencies;
  const bool want_depfile = !switches.depfile_path.empty();
  auto shader_bundle = GenerateShaderBundleFlatbuffer(
      switches.shader_bundle, switches.CreateSourceOptions(),
      want_depfile ? &dependencies : nullptr);
  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;
  }
 
  // --------------------------------------------------------------------------
  /// 3. Output a depfile if one was requested.
  ///
  /// Lets build systems (notably Dart's `hooks` framework, which
  /// `flutter_gpu_shaders`' `buildShaderBundleJson` consumer goes
  /// through) rerun the bundle build when any contributing source file
  /// or `#include`d header changes.
 
  if (want_depfile) {
    if (!OutputBundleDepfile(switches, Utf8FromPath(sl_file_name),
                             dependencies)) {
      return false;
    }
  }
 
  return true;
}

References impeller::compiler::Switches::CreateSourceOptions(), impeller::compiler::Switches::depfile_path, GenerateShaderBundleFlatbuffer(), OutputBundleDepfile(), 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,
		std::set< std::string > *	out_dependencies = nullptr
	)

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.

Parameters

out_dependencies

Optional. When non-null, populated with the set of source files (including transitive #includes) that contributed to the generated bundle. Used by GenerateShaderBundle to emit a depfile when --depfile is set.

1. Parse the bundle configuration.
2. Build the deserialized shader bundle.

Definition at line 239 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;
  shader_bundle.format_version = static_cast<uint32_t>(
      fb::shaderbundle::ShaderBundleFormatVersion::kVersion);
 
  for (const auto& [shader_name, shader_config] : bundle_config.value()) {
    std::unique_ptr<fb::shaderbundle::ShaderT> shader =
        GenerateShaderFB(options, shader_name, shader_config, out_dependencies);
    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, std::set< std::string > *  out_dependencies  )

static

Definition at line 199 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, out_dependencies);
  if (!result->metal_ios) {
    return nullptr;
  }
  result->metal_desktop =
      GenerateShaderBackendFB(TargetPlatform::kMetalDesktop, options,
                              shader_name, shader_config, out_dependencies);
  if (!result->metal_desktop) {
    return nullptr;
  }
  result->opengl_es =
      GenerateShaderBackendFB(TargetPlatform::kOpenGLES, options, shader_name,
                              shader_config, out_dependencies);
  if (!result->opengl_es) {
    return nullptr;
  }
  result->opengl_desktop =
      GenerateShaderBackendFB(TargetPlatform::kOpenGLDesktop, options,
                              shader_name, shader_config, out_dependencies);
  if (!result->opengl_desktop) {
    return nullptr;
  }
  result->vulkan =
      GenerateShaderBackendFB(TargetPlatform::kVulkan, options, shader_name,
                              shader_config, out_dependencies);
  if (!result->vulkan) {
    return nullptr;
  }
  return result;
}

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

Referenced by GenerateShaderBundleFlatbuffer().

GetOptionAsPath()

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

static

Definition at line 171 of file switches.cc.

                     {
  std::string value = command_line.GetOptionValueWithDefault(arg, "");
  return std::filesystem::path(std::u8string(value.begin(), value.end()));
}

References value.

GetReflectedStructSize()

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

static

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

Parameters

[in]

members

The members

Returns

The reflected structure size.

Definition at line 883 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 347 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.

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

GetShaderBundleTargetPlatformDefines()

std::vector< std::string_view > impeller::compiler::GetShaderBundleTargetPlatformDefines

(

TargetPlatform

platform

)

The platform-discriminating preprocessor defines injected when compiling a bundled shader for platform (for example IMPELLER_TARGET_METAL). These let bundled Flutter GPU shaders specialize for the backend they will run on, matching the defines that Impeller's own shaders receive from the build templates.

Note

Exposed only for testing purposes.

Definition at line 90 of file shader_bundle.cc.

                             {
  switch (platform) {
    case TargetPlatform::kMetalIOS:
      return {"IMPELLER_TARGET_METAL", "IMPELLER_TARGET_METAL_IOS"};
    case TargetPlatform::kMetalDesktop:
      return {"IMPELLER_TARGET_METAL", "IMPELLER_TARGET_METAL_DESKTOP"};
    case TargetPlatform::kOpenGLES:
      return {"IMPELLER_TARGET_OPENGLES"};
    case TargetPlatform::kOpenGLDesktop:
      return {"IMPELLER_TARGET_OPENGL"};
    case TargetPlatform::kVulkan:
      return {"IMPELLER_TARGET_VULKAN"};
    case TargetPlatform::kSkSL:
    case TargetPlatform::kRuntimeStageMetal:
    case TargetPlatform::kRuntimeStageGLES:
    case TargetPlatform::kRuntimeStageGLES3:
    case TargetPlatform::kRuntimeStageVulkan:
    case TargetPlatform::kUnknown:
      return {};
  }
  return {};
}

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

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

InferShaderNameFromPath()

std::string impeller::compiler::InferShaderNameFromPath

(

const std::filesystem::path &

path

)

Definition at line 34 of file utilities.cc.

                                                                 {
  return Utf8FromPath(path.stem());
}

References Utf8FromPath().

JoinStrings()

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

static

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

)

1. Output the source file. When in IPLR/RuntimeStage mode, output the serialized IPLR flatbuffer. Otherwise output the shader source in the target shading language.
2. Output SPIRV file.
3. Output shader reflection data. May include a JSON file, a C++ header, and/or a C++ TU.
4. Output a depfile.

Definition at line 197 of file impellerc_main.cc.

                                              {
  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(Utf8FromPath(switches.source_file_name));
  if (!source_file_mapping) {
    std::cerr << "Could not open input file." << std::endl;
    return false;
  }
 
  std::vector<std::shared_ptr<Compiler>> compilers;
  compilers.reserve(switches.PlatformsToCompile().size());
  for (const auto& platform : switches.PlatformsToCompile()) {
    std::shared_ptr<Compiler> compiler =
        CreateCompiler(platform, source_file_mapping, switches);
    if (compiler->IsValid()) {
      compilers.push_back(compiler);
    } else {
      std::cerr << "Compilation failed for target: "
                << TargetPlatformToString(platform) << std::endl;
 
      std::string verbose_error_messages = compiler->GetVerboseErrorMessages();
      if (verbose_error_messages.empty()) {
        // No verbose error messages. Output the regular error messages.
        std::cerr << compiler->GetErrorMessages();
      } else {
        if (switches.verbose) {
          // Verbose messages are available and the --verbose flag was set.
          // Directly output the verbose error messages.
          std::cerr << verbose_error_messages;
        } else {
          // Verbose messages are available and the --verbose flag was not set.
          // Output the regular error messages and write the verbose error
          // messages to a file.
          std::cerr << compiler->GetErrorMessages();
          OutputVerboseErrorFile(verbose_error_messages, switches);
        }
      }
 
      return false;
    }
  }
 
  // --------------------------------------------------------------------------
  /// 1. Output the source file. When in IPLR/RuntimeStage mode, output the
  ///    serialized IPLR flatbuffer. Otherwise output the shader source in the
  ///    target shading language.
  ///
 
  if (switches.iplr) {
    if (!OutputIPLR(compilers, switches)) {
      return false;
    }
  } else {
    // Non-IPLR mode is supported only for single platform targets. There is
    // exactly 1 created compiler for this case.
    FML_DCHECK(compilers.size() == 1);
    if (!OutputSLFile(*compilers.front(), switches)) {
      return false;
    }
  }
 
  // Use the first compiler for outputting the SPIRV file, reflection data, and
  // the depfile. The SPIRV and depfile outputs do not depend on the target
  // platform, so any valid compiler can be used. Reflection data output is only
  // supported for single platform targets, so it uses the first (only) valid
  // compiler as well.
  auto first_valid_compiler = compilers.front();
 
  // --------------------------------------------------------------------------
  /// 2. Output SPIRV file.
  ///
 
  if (!OutputSPIRV(*first_valid_compiler, switches)) {
    return false;
  }
 
  // --------------------------------------------------------------------------
  /// 3. Output shader reflection data.
  ///    May include a JSON file, a C++ header, and/or a C++ TU.
  ///
 
  if (ShouldOutputReflectionData(switches)) {
    // Outputting reflection data is supported only for single platform targets.
    FML_DCHECK(compilers.size() == 1);
    if (!OutputReflectionData(*first_valid_compiler, switches)) {
      return false;
    }
  }
 
  // --------------------------------------------------------------------------
  /// 4. Output a depfile.
  ///
 
  // Dep file output does not depend on the target platform. Any valid compiler
  // can be used to output it. Arbitrarily pick the first valid compiler.
  if (!OutputDepfile(*first_valid_compiler, switches)) {
    return false;
  }
 
  return true;
}

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

Referenced by main().

OutputBundleDepfile()

static bool impeller::compiler::OutputBundleDepfile ( const Switches &  switches, const std::string &  target, const std::set< std::string > &  dependencies  )

static

Write a Ninja-style depfile listing every source file (including #included headers) that contributed to the shader bundle at target.

Format mirrors Compiler::CreateDepfileContents for single-shader compiles: <target>: <dep1> <dep2> ... <depN>\n. See https://github.com/ninja-build/ninja/blob/master/src/depfile_parser.cc#L28

Definition at line 281 of file shader_bundle.cc.

                                                                       {
  std::stringstream stream;
  stream << target << ":";
  for (const auto& dep : dependencies) {
    stream << " " << dep;
  }
  stream << "\n";
  const auto contents = std::make_shared<std::string>(stream.str());
  const fml::NonOwnedMapping mapping(
      reinterpret_cast<const uint8_t*>(contents->data()), contents->size(),
      [contents](auto, auto) {});
 
  // Pass the relative path straight through; fml::WriteAtomically
  // resolves it against switches.working_directory (a directory fd
  // representing the build system's intended working dir, which may
  // differ from std::filesystem::current_path()).
  if (!fml::WriteAtomically(*switches.working_directory,
                            Utf8FromPath(switches.depfile_path).c_str(),
                            mapping)) {
    std::cerr << "Could not write depfile to " << switches.depfile_path
              << std::endl;
    return false;
  }
  return true;
}

References impeller::compiler::Switches::depfile_path, Utf8FromPath(), and impeller::compiler::Switches::working_directory.

Referenced by GenerateShaderBundle().

ParseMSLVersion()

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

static

Definition at line 105 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 25 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 836 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.

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 199 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 147 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 211 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 93 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().

ShaderCErrorToString()

std::string impeller::compiler::ShaderCErrorToString

(

shaderc_compilation_status

status

)

Definition at line 130 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 90 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 158 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::filesystem::path &

file_name

)

Definition at line 17 of file types.cc.

                                                                      {
  std::string extension = file_name.extension().string();
  if (extension == ".vert") {
    return SourceType::kVertexShader;
  }
 
  if (extension == ".frag") {
    return SourceType::kFragmentShader;
  }
 
  if (extension == ".comp") {
    return SourceType::kComputeShader;
  }
 
  return SourceType::kUnknown;
}

References kComputeShader, kFragmentShader, kUnknown, and kVertexShader.

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

SourceTypeFromString()

SourceType impeller::compiler::SourceTypeFromString

(

std::string

name

)

Definition at line 34 of file types.cc.

                                                {
  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 204 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, and kVertexShader.

StringStartsWith()

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

Definition at line 86 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 48 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";
}

TargetPlatformFromCommandLine()

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

static

Definition at line 129 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 258 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.

TargetPlatformIsOpenGL()

bool impeller::compiler::TargetPlatformIsOpenGL

(

TargetPlatform

platform

)

Definition at line 239 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.

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

TargetPlatformIsVulkan()

bool impeller::compiler::TargetPlatformIsVulkan

(

TargetPlatform

platform

)

Definition at line 277 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().

TargetPlatformSLExtension()

std::string impeller::compiler::TargetPlatformSLExtension

(

TargetPlatform

platform

)

Definition at line 218 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 183 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 62 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.

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

ToCamelCase()

std::string impeller::compiler::ToCamelCase

(

std::string_view

string

)

Definition at line 38 of file utilities.cc.

                                             {
  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 169 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, and kVertexShader.

Referenced by CreateCompiler().

ToInputType() [1/2]

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

static

Definition at line 95 of file runtime_stage_data.cc.

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

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.

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();
}

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

ToLowerCase()

std::string impeller::compiler::ToLowerCase

(

std::string_view

string

)

Definition at line 61 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 155 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, and kVertexShader.

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

ToSourceLanguage()

SourceLanguage impeller::compiler::ToSourceLanguage

(

const std::string &

source_language

)

Definition at line 52 of file types.cc.

                                                                  {
  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 652 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, and impeller::compiler::CompilerBackend::kSkSL.

ToUniformType() [1/2]

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

static

Definition at line 61 of file runtime_stage_data.cc.

                                      {
  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, and impeller::kStruct.

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

ToUniformType() [2/2]

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

static

Definition at line 56 of file shader_bundle_data.cc.

                                      {
  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, and impeller::kSampledImage.

TypeNameWithPaddingOfSize()

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

static

Definition at line 825 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(), impeller::compiler::SPIRVCompiler::CompileToSPV(), EntryPointFunctionNameFromSourceName(), GenerateShaderBundle(), InferShaderNameFromPath(), Main(), OutputBundleDepfile(), 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 1377 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, impeller::compiler::VertexType::type_name, TypeNameWithPaddingOfSize(), and impeller::compiler::VertexType::variable_name.

Variable Documentation

kEntrypointKey

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

static

Definition at line 187 of file runtime_stage_data.cc.

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

kExternalTexturePrefix

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

constexpr

Definition at line 11 of file constants.h.

Referenced by CreateGLSLCompiler().

kFormatVersionKey

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

static

Definition at line 184 of file runtime_stage_data.cc.

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

kKnownPlatforms

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

static

Initial value:

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

Definition at line 20 of file switches.cc.

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

kKnownRuntimeStages

const std::vector<std::pair<std::string, TargetPlatform> > impeller::compiler::kKnownRuntimeStages

static

Initial value:

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

Definition at line 29 of file switches.cc.

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

kKnownSourceTypes

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

static

Initial value:

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

Definition at line 37 of file switches.cc.

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

kMaxUniformBufferSize

const uint32_t impeller::compiler::kMaxUniformBufferSize = 6208

static

Definition at line 103 of file compiler.cc.

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

kReflectionCCTemplate

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

constexpr

Definition at line 209 of file code_gen_template.h.

kReflectionHeaderTemplate

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

constexpr

Definition at line 10 of file code_gen_template.h.

kShaderKey

const char* impeller::compiler::kShaderKey = "shader"

static

Definition at line 189 of file runtime_stage_data.cc.

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

kStageKey

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

static

Definition at line 185 of file runtime_stage_data.cc.

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

kTargetPlatformKey

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

static

Definition at line 186 of file runtime_stage_data.cc.

kUniformArrayElementsKey

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

static

Definition at line 196 of file runtime_stage_data.cc.

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

kUniformBitWidthKey

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

static

Definition at line 195 of file runtime_stage_data.cc.

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

kUniformColumnsKey

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

static

Definition at line 194 of file runtime_stage_data.cc.

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

kUniformLocationKey

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

static

Definition at line 191 of file runtime_stage_data.cc.

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

kUniformNameKey

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

static

Definition at line 190 of file runtime_stage_data.cc.

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

kUniformRowsKey

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

static

Definition at line 193 of file runtime_stage_data.cc.

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

kUniformsKey

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

static

Definition at line 188 of file runtime_stage_data.cc.

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

kUniformStructElementsKey

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

static

Definition at line 197 of file runtime_stage_data.cc.

kUniformTypeKey

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

static

Definition at line 192 of file runtime_stage_data.cc.

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