# 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 ozone_platform_x11 variable

import("gni/angle.gni")

if (angle_enable_vulkan) {

import("//build_overrides//vulkan_headers.gni")

}

if (angle_use_wayland) {

import("//build_overrides/wayland.gni")

}

if (angle_enable_wgpu) {

import("//build_overrides/dawn.gni")

import("//build_overrides/tint.gni")

}

if (angle_has_build) {

import("//build/config/linux/pkg_config.gni")

import("//build/config/sanitizers/sanitizers.gni")

import("//build/config/ui.gni")

import("//testing/libfuzzer/fuzzer_test.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")

}

} else {

using_sanitizer = false

}

declare_args() {

# Use the PCI lib to collect GPU information on Linux.

use_libpci = (is_linux || is_chromeos) && (angle_use_x11 || use_ozone) &&

angle_has_build

# Enable using Vulkan to collect system info as a fallback.

angle_enable_vulkan_system_info = false

# Link in system libGL, to work with apitrace. See doc/DebuggingTips.md.

angle_link_glx = false

# Don't build extra (test, samples etc) for Windows UWP. We don't have

# infrastructure (e.g. windowing helper functions) in place to run them.

# Also don't build them with MSVC, because tests and unused dependencies

# often have problems building with it, e.g. for C++20.

angle_build_all = !build_with_chromium && !angle_is_winuwp &&

!angle_is_msvc && angle_has_build && angle_build_tests

# Enable generating current commit information using git

angle_enable_commit_id = true

# Abseil has trouble supporting MSVC, particularly regarding component builds.

# http://crbug.com/1126524

angle_enable_abseil = angle_has_build && is_clang

# Adds run-time checks to filter out EVENT() messages when the debug annotator is disabled.

angle_enable_annotator_run_time_checks = false

# Enables non-conformant extensions and features

angle_expose_non_conformant_extensions_and_versions = false

# Optional feature that forces dirty state whenever we use a new context regardless of thread.

angle_force_context_check_every_call = false

# Allow shared library custom name extensions for setting soname such as libEGL.so.1

angle_egl_extension = ""

angle_glesv2_extension = ""

# Enable share context lock. If it is false, the client need to use gl calls in a threadsafe way.

angle_enable_share_context_lock =

!build_with_chromium || build_angle_deqp_tests

if (is_android) {

# Use Android TLS slot to store current context.

angle_use_android_tls_slot = !build_with_chromium

}

angle_enable_global_mutex_recursion =

is_android && angle_enable_vulkan && !build_with_chromium

# Potentially can be enabled for other platforms, but limiting to Android platform for now.

# Chromium may have problems (requires verification), disabled for safety.

angle_enable_global_mutex_load_time_allocate =

is_android && !build_with_chromium

angle_enable_context_mutex = true

# Prefix where the artifacts should be installed on the system

install_prefix = ""

}

declare_args() {

# May need to enable to fix recursion when vkAcquireNextImageKHR() returns back to ANGLE from

# eglClientWaitSyncKHR(). May happen if Android Presentation Engine uses

# EGL_KHR_fence_sync instead of EGL_ANDROID_native_fence_sync for synchronization.

# To check call: adb shell "dumpsys SurfaceFlinger | grep 'Sync configuration'"

# The Android's "testDrawingHardwareBitmapNotLeaking" test may be used for testing.

# Disable this option to save performance on platforms that does not require recursion.

angle_enable_context_mutex_recursion = angle_enable_global_mutex_recursion

}

if (angle_build_all) {

group("all") {

testonly = true

deps = [

":angle",

":angle_shader_translator",

":translator_fuzzer",

":xxhash_fuzzer",

"$angle_root/samples:angle_samples",

"$angle_root/src/tests:angle_tests",

]

if (angle_enable_cl) {

deps += [ "$angle_root/src/libOpenCL:angle_cl" ]

}

if (angle_enable_cl_testing) {

deps += [ "$angle_root/third_party/OpenCL-CTS/:opencl_cts" ]

}

if (angle_enable_cl && angle_enable_vulkan) {

# OpenCL through Vulkan in ANGLE requires clspv for online compiler

deps += [ "$angle_clspv_dir:clspv" ]

}

if (angle_build_mesa) {

deps += [ "$angle_root/third_party/mesa" ]

}

}

}

