kc3-lang/angle/BUILD.gn

Branch : - branch - main - tag -

• Show log

  Commit

• Author : Tobin Ehlis
  Date : 2019-03-15 17:02:17
  Hash : 134425c7
  Message : Vulkan:Integrate SecondaryCommandBuffers Integrate the custom SecondaryCommandBuffer type into the CommandGraph nodes by adding new ANGLE_USE_CUSTOM_VULKAN_CMD_BUFFERS define that can be set in the BUILD gn args with angle_enable_custom_vulkan_cmd_buffers set to "true." Initially the custom cmd buffers are disabled by default. This adds some support functions to SecondaryCommandBuffer to make the integration easier by matching the wrapped cmd buffer interface: initialize(), end(), valid(). Bug: angleproject:3136 Change-Id: Ib910554583192550757bb8ce89914e3ea8737988 Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/1526556 Commit-Queue: Tobin Ehlis <tobine@google.com> Reviewed-by: Jamie Madill <jmadill@chromium.org>

• BUILD.gn

• # Copyright 2019 The ANGLE Project 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 the use_x11 variable
  import("//build/config/dcheck_always_on.gni")
  import("//build/config/linux/pkg_config.gni")
  import("//build/config/ui.gni")
  import("//testing/libfuzzer/fuzzer_test.gni")
  import("gni/angle.gni")
  if (is_android) {
    # android/rules.gni can only be imported for Android targets
    import("//build/config/android/config.gni")
    import("//build/config/android/rules.gni")
    import("android/angle_apk.gni")
  }
  
  declare_args() {
    # Use the PCI lib to collect GPU information on Linux.
    use_libpci = is_linux && (!is_chromecast || is_cast_desktop_build) &&
                 (use_x11 || use_ozone)
  
    # Link in system libGL, to work with apitrace.  See doc/DebuggingTips.md.
    angle_link_glx = false
  }
  
  if (!build_with_chromium) {
    group("all") {
      testonly = true
      deps = [
        ":angle_shader_translator",
        ":translator_fuzzer",
        ":xxhash_fuzzer",
        "//samples:all",
        "//src/tests:all",
      ]
    }
  }
  
  if (ozone_platform_gbm) {
    pkg_config("libdrm") {
      packages = [ "libdrm" ]
    }
  }
  
  angle_git_is_present = exec_script("src/commit_id.py",
                                     [
                                       "check",
                                       rebase_path(".", root_build_dir),
                                     ],
                                     "value")
  
  angle_use_commit_id = angle_git_is_present == 1
  
  import("src/compiler.gni")
  import("src/libGLESv2.gni")
  
  # This config is exported to dependent targets (and also applied to internal
  # ones).
  config("external_config") {
    include_dirs = [ "include" ]
  }
  
  # Prevent the GL headers from redeclaring ANGLE entry points.
  config("no_gl_prototypes") {
    defines = [
      "GL_GLES_PROTOTYPES=0",
      "EGL_EGL_PROTOTYPES=0",
    ]
  }
  
  config("gl_prototypes") {
    defines = [
      "GL_GLES_PROTOTYPES=1",
      "EGL_EGL_PROTOTYPES=1",
      "GL_GLEXT_PROTOTYPES",
      "EGL_EGLEXT_PROTOTYPES",
    ]
  }
  
  # This config is applied to internal Angle targets (not pushed to dependents).
  config("internal_config") {
    include_dirs = [
      "include",
      "src",
    ]
  
    defines = []
  
    if (angle_64bit_current_cpu) {
      defines += [ "ANGLE_IS_64_BIT_CPU" ]
    } else {
      defines += [ "ANGLE_IS_32_BIT_CPU" ]
    }
  
    if (angle_force_thread_safety) {
      defines += [ "ANGLE_FORCE_THREAD_SAFETY=1" ]
    }
  
    if (angle_enable_vulkan) {
      if (angle_enable_vulkan_gpu_trace_events) {
        defines += [ "ANGLE_ENABLE_VULKAN_GPU_TRACE_EVENTS=1" ]
      }
      if (angle_vulkan_conformant_configs_only) {
        defines += [ "ANGLE_VULKAN_CONFORMANT_CONFIGS_ONLY=1" ]
      }
    }
  
    if (angle_enable_trace) {
      defines += [ "ANGLE_ENABLE_DEBUG_TRACE=1" ]
    }
  }
  
  config("extra_warnings") {
    cflags = []
  
    # Enable more default warnings on Windows.
    if (is_win) {
      cflags += [
        "/we4244",  # Conversion: possible loss of data.
        "/we4456",  # Variable shadowing.
        "/we4458",  # declaration hides class member.
        "/we4800",  # forcing value to bool.
        "/we4838",  # narrowing conversion.
      ]
    }
    if (is_clang) {
      if (!is_fuchsia) {
        cflags += [
          # Remove when crbug.com/926235 is resolved.
          "-Wextra-semi",
        ]
      }
  
      cflags += [
        # Enable after anglebug.com/3128 is fixed.
        # "-Wextra-semi-stmt",
  
        # Remove when crbug.com/428099 is resolved.
        "-Winconsistent-missing-override",
        "-Wnon-virtual-dtor",
        "-Wunneeded-internal-declaration",
      ]
    }
  }
  
  # This config adds build-ids to the associated library.
  # -Wl is a special option that indicates that clang should pass the associated
  # option --build-id to the linker. This will cause a build-id section to be added
  # to the associated library. The build-id makes it possible for a debugger to
  # find the right symbol file to use.
  config("build_id_config") {
    ldflags = [ "-Wl,--build-id" ]
  }
  
  # Windows ARM64 is available since 10.0.16299 so no need to copy
  # d3dcompiler_47.dll because this file is available as inbox.
  if (is_win && target_cpu != "arm64") {
    # We also ship an older DLL for compatiblity with Windows 7 machines without
    # the UCRT. This DLL isn't available in the standard SDK distribution.
    _old_compiler = "$windows_sdk_path/Redist/D3D/$target_cpu/d3dcompiler_old.dll"
    _has_old_compiler =
        exec_script("scripts/file_exists.py", [ _old_compiler ], "value")
  
    copy("copy_compiler_dll") {
      sources = [
        "$windows_sdk_path/Redist/D3D/$target_cpu/d3dcompiler_47.dll",
      ]
  
      if (_has_old_compiler) {
        sources += [ _old_compiler ]
      }
  
      outputs = [
        "$root_out_dir/{{source_file_part}}",
      ]
    }
  }
  
  # Holds the shared includes so we only need to list them once.
  config("includes_config") {
    include_dirs = [ "include" ]
  }
  
  angle_source_set("includes") {
    sources = libangle_includes
    public_configs = [ ":includes_config" ]
  }
  
  angle_static_library("preprocessor") {
    sources = angle_preprocessor_sources
  
    public_deps = [
      ":angle_common",
    ]
  }
  
  config("angle_disable_pool_alloc") {
    defines = [ "ANGLE_DISABLE_POOL_ALLOC" ]
  }
  
  config("debug_annotations_config") {
    if (is_debug) {
      defines = [ "ANGLE_ENABLE_DEBUG_ANNOTATIONS" ]
    }
  }
  
  config("angle_release_asserts_config") {
    if (dcheck_always_on) {
      defines = [ "ANGLE_ENABLE_RELEASE_ASSERTS" ]
    }
  }
  
  config("angle_common_config") {
    include_dirs = [ "src/common/third_party/base" ]
    if (is_android) {
      libs = [ "log" ]
    }
  }
  
  angle_source_set("angle_system_utils") {
    sources = angle_system_utils_sources
  }
  
  angle_source_set("xxhash") {
    sources = xxhash_sources
    configs -= [ "${angle_root}:extra_warnings" ]
  }
  
  fuzzer_test("xxhash_fuzzer") {
    sources = [
      "src/common/third_party/xxhash/xxhash_fuzzer.cpp",
    ]
    deps = [
      ":xxhash",
    ]
  }
  
  angle_static_library("angle_common") {
    sources = libangle_common_sources
  
    configs += [
      ":angle_common_config",
      ":debug_annotations_config",
    ]
  
    deps = [
      ":xxhash",
    ]
  
    public_deps = [
      ":angle_system_utils",
      ":angle_version",
      ":includes",
    ]
    public_configs += [ ":angle_common_config" ]
    all_dependent_configs = [ ":angle_release_asserts_config" ]
    if (use_fuzzing_engine) {
      all_dependent_configs += [ ":angle_disable_pool_alloc" ]
    }
  }
  
  config("angle_image_util_config") {
    include_dirs = [
      "include",
      "src",
    ]
  }
  
  angle_static_library("angle_image_util") {
    sources = libangle_image_util_sources
    public_configs += [ ":angle_image_util_config" ]
    public_deps = [
      ":angle_common",
    ]
  }
  
  config("angle_gl_visibility_config") {
    if (is_win) {
      defines = [
        "GL_APICALL=",
        "GL_API=",
      ]
    } else {
      defines = [
        "GL_APICALL=__attribute__((visibility(\"default\")))",
        "GL_API=__attribute__((visibility(\"default\")))",
      ]
    }
  }
  
  config("angle_gpu_info_util_config") {
    include_dirs = [
      "include",
      "src",
    ]
  }
  
  angle_static_library("angle_gpu_info_util") {
    public_configs += [ ":angle_gpu_info_util_config" ]
    public_deps = [
      ":angle_common",
    ]
    sources = libangle_gpu_info_util_sources
    deps = []
    libs = []
    defines = []
  
    if (is_android) {
      sources += [ "src/gpu_info_util/SystemInfo_android.cpp" ]
    }
  
    if (is_win) {
      sources += libangle_gpu_info_util_win_sources
      libs += [ "setupapi.lib" ]
      defines += [ "GPU_INFO_USE_SETUPAPI" ]
    }
  
    if (is_linux || is_fuchsia) {
      sources += libangle_gpu_info_util_linux_sources
  
      if (use_x11) {
        sources += libangle_gpu_info_util_x11_sources
        deps += [ "src/third_party/libXNVCtrl:libXNVCtrl" ]
        defines += [ "GPU_INFO_USE_X11" ]
        libs += [
          "X11",
          "Xi",
          "Xext",
        ]
      }
    }
  
    if (use_libpci) {
      sources += libangle_gpu_info_util_libpci_sources
      defines += [ "GPU_INFO_USE_LIBPCI" ]
      libs += [ "pci" ]
    }
  
    if (is_mac) {
      sources += libangle_gpu_info_util_mac_sources
      libs += [
        "IOKit.framework",
        "CoreFoundation.framework",
        "CoreGraphics.framework",
      ]
    }
  }
  
  angle_static_library("translator") {
    sources = angle_translator_sources
    defines = []
  
    if (angle_enable_essl || use_fuzzing_engine) {
      sources += angle_translator_essl_sources
      defines += [ "ANGLE_ENABLE_ESSL" ]
    }
  
    if (angle_enable_glsl || use_fuzzing_engine) {
      sources += angle_translator_glsl_sources
      defines += [ "ANGLE_ENABLE_GLSL" ]
    }
  
    if (angle_enable_hlsl || use_fuzzing_engine) {
      sources += angle_translator_hlsl_sources
      defines += [ "ANGLE_ENABLE_HLSL" ]
    }
  
    if (angle_enable_vulkan || use_fuzzing_engine) {
      sources += angle_translator_lib_vulkan_sources
      defines += [ "ANGLE_ENABLE_VULKAN" ]
    }
  
    public_configs += [ ":external_config" ]
  
    deps = [
      ":includes",
      ":preprocessor",
    ]
  
    public_deps = [
      ":angle_common",
    ]
  
    if (is_win) {
      # Necessary to suppress some system header xtree warnigns in Release.
      # For some reason this warning doesn't get triggered in Chromium
      cflags = [ "/wd4718" ]
    }
  }
  
  angle_source_set("translator_fuzzer") {
    sources = [
      "src/compiler/fuzz/translator_fuzzer.cpp",
    ]
  
    include_dirs = [
      "include",
      "src",
    ]
  
    deps = [
      ":translator",
    ]
  }
  
  config("commit_id_config") {
    include_dirs = [ "$root_gen_dir/angle" ]
    visibility = [ ":commit_id" ]
  }
  
  commit_id_output_file = "$root_gen_dir/angle/id/commit.h"
  if (angle_use_commit_id) {
    action("commit_id") {
      script = "src/commit_id.py"
      outputs = [
        commit_id_output_file,
      ]
  
      # commit id should depend on angle's HEAD revision
      inputs = [
        ".git/HEAD",
      ]
  
      args = [
        "gen",
        rebase_path(".", root_build_dir),
        rebase_path(commit_id_output_file, root_build_dir),
      ]
  
      public_configs = [ ":commit_id_config" ]
    }
  } else {
    copy("commit_id") {
      sources = [
        "src/commit.h",
      ]
      outputs = [
        commit_id_output_file,
      ]
      public_configs = [ ":commit_id_config" ]
    }
  }
  
  angle_source_set("angle_version") {
    sources = [
      "src/common/version.h",
    ]
    public_deps = [
      ":commit_id",
    ]
  }
  
  config("libANGLE_config") {
    cflags = []
    defines = []
    libs = []
    ldflags = []
    if (angle_enable_d3d9) {
      defines += [ "ANGLE_ENABLE_D3D9" ]
      ldflags += [ "/DELAYLOAD:d3d9.dll" ]
    }
    if (angle_enable_d3d11) {
      defines += [ "ANGLE_ENABLE_D3D11" ]
    }
    if (angle_enable_gl) {
      defines += [ "ANGLE_ENABLE_OPENGL" ]
      if (use_x11) {
        defines += [ "ANGLE_USE_X11" ]
      }
      if (angle_enable_gl_null) {
        defines += [ "ANGLE_ENABLE_OPENGL_NULL" ]
      }
    }
    if (angle_enable_vulkan) {
      defines += [ "ANGLE_ENABLE_VULKAN" ]
      if (angle_enable_custom_vulkan_cmd_buffers) {
        defines += [ "ANGLE_USE_CUSTOM_VULKAN_CMD_BUFFERS=1" ]
      }
    }
    if (angle_enable_null) {
      defines += [ "ANGLE_ENABLE_NULL" ]
    }
    defines += [ "LIBANGLE_IMPLEMENTATION" ]
  
    if (is_win) {
      cflags += [ "/wd4530" ]  # C++ exception handler used, but unwind semantics are not enabled.
    }
  
    if (is_android && (angle_enable_gl || angle_enable_vulkan)) {
      # In API level 26 ANativeWindow APIs were moved from libandroid.so
      # into a separate library, libnativewindow.so
      if (ndk_api_level_at_least_26) {
        libs += [ "nativewindow" ]
      } else {
        libs += [ "android" ]
      }
    }
  }
  
  if (angle_enable_vulkan) {
    config("vulkan_config") {
      if (is_android) {
        libs = [ "vulkan" ]
      }
    }
  
    # Use this target to include everything ANGLE needs for Vulkan.
    group("angle_vulkan") {
      public_deps = [
        "$angle_root/third_party/vulkan-headers:vulkan_headers",
      ]
      public_configs = [ ":vulkan_config" ]
      data_deps = []
      if (!is_android && !is_fuchsia) {
        deps = [
          "$angle_root/third_party/vulkan-loader:libvulkan",
        ]
        data_deps += [ "$angle_root/third_party/vulkan-tools:VkICD_mock_icd" ]
        public_configs +=
            [ "$angle_root/third_party/vulkan-loader:vulkan_loader_config" ]
      }
      if (is_fuchsia) {
        public_deps += [
          "$angle_root/src/common/fuchsia_egl",
          "//third_party/fuchsia-sdk:vulkan_base",
          "//third_party/fuchsia-sdk/sdk:vulkan",
        ]
      }
  
      if (angle_enable_vulkan_validation_layers) {
        if (is_fuchsia) {
          deps = [
            "//third_party/fuchsia-sdk:vulkan_validation",
          ]
        } else {
          data_deps += [ "$angle_root/third_party/vulkan-validation-layers:vulkan_validation_layers" ]
          if (!is_android) {
            data_deps += [ "$angle_root/third_party/vulkan-validation-layers:vulkan_gen_json_files" ]
          }
        }
      }
    }
  }
  
  angle_static_library("libANGLE") {
    sources = libangle_sources
  
    include_dirs = []
    libs = []
    defines = []
    if (angle_link_glx) {
      libs += [ "GL" ]
      defines += [ "ANGLE_LINK_GLX" ]
    }
    public_deps = [
      ":angle_common",
      ":angle_gpu_info_util",
      ":angle_version",
      ":translator",
    ]
    deps = [
      ":angle_image_util",
      ":includes",
    ]
  
    # Enable extra Chromium style warnings for libANGLE.
    if (is_clang) {
      suppressed_configs -= [ "//build/config/clang:find_bad_constructs" ]
    }
  
    # Shared D3D sources.
    if (angle_enable_d3d9 || angle_enable_d3d11) {
      sources += libangle_d3d_shared_sources
  
      defines += [ "ANGLE_PRELOADED_D3DCOMPILER_MODULE_NAMES={ " + "\"d3dcompiler_47.dll\", \"d3dcompiler_46.dll\", \"d3dcompiler_43.dll\" }" ]
    }
  
    if (angle_enable_d3d9) {
      sources += libangle_d3d9_sources
      libs += [ "d3d9.lib" ]
    }
  
    if (angle_enable_d3d11) {
      sources += libangle_d3d11_sources
      sources += libangle_d3d11_win32_sources
      libs += [ "dxguid.lib" ]
      import("src/libANGLE/renderer/d3d/d3d11/d3d11_blit_shaders_autogen.gni")
      sources += libangle_d3d11_blit_shaders
    }
  
    if (angle_enable_gl) {
      sources += libangle_gl_sources
      include_dirs += [ "src/third_party/khronos" ]
  
      if (angle_enable_gl_null) {
        sources += libangle_gl_null_sources
      }
      if (is_win) {
        sources += libangle_gl_wgl_sources
      }
      if (use_x11) {
        sources += libangle_gl_glx_sources
        deps += [ "src/third_party/libXNVCtrl:libXNVCtrl" ]
        libs += [
          "X11",
          "Xi",
          "Xext",
        ]
      }
      if (is_mac) {
        sources += libangle_gl_cgl_sources
        libs += [
          "Cocoa.framework",
          "IOSurface.framework",
          "OpenGL.framework",
          "QuartzCore.framework",
        ]
      }
      if (is_android) {
        sources += libangle_gl_egl_sources
        sources += libangle_gl_egl_dl_sources
        sources += libangle_gl_egl_android_sources
      }
      if (ozone_platform_gbm) {
        configs += [ ":libdrm" ]
        defines += [ "ANGLE_USE_OZONE" ]
        deps += [ "//third_party/minigbm" ]
        sources += libangle_gl_egl_sources
        sources += libangle_gl_egl_dl_sources
        sources += libangle_gl_ozone_sources
      }
    }
  
    if (angle_enable_vulkan) {
      sources += libangle_vulkan_sources
      if (is_win) {
        sources += libangle_vulkan_win32_sources
      }
      if (is_linux) {
        sources += libangle_vulkan_xcb_sources
      }
      if (is_fuchsia) {
        sources += libangle_vulkan_fuchsia_sources
        deps += [
          "$angle_root/src/common/fuchsia_egl",
          "$angle_root/src/common/fuchsia_egl:backend",
        ]
      }
      if (is_android) {
        sources += libangle_vulkan_android_sources
        libs += [ "vulkan" ]
      }
      deps += [
        ":angle_vulkan",
        "${angle_glslang_dir}:glslang_default_resource_limits_sources",
        "${angle_glslang_dir}:glslang_sources",
        "${angle_spirv_tools_dir}:spvtools_val",
      ]
      public_deps += [ "$angle_root/third_party/vulkan-headers:vulkan_headers" ]
  
      # Include generated shaders.
      import("src/libANGLE/renderer/vulkan/vk_internal_shaders_autogen.gni")
      sources += angle_vulkan_internal_shaders
    }
  
    if (angle_enable_null) {
      sources += libangle_null_sources
    }
  
    if (is_debug) {
      defines += [ "ANGLE_GENERATE_SHADER_DEBUG_INFO" ]
    }
  
    configs += [ ":debug_annotations_config" ]
    public_configs += [ ":libANGLE_config" ]
  
    # Windows ARM64 is available since 10.0.16299 so no need to copy
    # d3dcompiler_47.dll because this file is available as inbox.
    if (is_win && target_cpu != "arm64") {
      data_deps = [
        ":copy_compiler_dll",
      ]
    }
  }
  
  config("shared_library_public_config") {
    if (is_mac && !is_component_build) {
      # Executable targets that depend on the shared libraries below need to have
      # the rpath setup in non-component build configurations.
      ldflags = [
        "-rpath",
        "@executable_path/",
      ]
    }
  }
  
  config("library_name_config") {
    defines = [
      "ANGLE_EGL_LIBRARY_NAME=\"libEGL${angle_libs_suffix}\"",
      "ANGLE_GLESV2_LIBRARY_NAME=\"libGLESv2${angle_libs_suffix}\"",
    ]
  }
  
  # This config controls export definitions on ANGLE API calls.
  config("angle_static") {
    defines = [
      "ANGLE_EXPORT=",
      "ANGLE_UTIL_EXPORT=",
      "EGLAPI=",
      "GL_APICALL=",
      "GL_API=",
    ]
  }
  
  angle_shared_library("libGLESv2${angle_libs_suffix}") {
    sources = libglesv2_sources
  
    if (is_win) {
      sources += [ "src/libGLESv2/libGLESv2_autogen.def" ]
    }
  
    configs += [
      ":angle_gl_visibility_config",
      ":debug_annotations_config",
      ":gl_prototypes",
    ]
  
    defines = [ "LIBGLESV2_IMPLEMENTATION" ]
  
    deps = [
      ":includes",
      ":libANGLE",
    ]
  
    public_deps = [
      ":angle_version",
    ]
  }
  
  angle_static_library("libGLESv2_static") {
    sources = libglesv2_sources
    configs += [ ":debug_annotations_config" ]
    public_configs += [ ":angle_static" ]
    deps = [
      ":includes",
    ]
    public_deps = [
      ":libANGLE",
    ]
  }
  
  angle_shared_library("libGLESv1_CM${angle_libs_suffix}") {
    sources = libglesv1_cm_sources
  
    configs += [
      ":angle_gl_visibility_config",
      ":debug_annotations_config",
      ":gl_prototypes",
    ]
  
    defines = []
  
    deps = [
      ":includes",
      ":libGLESv2${angle_libs_suffix}",
    ]
  }
  
  angle_static_library("libGLESv1_CM_static") {
    sources = libglesv1_cm_sources
    configs += [ ":debug_annotations_config" ]
    public_configs += [ ":angle_static" ]
    deps = [
      ":includes",
      ":libGLESv2_static",
    ]
  }
  
  config("libEGL_egl_loader_config") {
    defines = [ "ANGLE_USE_EGL_LOADER" ]
  }
  
  angle_source_set("libEGL_egl_loader") {
    sources = [
      "src/libEGL/egl_loader_autogen.cpp",
      "src/libEGL/egl_loader_autogen.h",
    ]
  
    public_configs += [
      ":libEGL_egl_loader_config",
      ":gl_prototypes",
    ]
  
    deps = [
      ":includes",
    ]
  }
  
  angle_shared_library("libEGL${angle_libs_suffix}") {
    sources = libegl_sources
  
    configs += [
      ":debug_annotations_config",
      ":library_name_config",
    ]
  
    defines = [ "LIBEGL_IMPLEMENTATION" ]
    if (is_win) {
      defines += [ "EGLAPI=" ]
    } else {
      defines += [ "EGLAPI=__attribute__((visibility(\"default\")))" ]
    }
  
    if (is_win) {
      sources += [ "src/libEGL/libEGL.def" ]
    }
  
    deps = [
      ":angle_system_utils",
      ":angle_version",
      ":libEGL_egl_loader",
    ]
  
    public_deps = [
      ":includes",
    ]
  
    data_deps = [
      ":libGLESv2${angle_libs_suffix}",
    ]
  }
  
  angle_static_library("libEGL_static") {
    sources = libegl_sources
  
    configs += [
      ":debug_annotations_config",
      ":library_name_config",
    ]
  
    public_configs += [ ":angle_static" ]
  
    deps = [
      ":includes",
      ":libGLESv2_static",
    ]
  }
  
  import("util/util.gni")
  
  config("angle_util_loader_config") {
    defines = [ "ANGLE_USE_UTIL_LOADER" ]
  }
  
  angle_source_set("angle_util_loader_headers") {
    sources = [
      "util/egl_loader_autogen.h",
      "util/gles_loader_autogen.h",
      "util/util_export.h",
    ]
  
    if (is_win) {
      sources += [ "util/windows/wgl_loader_autogen.h" ]
    }
  
    public_deps = [
      ":includes",
    ]
  }
  
  angle_source_set("angle_util_loader") {
    defines = [ "LIBANGLE_UTIL_IMPLEMENTATION" ]
  
    sources = [
      "util/egl_loader_autogen.cpp",
      "util/gles_loader_autogen.cpp",
    ]
  
    if (is_win) {
      sources += [ "util/windows/wgl_loader_autogen.cpp" ]
    }
  
    deps = [
      ":angle_util_loader_headers",
    ]
  
    public_configs += [
      ":angle_util_config",
      ":angle_util_loader_config",
      ":no_gl_prototypes",
    ]
  }
  
  config("angle_util_config") {
    include_dirs = [ "." ]
    if (is_linux && use_x11) {
      libs = [ "X11" ]
    }
  }
  
  foreach(is_shared_library,
          [
            true,
            false,
          ]) {
    if (is_shared_library) {
      library_type = "angle_shared_library"
      library_name = "angle_util"
      dep_suffix = "${angle_libs_suffix}"
    } else {
      library_type = "angle_static_library"
      library_name = "angle_util_static"
      dep_suffix = "_static"
    }
  
    target(library_type, library_name) {
      sources = util_sources
  
      if (is_win) {
        sources += util_win_sources
      }
  
      libs = []
      if (is_linux) {
        sources += util_linux_sources
        libs += [
          "rt",
          "dl",
        ]
      }
  
      if (is_mac) {
        sources += util_osx_sources
        libs += [
          "AppKit.framework",
          "QuartzCore.framework",
        ]
      }
  
      if (use_x11) {
        sources += util_x11_sources
      }
  
      if (is_android) {
        # To prevent linux sources filtering on android
        set_sources_assignment_filter([])
        sources += util_linux_sources
        sources += util_android_sources
        libs += [
          "android",
          "log",
        ]
      }
  
      configs += [ ":debug_annotations_config" ]
  
      public_configs += [ ":angle_util_config" ]
  
      deps = [
        ":angle_common",
        ":angle_util_loader_headers",
      ]
  
      public_deps = []
      if (is_fuchsia) {
        sources += util_fuchsia_sources
        public_deps += [
          "$angle_root/src/common/fuchsia_egl",
          "//third_party/fuchsia-sdk/sdk:async_loop_cpp",
          "//third_party/fuchsia-sdk/sdk:fdio",
          "//third_party/fuchsia-sdk/sdk:images",
          "//third_party/fuchsia-sdk/sdk:scenic_cpp",
          "//third_party/fuchsia-sdk/sdk:ui_gfx",
          "//third_party/fuchsia-sdk/sdk:ui_policy",
          "//third_party/fuchsia-sdk/sdk:ui_scenic",
          "//third_party/fuchsia-sdk/sdk:ui_viewsv1",
        ]
      } else if (use_ozone) {
        sources += util_ozone_sources
      }
  
      if (is_shared_library) {
        defines = [ "LIBANGLE_UTIL_IMPLEMENTATION" ]
  
        if (is_win) {
          sources += util_win_shared_sources
        }
  
        public_deps += [ ":angle_util_loader" ]
  
        if (is_mac && !is_component_build) {
          ldflags = [
            "-install_name",
            "@rpath/libangle_util.dylib",
          ]
        }
      } else {
        public_configs += [
          ":angle_static",
          ":gl_prototypes",
        ]
      }
    }
  }
  
  # Convenience targets for some of the samples so they can be built
  # with Chromium's toolchain.
  
  angle_executable("angle_shader_translator") {
    testonly = true
  
    sources = [
      "samples/shader_translator/shader_translator.cpp",
    ]
  
    deps = [
      ":translator",
    ]
  }
  
  config("angle_feature_support_config") {
    include_dirs = [
      "include",
      "src",
    ]
    defines = [ "LIBFEATURE_SUPPORT_IMPLEMENTATION" ]
    if (is_debug) {
      defines += [ "ANGLE_FEATURE_UTIL_LOG_VERBOSE" ]
    }
  }
  
  angle_shared_library("libfeature_support${angle_libs_suffix}") {
    if (is_android) {
      libs = [ "log" ]
    }
  
    public_configs += [
      ":angle_feature_support_config",
      "${angle_jsoncpp_dir}:jsoncpp_config",
    ]
  
    if (is_mac && !is_component_build) {
      ldflags = [
        "-install_name",
        "@rpath/${target_name}.dylib",
      ]
    }
  
    sources = [
      "src/feature_support_util/feature_support_util.cpp",
      "src/feature_support_util/feature_support_util.h",
    ]
  
    deps = [
      ":angle_gpu_info_util",
      "${angle_jsoncpp_dir}:jsoncpp",
    ]
  }
  
  if (!is_component_build && is_android && symbol_level != 0) {
    action_foreach("compressed_symbols") {
      sources = []
      foreach(_library, angle_libraries) {
        sources += [ "${root_out_dir}/lib${_library}${angle_libs_suffix}.so" ]
      }
      if (angle_enable_vulkan_validation_layers) {
        foreach(_layer, vulkan_validation_layers) {
          sources += [ "${root_out_dir}/lib${_layer}.so" ]
        }
      }
  
      script = rebase_path("${root_build_dir}/android/compress_symbols.py",
                           root_build_dir)
  
      deps = []
      foreach(_library, angle_libraries) {
        deps += [ "${angle_root}:lib${_library}${angle_libs_suffix}" ]
      }
  
      if (angle_enable_vulkan_validation_layers) {
        foreach(_layer, vulkan_validation_layers) {
          deps +=
              [ "${angle_root}/third_party/vulkan-validation-layers:${_layer}" ]
        }
      }
  
      outputs = [
        "$root_out_dir/lib.compressed/{{source_file_part}}",
      ]
  
      android_nm = "${android_tool_prefix}nm"
  
      args = [
        "--objcopy",
        rebase_path(android_objcopy, root_build_dir),
        "--nm",
        rebase_path(android_nm, root_build_dir),
        "--sofile",
        "{{source}}",
        "--unstrippedsofile",
        "{{source_dir}}/lib.unstripped/{{source_file_part}}",
        "--output",
        "{{source_dir}}/lib.compressed/{{source_file_part}}",
      ]
    }
  }
  
  if (!is_component_build && is_android &&
      current_toolchain == default_toolchain) {
    # Package ANGLE libraries for pre-installed system image
    angle_apk("aosp_apk") {
      package_name = "com.android.angle"
      apk_name = "AngleLibraries"
    }
  
    group("angle_apks") {
      deps = [
        ":aosp_apk",
      ]
    }
  
    # Include a temporary target until we update builders to use angle_apks
    group("angle_apk") {
      deps = [
        ":angle_apks",
      ]
    }
  }