# Copyright 2013 The Flutter Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

import("//build/compiled_action.gni")
import("//flutter/common/config.gni")
import("//flutter/impeller/tools/malioc.gni")
import("//flutter/testing/testing.gni")

declare_args() {
  impeller_debug =
      flutter_runtime_mode == "debug" || flutter_runtime_mode == "profile"

  # Whether the runtime capture/playback system is enabled.
  impeller_capture = flutter_runtime_mode == "debug"

  # Whether the Metal backend is enabled.
  impeller_enable_metal = (is_mac || is_ios) && target_os != "fuchsia"

  # Whether the OpenGLES backend is enabled.
  impeller_enable_opengles =
      (is_linux || is_win || is_android) && target_os != "fuchsia"

  # Whether the Vulkan backend is enabled.
  impeller_enable_vulkan = (is_linux || is_win || is_android ||
                            enable_unittests) && target_os != "fuchsia"

  # Whether playgrounds should run with Vulkan.
  #
  # impeller_enable_vulkan may be true in build environments that run tests but
  # do not have a Vulkan ICD present.
  impeller_enable_vulkan_playgrounds =
      (is_linux || is_win || is_android) && target_os != "fuchsia"

  # Whether to use a prebuilt impellerc.
  # If this is the empty string, impellerc will be built.
  # If it is non-empty, it should be the absolute path to impellerc.
  impeller_use_prebuilt_impellerc = ""

  # Whether to use a prebuilt scenec.
  # If this is the empty string, scenec will be built.
  # If it is non-empty, it should be the absolute path to scenec.
  impeller_use_prebuilt_scenec = ""

  # If enabled, all OpenGL calls will be traced. Because additional trace
  # overhead may be substantial, this is not enabled by default.
  impeller_trace_all_gl_calls = false

  # Enable experimental 3D scene rendering.
  impeller_enable_3d = false

  # Enable to get trace statements for canvas usage.
  impeller_trace_canvas = false
}

declare_args() {
  # Wether to build and include the validation layers.
  impeller_enable_vulkan_validation_layers =
      impeller_enable_vulkan && flutter_runtime_mode == "debug" &&
      target_cpu == "arm64"

  # Whether Impeller supports rendering on the platform.
  impeller_supports_rendering =
      impeller_enable_metal || impeller_enable_opengles ||
      impeller_enable_vulkan

  impeller_enable_compute = impeller_enable_vulkan || impeller_enable_metal
}

# ------------------------------------------------------------------------------
# @brief           Define an Impeller component. Components are different
#                  Impeller subsystems part of the umbrella framework.
#
# @param[optional] target_type  The type of the component. This can be any of
#                               the target types supported by GN. Defaults to
#                               source_set. If Impeller is not supported on the
#                               target platform, this target is a no-op.
#
template("impeller_component") {
  if (defined(invoker.testonly) && invoker.testonly && !enable_unittests) {
    group(target_name) {
      not_needed(invoker, "*")
    }
  } else {
    target_type = "source_set"
    if (defined(invoker.target_type)) {
      target_type = invoker.target_type
    }
    target(target_type, target_name) {
      forward_variables_from(invoker, "*")

      if (!defined(invoker.public_configs)) {
        public_configs = []
      }

      public_configs += [ "//flutter/impeller:impeller_public_config" ]

      if (!defined(invoker.cflags)) {
        cflags = []
      }
      cflags += [ "-Wthread-safety-analysis" ]

      if (!defined(invoker.cflags_objc)) {
        cflags_objc = []
      }

      if (is_ios || is_mac) {
        cflags_objc += flutter_cflags_objc_arc
      }

      if (!defined(invoker.cflags_objcc)) {
        cflags_objcc = []
      }

      if (is_ios || is_mac) {
        cflags_objcc += flutter_cflags_objcc_arc
      }
    }
  }
}