import("src/angle_program_serialize_data_version.gni")

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 (is_win) {

defines += [ "ANGLE_IS_WIN" ]

if (angle_is_winuwp) {

defines += [ "ANGLE_IS_WINUWP" ]

}

if (angle_is_winappsdk) {

defines += [ "ANGLE_IS_WINAPPSDK" ]

}

} else if (is_linux || is_chromeos) {

defines += [ "ANGLE_IS_LINUX" ]

}

if (angle_enable_share_context_lock) {

defines += [ "ANGLE_ENABLE_SHARE_CONTEXT_LOCK=1" ]

}

if (is_android) {

if (angle_use_android_tls_slot) {

defines += [ "ANGLE_USE_ANDROID_TLS_SLOT=1" ]

}

}

if (angle_enable_global_mutex_recursion) {

defines += [ "ANGLE_ENABLE_GLOBAL_MUTEX_RECURSION=1" ]

}

if (angle_enable_global_mutex_load_time_allocate) {

defines += [ "ANGLE_ENABLE_GLOBAL_MUTEX_LOAD_TIME_ALLOCATE=1" ]

}

if (angle_enable_context_mutex && angle_enable_share_context_lock &&

!angle_force_context_check_every_call) {

defines += [ "ANGLE_ENABLE_CONTEXT_MUTEX=1" ]

}

if (angle_enable_context_mutex_recursion) {

defines += [ "ANGLE_ENABLE_CONTEXT_MUTEX_RECURSION=1" ]

}

# Enables debug/trace-related functionality, including logging every GLES/EGL API command to the

# "angle_debug.txt" file on desktop. Enables debug markers for AGI, but must also set

# angle_enable_annotator_run_time_checks to improve performance.

if (angle_enable_trace) {

defines += [ "ANGLE_ENABLE_DEBUG_TRACE=1" ]

}

# When used with angle_enable_trace, enables logging every GLES/EGL API command to Android logcat

# Enables debug markers for AGI regardless of run-time checks.

if (angle_enable_trace_android_logcat) {

defines += [ "ANGLE_ENABLE_TRACE_ANDROID_LOGCAT=1" ]

}

# When used with angle_enable_trace, enables logging every GLES/EGL API command to the terminal

if (angle_enable_trace_events) {

defines += [ "ANGLE_ENABLE_TRACE_EVENTS=1" ]

}

# Output `INFO`-level logs and up.

if (angle_always_log_info) {

defines += [ "ANGLE_ALWAYS_LOG_INFO" ]

}

# Enables pipeline cache graph dump functionality.

# The dump path must have appropriate permissions for this to work.

if (angle_dump_pipeline_cache_graph) {

defines += [ "ANGLE_DUMP_PIPELINE_CACHE_GRAPH=1" ]

}

# Checks that unwind backtrace support for Android is enabled only for debug mode.

assert(is_debug || !angle_enable_unwind_backtrace_support)

if (is_chromeos) {

defines += [ "ANGLE_PLATFORM_CHROMEOS" ]

}

if (is_ggp) {

defines += [ "__ggp__" ]

}

