impeller::compiler::CompilerSkSL Class Reference

#include <spirv_sksl.h>

Inheritance diagram for impeller::compiler::CompilerSkSL:

Public Member Functions
	CompilerSkSL (std::vector< uint32_t > spirv_)
	CompilerSkSL (const uint32_t *ir_, size_t word_count)
	CompilerSkSL (const spirv_cross::ParsedIR &ir_)
	CompilerSkSL (spirv_cross::ParsedIR &&ir_)
std::string	compile () override

Private Member Functions
void	emit_header () override
void	emit_uniform (const spirv_cross::SPIRVariable &var) override
void	emit_function_prototype (spirv_cross::SPIRFunction &func, const spirv_cross::Bitset &return_flags) override
std::string	image_type_glsl (const spirv_cross::SPIRType &type, uint32_t id=0, bool member=false) override
std::string	builtin_to_glsl (spv::BuiltIn builtin, spv::StorageClass storage) override
std::string	to_texture_op (const spirv_cross::Instruction &i, bool sparse, bool *forward, spirv_cross::SmallVector< uint32_t > &inherited_expressions) override
std::string	to_function_name (const spirv_cross::CompilerGLSL::TextureFunctionNameArguments &args) override
std::string	to_function_args (const spirv_cross::CompilerGLSL::TextureFunctionArguments &args, bool *p_forward) override

Detailed Description

Definition at line 19 of file spirv_sksl.h.

Constructor & Destructor Documentation

CompilerSkSL() [1/4]

impeller::compiler::CompilerSkSL::CompilerSkSL ( std::vector< uint32_t >  spirv_ )

inlineexplicit

Definition at line 21 of file spirv_sksl.h.

      : CompilerGLSL(std::move(spirv_)) {}

CompilerSkSL() [2/4]

impeller::compiler::CompilerSkSL::CompilerSkSL ( const uint32_t *  ir_, size_t  word_count  )

inline

Definition at line 24 of file spirv_sksl.h.

      : CompilerGLSL(ir_, word_count) {}

CompilerSkSL() [3/4]

impeller::compiler::CompilerSkSL::CompilerSkSL ( const spirv_cross::ParsedIR &  ir_ )

inlineexplicit

Definition at line 27 of file spirv_sksl.h.

      : spirv_cross::CompilerGLSL(ir_) {}

CompilerSkSL() [4/4]

impeller::compiler::CompilerSkSL::CompilerSkSL ( spirv_cross::ParsedIR &&  ir_ )

inlineexplicit

Definition at line 30 of file spirv_sksl.h.

      : spirv_cross::CompilerGLSL(std::move(ir_)) {}

Member Function Documentation

builtin_to_glsl()

std::string impeller::compiler::CompilerSkSL::builtin_to_glsl ( spv::BuiltIn  builtin, spv::StorageClass  storage  )

overrideprivate

Definition at line 409 of file spirv_sksl.cc.

                                                                {
  std::string gl_builtin = CompilerGLSL::builtin_to_glsl(builtin, storage);
  switch (builtin) {
    case BuiltInFragCoord:
      return "flutter_FragCoord";
    default:
      FLUTTER_CROSS_THROW("Builtin '" + gl_builtin + "' is not supported.");
      break;
  }
 
  return "???";
}

compile()

std::string impeller::compiler::CompilerSkSL::compile ( )

override

Definition at line 24 of file spirv_sksl.cc.

                                {
  ir.fixup_reserved_names();
 
  if (get_execution_model() != ExecutionModelFragment) {
    FLUTTER_CROSS_THROW("Only fragment shaders are supported.'");
    return "";
  }
 
  options.es = false;
  options.version = 100;
  options.vulkan_semantics = false;
  options.enable_420pack_extension = false;
  options.flatten_multidimensional_arrays = true;
 
  backend.allow_precision_qualifiers = false;
  backend.basic_int16_type = "short";
  backend.basic_int_type = "int";
  backend.basic_uint16_type = "ushort";
  backend.basic_uint_type = "uint";
  backend.double_literal_suffix = false;
  backend.float_literal_suffix = false;
  backend.long_long_literal_suffix = false;
  backend.needs_row_major_load_workaround = true;
  backend.nonuniform_qualifier = "";
  backend.support_precise_qualifier = false;
  backend.uint32_t_literal_suffix = false;
  backend.use_array_constructor = true;
  backend.workgroup_size_is_hidden = true;
 
  fixup_user_functions();
 
  fixup_anonymous_struct_names();
  fixup_type_alias();
  reorder_type_alias();
  build_function_control_flow_graphs_and_analyze();
  fixup_image_load_store_access();
  update_active_builtins();
  analyze_image_and_sampler_usage();
  analyze_interlocked_resource_usage();
 
  uint32_t pass_count = 0;
  do {
    reset(pass_count);
 
    // Move constructor for this type is broken on GCC 4.9 ...
    buffer.reset();
 
    emit_header();
    emit_resources();
 
    emit_function(get<SPIRFunction>(ir.default_entry_point), Bitset());
 
    pass_count++;
  } while (is_forcing_recompilation());
 
  statement("half4 main(float2 iFragCoord)");
  begin_scope();
  statement("  flutter_FragCoord = float4(iFragCoord, 0, 0);");
  statement("  FLT_main();");
  statement("  return " + output_name_ + ";");
  end_scope();
 
  return buffer.str();
}