# ------------------------------------------------------------------------------
# @brief           Build a Metal Library. The output is a single file. Use
#                  get_target_outputs to get its location on build.
#
# @param[required] name     The name of the Metal library.
#
# @param[required] sources  The GLSL (4.60) sources to compiled into the Metal
#                           library.
#
# @param[required] metal_version  The Metal language version to compile for.
#
template("metal_library") {
  assert(is_ios || is_mac)
  assert(defined(invoker.name), "Metal library name must be specified.")
  assert(defined(invoker.sources), "Metal source files must be specified.")
  assert(defined(invoker.metal_version),
         "Metal language version must be specified.")

  metal_library_name = invoker.name

  action("$target_name") {
    forward_variables_from(invoker,
                           "*",
                           [
                             "inputs",
                             "outputs",
                             "script",
                             "depfile",
                             "args",
                           ])

    inputs = invoker.sources

    metal_library_path = "$root_out_dir/shaders/$metal_library_name.metallib"
    metal_library_symbols_path =
        "$root_out_dir/shaders/$metal_library_name.metallibsym"

    outputs = [
      metal_library_path,
      metal_library_symbols_path,
    ]

    script = "//flutter/impeller/tools/build_metal_library.py"

    depfile = "$target_gen_dir/mtl/$metal_library_name.depfile"

    args = [
      "--output",
      rebase_path(metal_library_path, root_out_dir),
      "--depfile",
      rebase_path(depfile),
      "--metal-version=$metal_version",
    ]

    if (is_ios) {
      if (use_ios_simulator) {
        args += [ "--platform=ios-simulator" ]
      } else {
        args += [ "--platform=ios" ]
      }
    } else if (is_mac) {
      args += [ "--platform=mac" ]
    } else {
      assert(false, "Unsupported platform for generating Metal shaders.")
    }

    foreach(source, invoker.sources) {
      args += [
        "--source",
        rebase_path(source, root_out_dir),
      ]
    }
  }
}

template("embed_blob") {
  assert(defined(invoker.symbol_name), "The symbol name must be specified.")
  assert(defined(invoker.blob), "The blob file to embed must be specified")
  assert(defined(invoker.hdr),
         "The header file containing the symbol name must be specified.")
  assert(defined(invoker.cc),
         "The CC file containing the symbol data must be specified.")
  assert(defined(invoker.deps), "The target dependencies must be specified")

  gen_blob_target_name = "gen_blob_$target_name"
  action(gen_blob_target_name) {
    inputs = [ invoker.blob ]
    outputs = [
      invoker.hdr,
      invoker.cc,
    ]
    args = [
      "--symbol-name",
      invoker.symbol_name,
      "--output-header",
      rebase_path(invoker.hdr),
      "--output-source",
      rebase_path(invoker.cc),
      "--source",
      rebase_path(invoker.blob),
    ]
    script = "//flutter/impeller/tools/xxd.py"
    deps = invoker.deps
  }

  embed_config = "embed_$target_name"
  config(embed_config) {
    include_dirs = [ get_path_info(
            get_label_info("//flutter/impeller:impeller", "target_gen_dir"),
            "dir") ]
  }

  source_set(target_name) {
    public_configs = [ ":$embed_config" ]
    sources = get_target_outputs(":$gen_blob_target_name")
    deps = [ ":$gen_blob_target_name" ]
  }
}

# Dispatches to the build or prebuilt impellerc depending on the value of
# the `impeller_use_prebuilt_impellerc` argument.
# * When the `single_invocation` argument is false, all variables are
#   forwarded to `compiled_action_foreach` or `action_foreach`, which will
#   invoke `impellerc` separately for each source.
# * When the `single_invocation` argument is true, `impellerc` is only
#   invoked once via `compiled_action` or `action`.
template("_impellerc") {
  if (invoker.single_invocation) {
    if (impeller_use_prebuilt_impellerc == "") {
      compiled_action(target_name) {
        forward_variables_from(invoker, "*")
        tool = "//flutter/impeller/compiler:impellerc"
      }
    } else {
      action(target_name) {
        forward_variables_from(invoker, "*", [ "args" ])
        script = "//build/gn_run_binary.py"
        impellerc_path =
            rebase_path(impeller_use_prebuilt_impellerc, root_build_dir)
        args = [ impellerc_path ] + invoker.args
      }
    }
  } else {
    if (impeller_use_prebuilt_impellerc == "") {
      compiled_action_foreach(target_name) {
        forward_variables_from(invoker, "*")
        tool = "//flutter/impeller/compiler:impellerc"
      }
    } else {
      action_foreach(target_name) {
        forward_variables_from(invoker, "*", [ "args" ])
        script = "//build/gn_run_binary.py"
        impellerc_path =
            rebase_path(impeller_use_prebuilt_impellerc, root_build_dir)
        args = [ impellerc_path ] + invoker.args
      }
    }
  }
}