if (angle_use_vulkan_null_display) {

defines += [ "ANGLE_USE_VULKAN_NULL_DISPLAY" ]

} else if (angle_use_vulkan_display) {

defines += [ "ANGLE_USE_VULKAN_DISPLAY" ]

if (!angle_use_x11) {

defines += [ "EGL_NO_X11" ]

}

# These two are needed here to correctly select OSWindow::New

if (angle_use_x11) {

defines += [ "ANGLE_USE_X11" ]

}

if (angle_use_wayland) {

defines += [ "ANGLE_USE_WAYLAND" ]

}

if (angle_vulkan_display_mode == "simple") {

defines += [ "ANGLE_VULKAN_DISPLAY_MODE_SIMPLE" ]

} else if (angle_vulkan_display_mode == "headless") {

defines += [ "ANGLE_VULKAN_DISPLAY_MODE_HEADLESS" ]

} else if (angle_vulkan_display_mode == "offscreen") {

defines += [ "ANGLE_VULKAN_DISPLAY_MODE_OFFSCREEN" ]

} else {

assert(false)

}

}

if (is_lsan) {

defines += [ "ANGLE_WITH_LSAN" ]

}

if (angle_has_astc_encoder) {

defines += [ "ANGLE_HAS_ASTCENC" ]

}

if (angle_test_enable_system_egl) {

defines += [ "ANGLE_TEST_ENABLE_SYSTEM_EGL" ]

}

if (angle_debug_layers_enabled) {

defines += [ "ANGLE_DEBUG_LAYERS_ENABLED" ]

}

if (angle_build_mesa) {

defines += [ "ANGLE_HAS_MESA" ]

}

if (angle_standalone || build_with_chromium) {

defines += [ "ANGLE_OUTSIDE_WEBKIT" ]

}

if (is_win && build_with_chromium) {

defines += [ "ANGLE_WINDOWS_NO_FUTEX=1" ]

}

}

config("constructor_and_destructor_warnings") {

if (is_clang) {

cflags = [

"-Wexit-time-destructors",

"-Wglobal-constructors",

]

}

}

config("extra_warnings") {

cflags = []

is_gcc = !is_clang && !is_win

# Avoid failing builds for warnings enabled by Skia build.

if (defined(is_skia_standalone)) {

cflags += [ "-w" ]

}

# Enable more default warnings on Windows.

if (is_win) {

cflags += [

"/we4244", # Conversion: possible loss of data.

"/we4312", # Conversion: greater size.

"/we4456", # Variable shadowing.

"/we4458", # declaration hides class member.

"/we4715", # not all control paths return a value

"/we4800", # forcing value to bool.

"/we4838", # narrowing conversion.

]

}

if (is_clang) {

cflags += [

"-Wbad-function-cast",

"-Wconditional-uninitialized",

"-Wextra-semi-stmt",

"-Wfloat-conversion",

"-Winconsistent-missing-destructor-override",

"-Wmissing-field-initializers",

"-Wnewline-eof",

"-Wnon-virtual-dtor",

"-Wredundant-parens",

"-Wreturn-std-move",

"-Wshadow",

"-Wshadow-field",

"-Wtautological-type-limit-compare",

"-Wundefined-reinterpret-cast",

"-Wunneeded-internal-declaration",

"-Wunused-but-set-variable",

"-Wsuggest-destructor-override",

"-Wsuggest-override",

# The below warnings are used by WebKit. We enable them to make rolling

# ANGLE in WebKit easier.

"-Wparentheses",

"-Wrange-loop-analysis",

"-Wstrict-prototypes",

"-Wunreachable-code-aggressive",

"-Wshorten-64-to-32",

]

}

if (is_gcc) {

cflags_cc = [ "-Wdeprecated-copy" ]

}

if (angle_is_winuwp) {

cflags += [

"/wd4091", # keyword ignored on left of type when no variable is declared

"/wd4447", # 'main' signature found without threading model.

]

}

}

# 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" ]

}

_use_copy_compiler_dll = angle_has_build && is_win