emit_function_prototype()

void impeller::compiler::CompilerSkSL::emit_function_prototype ( spirv_cross::SPIRFunction &  func, const spirv_cross::Bitset &  return_flags  )

overrideprivate

Definition at line 371 of file spirv_sksl.cc.

                                                                       {
  // If this is not the entrypoint, then no special processsing for SkSL is
  // required.
  if (func.self != ir.default_entry_point) {
    CompilerGLSL::emit_function_prototype(func, return_flags);
    return;
  }
 
  auto& type = get<SPIRType>(func.return_type);
  if (type.basetype != SPIRType::Void) {
    FLUTTER_CROSS_THROW(
        "Return type of the entrypoint function must be 'void'");
  }
 
  if (func.arguments.size() != 0) {
    FLUTTER_CROSS_THROW(
        "The entry point function should not acept any parameters.");
  }
 
  processing_entry_point = true;
 
  // If this is the entrypoint of a fragment shader, then GLSL requires the
  // prototype to be "void main()", and so it is safe to rewrite as
  // "void FLT_main()".
  statement("void FLT_main()");
}

emit_header()

void impeller::compiler::CompilerSkSL::emit_header ( )

overrideprivate

Definition at line 113 of file spirv_sksl.cc.

                               {
  statement("// This SkSL shader is autogenerated by spirv-cross.");
  statement("");
  statement("float4 flutter_FragCoord;");
  statement("");
}

emit_uniform()

void impeller::compiler::CompilerSkSL::emit_uniform ( const spirv_cross::SPIRVariable &  var )

overrideprivate

Definition at line 120 of file spirv_sksl.cc.

                                                       {
  auto& type = get<SPIRType>(var.basetype);
  if (type.basetype == SPIRType::UInt && is_legacy()) {
    FLUTTER_CROSS_THROW("SkSL does not support unsigned integers: '" +
                        get_name(var.self) + "'");
  }
 
  add_resource_name(var.self);
  statement(variable_decl(var), ";");
 
  // The Flutter FragmentProgram implementation passes additional uniforms along
  // with shader uniforms that encode the shader width and height.
  if (type.basetype == SPIRType::SampledImage) {
    std::string name = to_name(var.self);
    statement("uniform half2 " + name + "_size;");
  }
}

image_type_glsl()

std::string impeller::compiler::CompilerSkSL::image_type_glsl ( const spirv_cross::SPIRType &  type, uint32_t  id = 0, bool  member = false  )

overrideprivate

Definition at line 399 of file spirv_sksl.cc.

                                                       {
  if (type.basetype != SPIRType::SampledImage || type.image.dim != Dim2D) {
    FLUTTER_CROSS_THROW("Only sampler2D uniform image types are supported.");
    return "???";
  }
  return "shader";
}

to_function_args()

std::string impeller::compiler::CompilerSkSL::to_function_args ( const spirv_cross::CompilerGLSL::TextureFunctionArguments &  args, bool *  p_forward  )

overrideprivate

Definition at line 442 of file spirv_sksl.cc.

                                                            {
  std::string name = to_expression(args.base.img);
 
  std::string glsl_args = CompilerGLSL::to_function_args(args, p_forward);
  // SkSL only supports coordinates. All other arguments to texture are
  // unsupported and will generate invalid SkSL.
  if (args.grad_x || args.grad_y || args.lod || args.offset || args.sample ||
      args.min_lod || args.sparse_texel || args.bias || args.component) {
    FLUTTER_CROSS_THROW(
        "Only sampler and position arguments are supported in texture() "
        "calls.");
  }
 
  // GLSL puts the shader as the first argument, but in SkSL the shader is
  // implicitly passed as the reciever of the 'eval' method. Therefore, the
  // shader is removed from the GLSL argument list.
  std::string no_shader;
  auto npos = glsl_args.find(", ");  // The first ','.
  if (npos != std::string::npos) {
    no_shader = glsl_args.substr(npos + 1);  // The string after the first ','.
  }
 
  if (no_shader.empty()) {
    FLUTTER_CROSS_THROW("Unexpected shader sampling arguments: '(" + glsl_args +
                        ")'");
    return "()";
  }
 
  return name + "_size * (" + no_shader + ")";
}

to_function_name()

std::string impeller::compiler::CompilerSkSL::to_function_name ( const spirv_cross::CompilerGLSL::TextureFunctionNameArguments &  args )

overrideprivate

Definition at line 436 of file spirv_sksl.cc.

                                                          {
  std::string name = to_expression(args.base.img);
  return name + ".eval";
}

to_texture_op()

std::string impeller::compiler::CompilerSkSL::to_texture_op ( const spirv_cross::Instruction &  i, bool  sparse, bool *  forward, spirv_cross::SmallVector< uint32_t > &  inherited_expressions  )

overrideprivate

Definition at line 423 of file spirv_sksl.cc.

                                                  {
  auto op = static_cast<Op>(i.op);
  if (op != OpImageSampleImplicitLod) {
    FLUTTER_CROSS_THROW("Only simple shader sampling is supported.");
    return "???";
  }
  return CompilerGLSL::to_texture_op(i, sparse, forward, inherited_expressions);
}

---

The documentation for this class was generated from the following files:

• impeller/compiler/spirv_sksl.h
• impeller/compiler/spirv_sksl.cc