# Required: shaders                 The list of shaders inputs to compile.
# Required: shader_target_flags     The target flag(s) to append. Valid options:
#                                       --sksl
#                                       --metal-ios
#                                       --metal-desktop
#                                       --opengl-es
#                                       --opengl-desktop
#                                       --vulkan
#                                       --runtime-stage-metal
#                                       --runtime-stage-gles
# Required: sl_file_extension       The file extension to use for output files.
#                                   Not required for --shader_bundle mode.
# Optional: iplr                    Causes --sl output to be in iplr/runtime
#                                   stage flatbuffer format.
# Optional: shader_bundle           Specifies a Flutter GPU shader bundle
#                                   configuration.
#   Required: shader_bundle_output  Specifies the output filename of the shader
#                                   bundle. This is only required if
#                                   shader_bundle is supplied.
# Optional: defines                 Specifies a list of valueless macro
#                                   definitions.
# Optional: intermediates_subdir    Specifies the subdirectory in which to put
#                                   intermediates.
# Optional: json                    Causes output format to be JSON instead of
#                                   flatbuffer.
template("impellerc") {
  assert(defined(invoker.shaders), "Impeller shaders must be specified.")
  assert(defined(invoker.shader_target_flags),
         "The flag to impellerc for target selection must be specified.")
  assert(defined(invoker.sl_file_extension) || defined(invoker.shader_bundle),
         "The extension of the SL file must be specified (metal, glsl, etc..).")
  if (defined(invoker.shader_bundle)) {
    assert(
        defined(invoker.shader_bundle_output),
        "When shader_bundle is specified, shader_output_bundle must also be specified.")
  }

  sksl = false
  foreach(shader_target_flag, invoker.shader_target_flags) {
    sksl = shader_target_flag == "--sksl"
  }
  iplr = false
  if (defined(invoker.iplr) && invoker.iplr) {
    iplr = invoker.iplr
  }
  json = false
  if (defined(invoker.json) && invoker.json) {
    json = invoker.json
  }

  # Not needed on every path.
  not_needed([
               "iplr",
               "sksl",
               "shader_bundle",
               "shader_bundle_output",
             ])

  _impellerc(target_name) {
    shader_bundle = defined(invoker.shader_bundle)

    # When single_invocation is true, impellerc will be invoked exactly once. When it's
    # false, impellerc be invoked for each of the source file entries (invoker.shaders).
    single_invocation = shader_bundle

    if (defined(invoker.intermediates_subdir)) {
      subdir = invoker.intermediates_subdir
      generated_dir = "$target_gen_dir/$subdir"
    } else {
      generated_dir = "$target_gen_dir"
    }

    shader_target_flags = invoker.shader_target_flags

    shader_lib_dir = rebase_path("//flutter/impeller/compiler/shader_lib")
    args = [ "--include=$shader_lib_dir" ] + shader_target_flags

    # When we're in single invocation mode, we can't use source enumeration.
    if (!single_invocation) {
      depfile_path = "$generated_dir/{{source_file_part}}.d"
      depfile_intermediate_path = rebase_path(depfile_path, root_build_dir)
      depfile = depfile_path
      args += [
        "--input={{source}}",
        "--include={{source_dir}}",
        "--depfile=$depfile_intermediate_path",
      ]
    }

    if (defined(invoker.gles_language_version)) {
      gles_language_version = invoker.gles_language_version
      args += [ "--gles-language-version=$gles_language_version" ]
    }

    if (defined(invoker.metal_version)) {
      assert(is_mac || is_ios)
      metal_version = invoker.metal_version
      args += [ "--metal-version=$metal_version" ]
    }

    if (defined(invoker.use_half_textures) && invoker.use_half_textures) {
      args += [ "--use-half-textures" ]
    }
    if (defined(invoker.require_framebuffer_fetch) &&
        invoker.require_framebuffer_fetch) {
      args += [ "--require-framebuffer-fetch" ]
    }

    if (json) {
      args += [ "--json" ]
    }

    if (iplr) {
      # When building in IPLR mode, the compiler may be executed twice
      args += [ "--iplr" ]
    }

    # The `sl_output` is the raw shader file output by the compiler. For --iplr
    # and --shader-bundle, this is used as the filename for the flatbuffer to
    # output.

    if (shader_bundle) {
      # When a shader bundle is specified, don't bother supplying flags for
      # the reflection state as these are ignored. In this mode, the compiler
      # is invoked multiple times and the reflection state for each shader is
      # written to the output flatbuffer.
      sl_output = "$generated_dir/${invoker.shader_bundle_output}"
      sl_output_path = rebase_path(sl_output, root_build_dir)

      args += [
        "--sl=$sl_output_path",
        "--shader-bundle=${invoker.shader_bundle}",
      ]

      outputs = [ sl_output ]
    } else if (sksl) {
      # When SkSL is selected as a `shader_target_flags`, don't generate
      # C++ reflection state. Nothing needs to use it and it's likely invalid
      # given the special cases when generating SkSL.
      # Note that this configuration is orthogonal to the "--iplr" flag
      sl_output =
          "$generated_dir/{{source_file_part}}.${invoker.sl_file_extension}"
      sl_output_path = rebase_path(sl_output, root_build_dir)

      spirv_intermediate = "$generated_dir/{{source_file_part}}.spirv"
      spirv_intermediate_path = rebase_path(spirv_intermediate, root_build_dir)
      args += [
        "--sl=$sl_output_path",
        "--spirv=$spirv_intermediate_path",
      ]

      outputs = [ sl_output ]
    } else {
      # The default branch. Here we just generate one shader along with all of
      # its C++ reflection state.

      sl_output =
          "$generated_dir/{{source_file_part}}.${invoker.sl_file_extension}"
      sl_output_path = rebase_path(sl_output, root_build_dir)

      reflection_json_intermediate = "$generated_dir/{{source_file_part}}.json"
      reflection_header_intermediate = "$generated_dir/{{source_file_part}}.h"
      reflection_cc_intermediate = "$generated_dir/{{source_file_part}}.cc"

      spirv_intermediate = "$generated_dir/{{source_file_part}}.spirv"
      spirv_intermediate_path = rebase_path(spirv_intermediate, root_build_dir)
      reflection_json_path =
          rebase_path(reflection_json_intermediate, root_build_dir)
      reflection_header_path =
          rebase_path(reflection_header_intermediate, root_build_dir)
      reflection_cc_path =
          rebase_path(reflection_cc_intermediate, root_build_dir)

      args += [
        "--sl=$sl_output_path",
        "--spirv=$spirv_intermediate_path",
        "--reflection-json=$reflection_json_path",
        "--reflection-header=$reflection_header_path",
        "--reflection-cc=$reflection_cc_path",
      ]

      outputs = [
        sl_output,
        reflection_header_intermediate,
        reflection_cc_intermediate,
      ]
    }

    if (defined(invoker.defines)) {
      foreach(def, invoker.defines) {
        args += [ "--define=$def" ]
      }
    }

    if (single_invocation) {
      inputs = invoker.shaders
    } else {
      sources = invoker.shaders
    }
  }
}