if (_use_copy_compiler_dll) {

copy("copy_compiler_dll") {

sources = [ "$windows_sdk_path/Redist/D3D/$target_cpu/d3dcompiler_47.dll" ]

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" ]

}

config("angle_uwp_env") {

if (angle_is_winuwp && !angle_is_winappsdk) {

defines = [ "WINAPI_FAMILY=WINAPI_FAMILY_PC_APP" ]

}

}

angle_source_set("cl_includes") {

sources = cl_includes

public_configs = [ ":external_config" ]

}

angle_source_set("includes") {

sources = libangle_includes

public_configs = [ ":includes_config" ]

if (angle_enable_cl) {

public_deps = [ ":cl_includes" ]

}

}

config("disable_unreachable_code_break_warning") {

if (is_clang) {

cflags = [ "-Wno-unreachable-code-break" ]

}

}

angle_static_library("preprocessor") {

sources = angle_preprocessor_sources

# preprocessor_tab_autogen.cpp contains an instance of this.

configs += [ ":disable_unreachable_code_break_warning" ]

public_deps = [

":angle_common",

":angle_translator_headers",

]

}

config("angle_disable_pool_alloc") {

defines = [ "ANGLE_DISABLE_POOL_ALLOC" ]

}

config("debug_annotations_config") {

defines = []

if (is_debug) {

defines += [ "ANGLE_ENABLE_DEBUG_ANNOTATIONS" ]

}

if (angle_enable_annotator_run_time_checks) {

# When used with angle_enable_trace, enables debug markers for AGI with run-time checks to

# filter out EVENT() messages when the debug annotator is disabled.

defines += [ "ANGLE_ENABLE_ANNOTATOR_RUN_TIME_CHECKS" ]

}

}

config("angle_asserts_config") {

if (angle_assert_always_on) {

defines = [ "ANGLE_ASSERT_ALWAYS_ON" ]

}

}

config("angle_common_config") {

include_dirs = [

"src/common/base",

"src/common/third_party/xxhash",

]

libs = []

if (is_android) {

libs += [ "log" ]

}

if (is_win && !angle_is_winuwp && !build_with_chromium) {

# Needed for futex support

libs += [ "synchronization.lib" ]

}

defines = []

if (angle_delegate_workers) {

defines += [ "ANGLE_DELEGATE_WORKERS=1" ]

}

}

# Silences the "indirect call of a function with wrong dynamic type" cfi error

config("angle_no_cfi_icall") {

if (is_cfi && use_cfi_icall && current_toolchain == default_toolchain) {

cflags = [ "-fno-sanitize=cfi-icall" ]

}

}

# Silences the "cast from void* or another unrelated type to the wrong dynamic type" cfi error

config("angle_no_cfi_unrelated_cast") {

if (is_cfi && use_cfi_cast && current_toolchain == default_toolchain) {

cflags = [ "-fno-sanitize=cfi-unrelated-cast" ]

}

}

angle_source_set("xxhash") {

sources = xxhash_sources

if (is_clang) {

cflags_c = [ "-Wno-implicit-fallthrough" ]

}

}

if (angle_has_build) {

fuzzer_test("xxhash_fuzzer") {

sources = [ "src/common/third_party/xxhash/xxhash_fuzzer.cpp" ]

deps = [ ":xxhash" ]

}

}

template("angle_common_lib") {

angle_static_library(target_name) {

sources = invoker.sources

configs += [

":angle_common_config",

":debug_annotations_config",

]

deps = [ ":xxhash" ]

public_deps = [

":angle_abseil",

":includes",

]

public_configs += [ ":angle_common_config" ]

if (angle_has_build && use_fuzzing_engine) {

all_dependent_configs = [ ":angle_disable_pool_alloc" ]

}

if (is_linux || is_chromeos) {

libs = [ "dl" ]

}

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_expose_non_conformant_extensions_and_versions) {

defines = [ "ANGLE_EXPOSE_NON_CONFORMANT_EXTENSIONS_AND_VERSIONS" ]

}

if (using_sanitizer && !build_with_chromium) {

data_deps =

[ "//build/config/clang:llvm-symbolizer_data($host_toolchain)" ]

}

if (is_apple) {

frameworks = [ "Metal.framework" ]

}

}

}

angle_common_lib("angle_common") {

sources = libangle_common_sources

if (angle_enable_cl) {

sources += libangle_common_cl_sources

}

}

