Namespaces
namespace	testing

Classes
class	AutoLogger

class	Compiler

struct	CompilerBackend

class	CompilerSkSL

struct	IncludeDir

class	Includer

struct	IncluderData

struct	InputDescription

struct	KnownType

class	Reflector

class	RuntimeStageData

class	ShaderBundleData

struct	ShaderConfig
	A shader config parsed as part of a ShaderBundleConfig. More...

struct	SourceOptions

class	SPIRVCompiler

struct	SPIRVCompilerOptions

struct	SPIRVCompilerSourceProfile

struct	SPIRVCompilerTargetEnv

struct	StructField

struct	StructMember

class	Switches

struct	UniformDescription

class	UniqueIncluder
	Wraps a shared includer so unique includers may be created to satisfy the shaderc API. This is a simple proxy object and does nothing. More...

struct	VertexType

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

Enumerations
enum 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.

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.

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.

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.

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.

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

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.

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 class impeller::compiler::SourceLanguage

strong

Enumerator
kUnknown
kGLSL
kHLSL

Definition at line 44 of file types.h.

                          {
  kUnknown,
  kGLSL,
  kHLSL,
};

◆ SourceType

enum class impeller::compiler::SourceType

strong

Enumerator
kUnknown
kVertexShader
kFragmentShader
kComputeShader

Definition at line 23 of file types.h.

                      {
  kUnknown,
  kVertexShader,
  kFragmentShader,
  kComputeShader,
};

◆ TargetPlatform

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

References i, and length.

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 234 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(), FML_UNREACHABLE, 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 150 of file compiler.cc.

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

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

Referenced by CreateCompiler().

◆ CreateMSLCompiler()

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

static

Definition at line 67 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 208 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 138 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, type, 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 214 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 FML_UNREACHABLE, 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 91 of file shader_bundle.cc.

                                                             {
  auto result = std::make_unique<fb::shaderbundle::BackendShaderT>();
 
  std::shared_ptr<fml::FileMapping> source_file_mapping =
      fml::FileMapping::CreateReadOnly(shader_config.source_file_name);
  if (!source_file_mapping) {
    std::cerr << "Could not open file for bundled shader \"" << shader_name
              << "\"." << std::endl;
    return nullptr;
  }
 
  /// Override options.
  options.target_platform = target_platform;
  options.file_name = shader_name;  // This is just used for error messages.
  options.type = shader_config.type;
  options.source_language = shader_config.language;
  options.entry_point_name = EntryPointFunctionNameFromSourceName(
      shader_config.source_file_name, options.type, options.source_language,
      shader_config.entry_point);
 
  Reflector::Options reflector_options;
  reflector_options.target_platform = options.target_platform;
  reflector_options.entry_point_name = options.entry_point_name;
  reflector_options.shader_name = shader_name;
 
  Compiler compiler(source_file_mapping, options, reflector_options);
  if (!compiler.IsValid()) {
    std::cerr << "Compilation failed for bundled shader \"" << shader_name
              << "\"." << std::endl;
    std::cerr << compiler.GetErrorMessages() << std::endl;
    return nullptr;
  }
 
  // 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;
}

Referenced by GenerateShaderFB().

◆ GenerateShaderBundle()

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

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

Parse the shader bundle and generate the flatbuffer result.

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.

Serialize the shader bundle and write to disk.

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 273 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(), impeller::compiler::Switches::working_directory, and fml::WriteAtomically().

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.

Parse the bundle configuration.

Build the deserialized shader bundle.

Definition at line 203 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(), impeller::compiler::testing::TEST(), impeller::compiler::testing::TEST(), 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 163 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 fml::CommandLine::GetOptionValueWithDefault(), and 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 853 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 317 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 FML_UNREACHABLE, impeller::kMetal, kMetalDesktop, kMetalIOS, kOpenGLDesktop, kOpenGLES, impeller::kOpenGLES, impeller::kOpenGLES3, kRuntimeStageGLES, kRuntimeStageGLES3, kRuntimeStageMetal, kRuntimeStageVulkan, kSkSL, impeller::kSkSL, kUnknown, kVulkan, and impeller::kVulkan.

◆ InferShaderNameFromPath()

std::string impeller::compiler::InferShaderNameFromPath ( 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 628 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();
}

References i.

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

◆ Main()

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

Output the source file. When in IPLR/RuntimeStage mode, output the serialized IPLR flatbuffer. Otherwise output the shader source in the target shading language.