template("impellerc_reflect") {
  assert(
      defined(invoker.impellerc_invocation),
      "The target that specifies the ImpellerC invocation to reflect must be defined.")

  reflect_config = "reflect_$target_name"
  config(reflect_config) {
    include_dirs = [ get_path_info(
            get_label_info("//flutter/impeller:impeller", "target_gen_dir"),
            "dir") ]
  }

  impellerc_invocation = invoker.impellerc_invocation

  source_set(target_name) {
    public_configs = [ ":$reflect_config" ]
    public = filter_include(get_target_outputs(impellerc_invocation), [ "*.h" ])
    sources = filter_include(get_target_outputs(impellerc_invocation),
                             [
                               "*.h",
                               "*.cc",
                               "*.mm",
                             ])

    deps = [
      "//flutter/impeller/core",
      impellerc_invocation,
    ]
  }
}

template("_impeller_shaders_metal") {
  assert(defined(invoker.shaders), "Impeller shaders must be specified.")
  assert(defined(invoker.name), "Name of the shader library must be specified.")

  metal_version = "1.2"
  if (defined(invoker.metal_version)) {
    metal_version = invoker.metal_version
  }

  use_half_textures = false
  if (defined(invoker.use_half_textures) && invoker.use_half_textures) {
    use_half_textures = invoker.use_half_textures
  }

  shaders_base_name = string_join("",
                                  [
                                    invoker.name,
                                    "_shaders",
                                  ])
  impellerc_mtl = "impellerc_$target_name"
  impellerc(impellerc_mtl) {
    shaders = invoker.shaders
    metal_version = metal_version
    sl_file_extension = "metal"
    use_half_textures = use_half_textures
    shader_target_flags = []
    defines = [ "IMPELLER_TARGET_METAL" ]
    if (is_ios) {
      shader_target_flags += [ "--metal-ios" ]
      defines += [ "IMPELLER_TARGET_METAL_IOS" ]
    } else if (is_mac) {
      shader_target_flags = [ "--metal-desktop" ]
      defines += [ "IMPELLER_TARGET_METAL_DESKTOP" ]
    } else {
      assert(false, "Metal not supported on this platform.")
    }
  }

  mtl_lib = "genlib_$target_name"
  metal_library(mtl_lib) {
    name = invoker.name
    metal_version = metal_version
    sources =
        filter_include(get_target_outputs(":$impellerc_mtl"), [ "*.metal" ])
    deps = [ ":$impellerc_mtl" ]
  }

  reflect_mtl = "reflect_$target_name"
  impellerc_reflect(reflect_mtl) {
    impellerc_invocation = ":$impellerc_mtl"
  }

  embed_mtl_lib = "embed_$target_name"
  embed_blob(embed_mtl_lib) {
    metal_library_files = get_target_outputs(":$mtl_lib")
    symbol_name = shaders_base_name
    blob = metal_library_files[0]
    hdr = "$target_gen_dir/mtl/$shaders_base_name.h"
    cc = "$target_gen_dir/mtl/$shaders_base_name.cc"
    deps = [ ":$mtl_lib" ]
  }

  group(target_name) {
    public_deps = [
      ":$embed_mtl_lib",
      ":$reflect_mtl",
    ]
  }
}