angle_common_lib("angle_common_shader_state") {

sources = libangle_common_shader_state_sources

}

angle_source_set("angle_capture_common") {

sources = [

"src/common/frame_capture_utils.cpp",

"src/common/frame_capture_utils.h",

"src/common/frame_capture_utils_autogen.cpp",

"src/common/frame_capture_utils_autogen.h",

]

deps = [ ":angle_common" ]

public_deps = [ ":angle_gl_enum_utils" ]

}

config("angle_image_util_config") {

include_dirs = [

"include",

"src",

]

}

angle_source_set("angle_image_util_headers") {

sources = libangle_image_util_headers

public_deps = [ ":angle_common" ]

}

angle_static_library("angle_image_util") {

sources = libangle_image_util_sources

public_configs += [ ":angle_image_util_config" ]

public_deps = [ ":angle_image_util_headers" ]

if (angle_has_astc_encoder) {

public_deps += [ "third_party/astc-encoder:astcenc" ]

include_dirs = [ "third_party/astc-encoder/src/Source/" ]

}

}

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_vulkan_wayland_config") {

if (angle_enable_vulkan && angle_use_wayland &&

defined(vulkan_wayland_include_dirs)) {

include_dirs = vulkan_wayland_include_dirs

}

}

config("angle_gpu_info_util_config") {

include_dirs = [

"include",

"src",

]

}

angle_static_library("angle_gpu_info_util") {

public_configs += [

":angle_gpu_info_util_config",

":angle_backend_config",

]

public_deps = [ ":angle_common" ]

sources = libangle_gpu_info_util_sources

deps = []

libs = []

defines = []

if (angle_build_vulkan_system_info) {

sources += libangle_gpu_info_util_vulkan_sources

deps += [

"$angle_vulkan_headers_dir:vulkan_headers",

"src/common/vulkan:angle_libvulkan_loader",

"src/common/vulkan:angle_vulkan_icd",

]

configs += [ "$angle_root:angle_no_cfi_icall" ]

if (angle_enable_vulkan_system_info) {

defines += [ "ANGLE_USE_VULKAN_SYSTEM_INFO" ]

}

}

if (is_android) {

sources += libangle_gpu_info_util_android_sources

}

if (is_fuchsia) {

sources += libangle_gpu_info_util_fuchsia_sources

deps += [ "$angle_root/src/common/vulkan:angle_vulkan_entry_points" ]

}

if (is_win) {

sources += libangle_gpu_info_util_win_sources

if (!angle_is_winuwp) {

libs += [ "setupapi.lib" ]

}

libs += [ "dxgi.lib" ]

}

if (is_linux || is_chromeos) {

sources += libangle_gpu_info_util_linux_sources

if (angle_use_x11 && angle_has_build) {

sources += libangle_gpu_info_util_x11_sources

deps += [ "src/third_party/libXNVCtrl:libXNVCtrl" ]

defines += [ "GPU_INFO_USE_X11" ]

libs += [

"X11",

"Xi",

"Xext",

]

}

if (angle_use_wayland && angle_has_build) {

public_deps += [ ":angle_wayland" ]

}

}

if (use_libpci) {

sources += libangle_gpu_info_util_libpci_sources

defines += [ "GPU_INFO_USE_LIBPCI" ]

libs += [ "pci" ]

}

if (is_apple) {

frameworks = [

"IOKit.framework",

"CoreFoundation.framework",

"CoreGraphics.framework",

]

if (angle_enable_eagl) {

frameworks += [ "OpenGLES.framework" ]

} else if (angle_enable_cgl) {

frameworks += [ "OpenGL.framework" ]

}

if (is_mac || angle_enable_cgl) {

sources += libangle_gpu_info_util_mac_sources

}

if (is_ios && !angle_enable_cgl) {

sources += libangle_gpu_info_util_ios_sources

}

}

}