Output SPIRV file.

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

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(), fml::FileMapping::CreateReadOnly(), FML_DCHECK, GenerateShaderBundle(), fml::CommandLine::HasOption(), fml::InstallCrashHandler(), 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 245 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, target, Utf8FromPath(), impeller::compiler::Switches::working_directory, and fml::WriteAtomically().

Referenced by GenerateShaderBundle().

◆ ParseMSLVersion()

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

static

Definition at line 44 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(), impeller::compiler::testing::TEST(), impeller::compiler::testing::TEST(), impeller::compiler::testing::TEST(), impeller::compiler::testing::TEST(), impeller::compiler::testing::TEST(), impeller::compiler::testing::TEST(), and impeller::compiler::testing::TEST().

◆ ReadKnownScalarType()

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

static

Definition at line 806 of file reflector.cc.

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

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

◆ report_and_exit()

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

Definition at line 16 of file spirv_sksl.cc.

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

◆ RuntimeStageBackendToString()

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

static

Definition at line 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 fml::CommandLine::HasOption(), and 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                             //
    );
  }
}

References i.

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

References error.

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 fml::CommandLine::GetOptionValueWithDefault(), 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, name, 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 FML_UNREACHABLE, kComputeShader, kFragmentShader, kUnknown, kVertexShader, and type.

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

References i, and target.

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 fml::CommandLine::HasOption(), kKnownPlatforms, kUnknown, and target.

◆ 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 FML_UNREACHABLE, kMetalDesktop, kMetalIOS, kOpenGLDesktop, kOpenGLES, kRuntimeStageGLES, kRuntimeStageGLES3, kRuntimeStageMetal, kRuntimeStageVulkan, kSkSL, kUnknown, and kVulkan.

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

◆ TargetPlatformIsOpenGL()

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

Definition at line 239 of file types.cc.

                                                     {
  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 FML_UNREACHABLE, 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 FML_UNREACHABLE, 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 FML_UNREACHABLE, 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 FML_UNREACHABLE, 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 FML_UNREACHABLE, kMetalDesktop, kMetalIOS, kOpenGLDesktop, kOpenGLES, kRuntimeStageGLES, kRuntimeStageGLES3, kRuntimeStageMetal, kRuntimeStageVulkan, kSkSL, kUnknown, and kVulkan.

Referenced by impeller::compiler::testing::INSTANTIATE_TEST_SUITE_P(), impeller::compiler::testing::INSTANTIATE_TEST_SUITE_P(), impeller::compiler::testing::INSTANTIATE_TEST_SUITE_P(), 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();
}

References i, and length.

◆ 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, kVertexShader, and type.

Referenced by CreateCompiler().

◆ ToInputType() [1/2]

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

static

Definition at line 95 of file runtime_stage_data.cc.

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

References FML_UNREACHABLE, and type.

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

◆ ToInputType() [2/2]

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

static

Definition at line 100 of file shader_bundle_data.cc.

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

References FML_UNREACHABLE, and type.

◆ ToJsonStage()

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

static

Definition at line 47 of file runtime_stage_data.cc.

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

References FML_UNREACHABLE.

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

◆ ToJsonType()

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

static

Definition at line 138 of file runtime_stage_data.cc.

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

References FML_UNREACHABLE, and type.

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

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

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

References FML_UNREACHABLE.

◆ ToString()

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

static

Definition at line 622 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 FML_UNREACHABLE, impeller::compiler::CompilerBackend::kGLSL, impeller::compiler::CompilerBackend::kGLSLVulkan, impeller::compiler::CompilerBackend::kMSL, impeller::compiler::CompilerBackend::kSkSL, and type.

◆ ToUniformType() [1/2]

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

static

Definition at line 61 of file runtime_stage_data.cc.

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

References FML_UNREACHABLE, and type.

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

◆ ToUniformType() [2/2]

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

static

Definition at line 56 of file shader_bundle_data.cc.

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

References FML_UNREACHABLE, and type.

◆ TypeNameWithPaddingOfSize()

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

static

Definition at line 795 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 1347 of file reflector.cc.

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

References impeller::compiler::VertexType::base_type, impeller::compiler::VertexType::byte_length, type, impeller::compiler::VertexType::type_name, TypeNameWithPaddingOfSize(), and impeller::compiler::VertexType::variable_name.

Variable Documentation