template("shader_archive") {
  assert(defined(invoker.shaders),
         "The shaders to build the library from must be specified.")
  assert(defined(invoker.deps), "Target dependencies must be specified.")

  output_file = "$target_gen_dir/$target_name.shar"
  compiled_action(target_name) {
    tool = "//flutter/impeller/shader_archive:shader_archiver"
    inputs = invoker.shaders
    outputs = [ output_file ]
    output_path_rebased = rebase_path(output_file, root_build_dir)
    args = [ "--output=$output_path_rebased" ]
    foreach(shader, invoker.shaders) {
      shader_path = rebase_path(shader, root_build_dir)
      args += [ "--input=$shader_path" ]
    }
    deps = invoker.deps
  }
}

template("_impeller_shaders_gles") {
  assert(defined(invoker.shaders), "Impeller shaders must be specified.")
  assert(defined(invoker.name), "Name of the shader library must be specified.")
  assert(defined(invoker.analyze), "Whether to analyze must be specified.")

  require_framebuffer_fetch = false
  if (defined(invoker.require_framebuffer_fetch) &&
      invoker.require_framebuffer_fetch) {
    require_framebuffer_fetch = invoker.require_framebuffer_fetch
  }

  shaders_base_name = string_join("",
                                  [
                                    invoker.name,
                                    "_shaders_gles",
                                  ])
  impellerc_gles = "impellerc_$target_name"
  impellerc(impellerc_gles) {
    shaders = invoker.shaders
    sl_file_extension = "gles"
    require_framebuffer_fetch = require_framebuffer_fetch
    if (defined(invoker.gles_language_version)) {
      gles_language_version = invoker.gles_language_version
    }

    # Metal reflectors generate a superset of information.
    if (impeller_enable_metal || impeller_enable_vulkan) {
      intermediates_subdir = "gles"
    }
    if (is_mac) {
      shader_target_flags = [ "--opengl-desktop" ]
    } else {
      shader_target_flags = [ "--opengl-es" ]
    }

    defines = [ "IMPELLER_TARGET_OPENGLES" ]
  }

  gles_shaders =
      filter_include(get_target_outputs(":$impellerc_gles"), [ "*.gles" ])

  if (invoker.analyze) {
    analyze_lib = "analyze_$target_name"
    malioc_analyze_shaders(analyze_lib) {
      shaders = gles_shaders
      if (defined(invoker.gles_language_version)) {
        gles_language_version = invoker.gles_language_version
      }
      deps = [ ":$impellerc_gles" ]
    }
  }

  gles_lib = "genlib_$target_name"
  shader_archive(gles_lib) {
    shaders = gles_shaders
    deps = [ ":$impellerc_gles" ]
  }

  reflect_gles = "reflect_$target_name"
  impellerc_reflect(reflect_gles) {
    impellerc_invocation = ":$impellerc_gles"
  }

  embed_gles_lib = "embed_$target_name"
  embed_blob(embed_gles_lib) {
    gles_library_files = get_target_outputs(":$gles_lib")
    symbol_name = shaders_base_name
    blob = gles_library_files[0]
    hdr = "$target_gen_dir/gles/$shaders_base_name.h"
    cc = "$target_gen_dir/gles/$shaders_base_name.cc"
    deps = [ ":$gles_lib" ]
  }

  group(target_name) {
    public_deps = [ ":$embed_gles_lib" ]

    if (invoker.analyze) {
      public_deps += [ ":$analyze_lib" ]
    }

    if (!impeller_enable_metal && !impeller_enable_vulkan) {
      public_deps += [ ":$reflect_gles" ]
    }
  }
}

