| # 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/impeller/tools/args.gni") | |
| # 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 (!defined(invoker.mnemonic)) { | |
| mnemonic = "IMPELLERC" | |
| } | |
| if (invoker.single_invocation) { | |
| compiled_action(target_name) { | |
| forward_variables_from(invoker, "*") | |
| tool = "//flutter/impeller/compiler:impellerc" | |
| } | |
| } else { | |
| compiled_action_foreach(target_name) { | |
| forward_variables_from(invoker, "*") | |
| tool = "//flutter/impeller/compiler:impellerc" | |
| } | |
| } | |
| } | |
| # 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 | |
| # --runtime-stage-gles3 | |
| # --runtime-stage-vulkan | |
| # Not required for --shader_bundle mode. | |
| # 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) || defined(invoker.shader_bundle), | |
| "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_bundle_output must also be specified.") | |
| } | |
| if (defined(invoker.shader_target_flags)) { | |
| shader_target_flags = invoker.shader_target_flags | |
| } else { | |
| shader_target_flags = [] | |
| } | |
| 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", | |
| "shader_bundle", | |
| "shader_bundle_output", | |
| ]) | |
| _impellerc(target_name) { | |
| forward_variables_from(invoker, [ "mnemonic" ]) | |
| pool = "//build/toolchain:toolchain_pool" | |
| 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_lib_dir = | |
| rebase_path("//flutter/impeller/compiler/shader_lib", root_build_dir) | |
| 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.shader_target_flag)) { | |
| args += [ "${invoker.shader_target_flag}" ] | |
| } | |
| } | |
| 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 (defined(invoker.entry_point_prefix)) { | |
| args += [ "--entry-point-prefix=${invoker.entry_point_prefix}" ] | |
| } | |
| 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 { | |
| 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 ] | |
| # Generate reflection state only if a non-runtime target is provided. | |
| if (filter_include(shader_target_flags, | |
| [ | |
| "--metal-ios", | |
| "--metal-desktop", | |
| "--opengl-es", | |
| "--opengl-desktop", | |
| "--vulkan", | |
| ]) != []) { | |
| 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" | |
| 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 += [ | |
| "--reflection-json=$reflection_json_path", | |
| "--reflection-header=$reflection_header_path", | |
| "--reflection-cc=$reflection_cc_path", | |
| ] | |
| outputs += [ | |
| 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, | |
| ] | |
| } | |
| } |