◆ kEntrypointKey

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

static

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

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

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.

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

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.

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

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

◆ kMaxUniformBufferSize

const uint32_t impeller::compiler::kMaxUniformBufferSize = 6208

static

Definition at line 42 of file compiler.cc.

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

◆ kReflectionCCTemplate

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

constexpr

Definition at line 202 of file code_gen_template.h.

◆ kReflectionHeaderTemplate

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

constexpr

Definition at line 10 of file code_gen_template.h.

◆ kShaderKey

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

static

Definition at line 189 of file runtime_stage_data.cc.

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

◆ kStageKey

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

static

Definition at line 185 of file runtime_stage_data.cc.

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

◆ kTargetPlatformKey

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

static

Definition at line 186 of file runtime_stage_data.cc.

◆ kUniformArrayElementsKey

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

static

Definition at line 196 of file runtime_stage_data.cc.

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

◆ kUniformBitWidthKey

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

static

Definition at line 195 of file runtime_stage_data.cc.

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

◆ kUniformColumnsKey

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

static

Definition at line 194 of file runtime_stage_data.cc.

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

◆ kUniformLocationKey

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

static

Definition at line 191 of file runtime_stage_data.cc.

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

◆ kUniformNameKey

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

static

Definition at line 190 of file runtime_stage_data.cc.

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

◆ kUniformRowsKey

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

static

Definition at line 193 of file runtime_stage_data.cc.

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

◆ kUniformsKey

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

static

Definition at line 188 of file runtime_stage_data.cc.

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

◆ kUniformStructElementsKey

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

static

Definition at line 197 of file runtime_stage_data.cc.

◆ kUniformTypeKey

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

static

Definition at line 192 of file runtime_stage_data.cc.

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

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ ShaderBundleConfig

Enumeration Type Documentation

◆ SourceLanguage

◆ SourceType

◆ TargetPlatform

Function Documentation

◆ ConvertToEntrypointName()

◆ CreateCompiler()

◆ CreateGLSLCompiler()

◆ CreateMSLCompiler()

◆ CreateSkSLCompiler()

◆ CreateVulkanCompiler()

◆ EntryPointFunctionNameFromSourceName()

◆ EntryPointMustBeNamedMain()

◆ ExecutionModelToStringName()

◆ GenerateShaderBackendFB()

◆ GenerateShaderBundle()

◆ GenerateShaderBundleFlatbuffer()

◆ GenerateShaderFB()

◆ GetOptionAsPath()

◆ GetReflectedStructSize()

◆ GetRuntimeStageBackend()

◆ InferShaderNameFromPath()

◆ JoinStrings()

◆ Main()

◆ OutputBundleDepfile()

◆ ParseMSLVersion()

◆ ParseShaderBundleConfig()

◆ ReadKnownScalarType()

◆ report_and_exit()

◆ RuntimeStageBackendToString()

◆ RuntimeStagesFromCommandLine()

◆ SetBindingBaseOffset()

◆ SetDefaultLimitations()

◆ SetPermissiveAccess()

◆ ShaderCErrorToString()

◆ SourceLanguageToString()

◆ SourceTypeFromCommandLine()

◆ SourceTypeFromFileName()

◆ SourceTypeFromString()

◆ SourceTypeToString()

◆ StringStartsWith()

◆ StringToShaderStage()

◆ TargetPlatformFromCommandLine()

◆ TargetPlatformIsMetal()

◆ TargetPlatformIsOpenGL()

◆ TargetPlatformIsVulkan()

◆ TargetPlatformSLExtension()

◆ TargetPlatformToMSLPlatform()

◆ TargetPlatformToString()

◆ ToCamelCase()

◆ ToExecutionModel()

◆ ToInputType() [1/2]

◆ ToInputType() [2/2]

◆ ToJsonStage()

◆ ToJsonType()

◆ ToLowerCase()

◆ ToShaderCShaderKind()

◆ ToSourceLanguage()

◆ ToStage() [1/2]

◆ ToStage() [2/2]

◆ ToString()

◆ ToUniformType() [1/2]

◆ ToUniformType() [2/2]

◆ TypeNameWithPaddingOfSize()

◆ Utf8FromPath()

◆ VertexTypeFromInputResource()

Variable Documentation

◆ kEntrypointKey

◆ kExternalTexturePrefix

◆ kFormatVersionKey

◆ kKnownPlatforms

◆ kKnownRuntimeStages