template("_impeller_shaders_vk") {
  assert(defined(invoker.shaders), "Impeller shaders must be specified.")
  assert(defined(invoker.name), "Name of the shader library must be specified.")
  assert(defined(invoker.analyze), "Whether to analyze must be specified.")

  shaders_base_name = string_join("",
                                  [
                                    invoker.name,
                                    "_shaders_vk",
                                  ])
  impellerc_vk = "impellerc_$target_name"
  impellerc(impellerc_vk) {
    shaders = invoker.shaders
    sl_file_extension = "vkspv"

    # Metal reflectors generate a superset of information.
    if (impeller_enable_metal) {
      if (defined(invoker.metal_version)) {
        metal_version = invoker.metal_version
      }

      intermediates_subdir = "vk"
    }
    shader_target_flags = [ "--vulkan" ]

    defines = [ "IMPELLER_TARGET_VULKAN" ]
  }

  vk_shaders =
      filter_include(get_target_outputs(":$impellerc_vk"), [ "*.vkspv" ])

  if (invoker.analyze) {
    analyze_lib = "analyze_$target_name"
    malioc_analyze_shaders(analyze_lib) {
      shaders = vk_shaders
      if (defined(invoker.vulkan_language_version)) {
        vulkan_language_version = invoker.vulkan_language_version
      }
      deps = [ ":$impellerc_vk" ]
    }
  }

  vk_lib = "genlib_$target_name"
  shader_archive(vk_lib) {
    shaders = vk_shaders
    deps = [ ":$impellerc_vk" ]
  }

  reflect_vk = "reflect_$target_name"
  impellerc_reflect(reflect_vk) {
    impellerc_invocation = ":$impellerc_vk"
  }

  embed_vk_lib = "embed_$target_name"
  embed_blob(embed_vk_lib) {
    vk_library_files = get_target_outputs(":$vk_lib")
    symbol_name = shaders_base_name
    blob = vk_library_files[0]
    hdr = "$target_gen_dir/vk/$shaders_base_name.h"
    cc = "$target_gen_dir/vk/$shaders_base_name.cc"
    deps = [ ":$vk_lib" ]
  }

  group(target_name) {
    public_deps = [ ":$embed_vk_lib" ]

    if (invoker.analyze) {
      public_deps += [ ":$analyze_lib" ]
    }

    if (!impeller_enable_metal) {
      public_deps += [ ":$reflect_vk" ]
    }
  }
}