angle_source_set("angle_translator_headers") {

sources = angle_translator_exported_headers

public_deps = [ ":includes" ]

}

template("translator_lib") {

angle_static_library(target_name) {

sources = angle_translator_sources

defines = []

_needs_glsl_base = false

_needs_glsl_and_vulkan_base = false

_uses_spirv = false

# Frontend support:

if (angle_enable_desktop_glsl) {

sources += angle_translator_glsl_symbol_table_sources

} else {

sources += angle_translator_essl_symbol_table_sources

}

# Backend support:

if (angle_enable_essl || use_fuzzing_engine) {

_needs_glsl_base = true

sources += angle_translator_essl_sources

defines += [ "ANGLE_ENABLE_ESSL" ]

}

if (angle_enable_glsl || use_fuzzing_engine) {

_needs_glsl_base = true

_needs_glsl_and_vulkan_base = true

sources += angle_translator_glsl_sources

defines += [ "ANGLE_ENABLE_GLSL" ]

if (is_apple) {

sources += angle_translator_glsl_apple_sources

}

}

if (angle_enable_hlsl || use_fuzzing_engine) {

sources += angle_translator_hlsl_sources

defines += [ "ANGLE_ENABLE_HLSL" ]

}

if (!invoker.gl_d3d_only) {

if (angle_enable_vulkan || use_fuzzing_engine) {

_needs_glsl_base = true

_needs_glsl_and_vulkan_base = true

_uses_spirv = true

sources += angle_translator_lib_spirv_sources

}

if (angle_enable_vulkan || use_fuzzing_engine) {

defines += [ "ANGLE_ENABLE_VULKAN" ]

}

if (angle_enable_metal) {

sources += angle_translator_lib_msl_sources

defines += [ "ANGLE_ENABLE_METAL" ]

}

if (angle_enable_wgpu) {

sources += angle_translator_lib_wgsl_sources

defines += [ "ANGLE_ENABLE_WGPU" ]

}

}

if (_needs_glsl_base) {

sources += angle_translator_glsl_base_sources

}

if (_needs_glsl_and_vulkan_base) {

sources += angle_translator_glsl_and_vulkan_base_sources

}

public_configs += [ ":external_config" ]

deps = [

":angle_common_shader_state",

":includes",

":preprocessor",

"$angle_root/src/common/spirv:angle_spirv_headers",

]

if (_uses_spirv) {

deps += [

"$angle_root/src/common/spirv:angle_spirv_base",

"$angle_root/src/common/spirv:angle_spirv_builder",

"${angle_spirv_headers_dir}:spv_headers",

"${angle_spirv_tools_dir}:spvtools_headers",

"${angle_spirv_tools_dir}:spvtools_val",

]

}

public_deps = [

":angle_common",

":angle_translator_headers",

":angle_version_info",

]

if (is_win) {

# Necessary to suppress some system header xtree warnings in Release.

# For some reason this warning doesn't get triggered in Chromium

cflags = [ "/wd4718" ]

}

}

}

translator_lib("translator") {

gl_d3d_only = false

}

if (angle_enable_essl || angle_enable_glsl || angle_enable_hlsl) {

translator_lib("translator_gl_d3d_only") {

gl_d3d_only = true

}

}

angle_source_set("translator_fuzzer") {

sources = [ "src/compiler/fuzz/translator_fuzzer.cpp" ]

include_dirs = [

"include",

"src",

]

deps = [ ":translator" ]

}

config("angle_program_version_id_config") {

include_dirs = [ "$root_gen_dir/angle" ]

visibility = [ ":angle_program_version_id" ]

}

action("angle_program_version_id") {

response_file_contents =

rebase_path(angle_code_affecting_program_serialize, root_build_dir)

_program_version_header = "$root_gen_dir/angle/ANGLEShaderProgramVersion.h"

script = "src/program_serialize_data_version.py"

outputs = [ _program_version_header ]

visibility = [ ":angle_version" ]

inputs = angle_code_affecting_program_serialize

deps = angle_dependencies_affecting_program_serialize

args = [

rebase_path(_program_version_header, root_build_dir),

"{{response_file_name}}",

]

public_configs = [ ":angle_program_version_id_config" ]

}