# ------------------------------------------------------------------------------
# @brief           A target for precompiled shaders and the associated
#                  generated reflection library.
#
# @param[required] name
#
#    The base name for the reflected C++ library.
#
# @param[required] shaders
#
#    A list of GLSL shader files.
#
# @param[optional] analyze
#
#    Whether to analyze shaders with malioc. Defaults to false. Shaders will
#    only be analyzed if the GN argument "impeller_malioc_path" is defined.
#
# @param[optional] enable_opengles
#
#    Whether to compile the shaders for the OpenGL ES backend. Defaults to the
#    value of the GN argument "impeller_enable_opengles".
#
# @param[optional] gles_language_version
#
#    The GLES version required by the shaders.
#
# @param[optional] metal_version
#
#    The version of the Metal API required by the shaders.
#
# @param[optional] vulkan_language_version
#
#    The SPIR-V version required by the shaders.
#
# @param[optional] use_half_textures
#
#    Whether the metal shader is using half-precision textures and requires
#    openGL semantics when compilig SPIR-V.
#
# @param[optional] require_framebuffer_fetch
#
#    Whether to require the framebuffer fetch extension for GLES fragment shaders.
template("impeller_shaders") {
  if (defined(invoker.metal_version)) {
    metal_version = invoker.metal_version
  }

  use_half_textures = false
  if (defined(invoker.use_half_textures) && invoker.use_half_textures) {
    use_half_textures = true
  }

  require_framebuffer_fetch = false
  if (defined(invoker.require_framebuffer_fetch) &&
      invoker.require_framebuffer_fetch) {
    require_framebuffer_fetch = true
  }

  not_needed([
               "metal_version",
               "use_half_textures",
               "require_framebuffer_fetch",
             ])

  enable_opengles = impeller_enable_opengles
  if (defined(invoker.enable_opengles)) {
    enable_opengles = invoker.enable_opengles
  }

  if (impeller_enable_metal) {
    if (!defined(metal_version)) {
      metal_version = "1.2"
    }
    not_needed(invoker, [ "analyze" ])
    mtl_shaders = "mtl_$target_name"
    _impeller_shaders_metal(mtl_shaders) {
      name = invoker.name
      shaders = invoker.shaders
      metal_version = metal_version
      use_half_textures = use_half_textures
    }
  }

  if (enable_opengles) {
    analyze = true
    if (defined(invoker.analyze) && !invoker.analyze) {
      analyze = false
    }
    gles_shaders = "gles_$target_name"
    _impeller_shaders_gles(gles_shaders) {
      name = invoker.name
      require_framebuffer_fetch = require_framebuffer_fetch
      if (defined(invoker.gles_language_version)) {
        gles_language_version = invoker.gles_language_version
      }
      if (defined(invoker.gles_exclusions)) {
        shaders = invoker.shaders - invoker.gles_exclusions
      } else {
        shaders = invoker.shaders
      }
      analyze = analyze
    }
  }

  if (impeller_enable_vulkan) {
    analyze = true
    if (defined(invoker.analyze) && !invoker.analyze) {
      analyze = false
    }
    vk_shaders = "vk_$target_name"
    _impeller_shaders_vk(vk_shaders) {
      name = invoker.name
      if (defined(invoker.vulkan_language_version)) {
        vulkan_language_version = invoker.vulkan_language_version
      }
      shaders = invoker.shaders
      analyze = analyze
    }
  }

  if (!impeller_supports_rendering) {
    not_needed(invoker, "*")
  }

  group(target_name) {
    public_deps = []
    if (impeller_enable_metal) {
      public_deps += [ ":$mtl_shaders" ]
    }

    if (enable_opengles) {
      public_deps += [ ":$gles_shaders" ]
    }

    if (impeller_enable_vulkan) {
      public_deps += [ ":$vk_shaders" ]
    }
  }
}

# Dispatches to the build or prebuilt scenec depending on the value of
# the impeller_use_prebuilt_scenec argument. Forwards all variables to
# compiled_action_foreach or action_foreach as appropriate.
template("_scenec") {
  if (impeller_use_prebuilt_scenec == "") {
    compiled_action_foreach(target_name) {
      forward_variables_from(invoker, "*")
      tool = "//flutter/impeller/scene/importer:scenec"
    }
  } else {
    action_foreach(target_name) {
      forward_variables_from(invoker, "*", [ "args" ])
      script = "//build/gn_run_binary.py"
      scenec_path = rebase_path(impeller_use_prebuilt_scenec, root_build_dir)
      args = [ scenec_path ] + invoker.args
    }
  }
}

template("scenec") {
  assert(defined(invoker.geometry), "Geometry input files must be specified.")
  assert(defined(invoker.type),
         "The type of geometry to be parsed (gltf, etc..).")

  _scenec(target_name) {
    sources = invoker.geometry
    generated_dir = "$target_gen_dir"

    input_type = invoker.type
    args = [
      "--input={{source}}",
      "--input-type=$input_type",
    ]

    output = "$generated_dir/{{source_file_part}}.ipscene"
    output_path = rebase_path(output, root_build_dir)

    args += [ "--output=$output_path" ]

    outputs = [ output ]
  }
}