config("angle_commit_id_config") {

include_dirs = [ "$root_gen_dir/angle" ]

visibility = [ ":angle_commit_id" ]

}

action("angle_commit_id") {

_commit_id_header = "$root_gen_dir/angle/angle_commit.h"

script = "src/commit_id.py"

outputs = [ _commit_id_header ]

visibility = [ ":angle_version" ]

# Add git as a dependency if it is available.

if (angle_enable_commit_id &&

exec_script("src/commit_id.py", [ "check" ], "value") == 1) {

# commit id should depend on angle's HEAD revision

git_dirs = exec_script("src/commit_id.py", [ "get_git_dirs" ], "list lines")

inputs = [ git_dirs[0] + "/HEAD" ]

branch = read_file(git_dirs[0] + "/HEAD", "string")

result = string_split(branch)

if (result[0] == "ref:") {

_ref_file = result[1]

# If git has packed the contents of .git/refs/heads/ in .git/packed-refs,

# unpack the head before depending on it.

exec_script("src/commit_id.py",

[

"unpack",

_ref_file,

],

"")

inputs += [ git_dirs[1] + "/" + _ref_file ]

}

}

args = [

"gen",

rebase_path(_commit_id_header, root_build_dir),

]

public_configs = [ ":angle_commit_id_config" ]

}

angle_source_set("angle_version") {

sources = [ "src/common/angle_version.h" ]

public_deps = [

":angle_commit_id",

":angle_program_version_id",

]

visibility = [ ":angle_version_info" ]

# The version headers are used directly in Windows .RC files.

if (is_win) {

visibility += [

":libEGL",

":libGL",

":libGLESv1_CM",

":libGLESv2",

":libGLESv2_capture_complement",

]

if (angle_enable_vulkan) {

visibility += [

":libEGL_vulkan_secondaries",

":libGLESv2_vulkan_secondaries",

]

}

}

}

angle_source_set("angle_version_info") {

sources = [

"src/common/angle_version_info.cpp",

"src/common/angle_version_info.h",

]

deps = [

":angle_translator_headers",

":angle_version",

]

}

config("angle_backend_config") {

defines = []

if (angle_force_context_check_every_call) {

defines += [ "ANGLE_FORCE_CONTEXT_CHECK_EVERY_CALL=1" ]

}

if (angle_expose_non_conformant_extensions_and_versions) {

defines += [ "ANGLE_EXPOSE_NON_CONFORMANT_EXTENSIONS_AND_VERSIONS" ]

}

configs = []

if (angle_enable_d3d11) {

configs += [ "src/libANGLE/renderer/d3d:angle_d3d11_backend_config" ]

}

if (angle_enable_d3d9) {

configs += [ "src/libANGLE/renderer/d3d:angle_d3d9_backend_config" ]

}

if (angle_enable_gl) {

configs += [ "src/libANGLE/renderer/gl:angle_gl_backend_config" ]

}

if (angle_enable_null) {

configs += [ "src/libANGLE/renderer/null:angle_null_backend_config" ]

}

if (angle_enable_wgpu) {

configs += [ "src/libANGLE/renderer/wgpu:angle_wgpu_backend_config" ]

}

if (angle_enable_metal) {

configs += [ "src/libANGLE/renderer/metal:angle_metal_backend_config" ]

}

if (angle_enable_vulkan) {

configs += [ "src/libANGLE/renderer/vulkan:angle_vulkan_backend_config" ]

}

if (angle_enable_cl_passthrough) {

configs += [ "src/libANGLE/renderer/cl:angle_cl_backend_config" ]

}

if (angle_is_winuwp) {

configs += [ "src/libANGLE/renderer/d3d:angle_enable_winuwp_config" ]

}

}

config("libANGLE_config") {