# Copyright (C) 2018-2019 The ANGLE Project Authors.
# Copyright (C) 2019 LunarG, Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import("//build_overrides/build.gni")
import("//build_overrides/vulkan_loader.gni")

deps = []

declare_args() {
  custom_vulkan_loader_library_name = ""
}

if (is_fuchsia) {
  import("//build/cpp/sdk_shared_library.gni")
  import("//build/sdk/sdk_documentation.gni")
}

if (!is_android) {
  vulkan_undefine_configs = []
}
if (is_win) {
  vulkan_undefine_configs += [
    "//build/config/win:nominmax",
    "//build/config/win:unicode",
  ]
}

config("vulkan_internal_config") {
  defines = [
    "VULKAN_NON_CMAKE_BUILD",
    "VK_ENABLE_BETA_EXTENSIONS",
  ]
  if (is_clang || !is_win) {
    cflags = [
      "-Wno-conversion",
      "-Wno-extra-semi",
      "-Wno-implicit-fallthrough",
      "-Wno-sign-compare",
      "-Wno-strict-prototypes",
      "-Wno-unreachable-code",
      "-Wno-unused-function",
      "-Wno-unused-variable",
      "-Wno-write-strings",
      "-Wno-newline-eof",
    ]
  }
  if (is_fuchsia) {
    defines += [
      "SYSCONFDIR=\"/config/data\"",
      "EXTRASYSCONFDIR=\"/pkg/data\"",
    ]
  }
  if (is_linux || is_mac) {
    defines += [
      "SYSCONFDIR=\"/etc\"",
      "FALLBACK_CONFIG_DIRS=\"/etc/xdg\"",
      "FALLBACK_DATA_DIRS=\"/usr/local/share:/usr/share\"",
    ]
  }
}

# Vulkan loader
# -------------

config("vulkan_loader_config") {
  include_dirs = [
    "loader/generated",
    "loader",
  ]
  defines = [
    "API_NAME=\"Vulkan\"",
    "USE_UNSAFE_FILE_SEARCH=1",
  ]

  if (is_win) {
    cflags = [ "/wd4201" ]
  }
  if (is_linux) {
    # assume secure_getenv() is available
    defines += [
      "HAVE_SECURE_GETENV",
      "_POSIX_C_SOURCE=200809L",
    ]
  }
}

if (!is_android) {
  if (is_fuchsia) {
    library_type = "sdk_shared_library"
  } else if (vulkan_loader_shared) {
    library_type = "shared_library"
  } else {
    library_type = "static_library"
  }

  target(library_type, "libvulkan") {
    sources = [
      "loader/adapters.h",
      "loader/allocation.c",
      "loader/allocation.h",
      "loader/asm_offset.c",
      "loader/cJSON.c",
      "loader/cJSON.h",
      "loader/debug_utils.c",
      "loader/debug_utils.h",
      "loader/dev_ext_trampoline.c",
      "loader/extension_manual.c",
      "loader/extension_manual.h",
      "loader/generated/vk_layer_dispatch_table.h",
      "loader/generated/vk_loader_extensions.h",
      "loader/generated/vk_object_types.h",
      "loader/get_environment.c",
      "loader/get_environment.h",
      "loader/gpa_helper.c",
      "loader/gpa_helper.h",
      "loader/loader.c",
      "loader/loader.h",
      "loader/loader_common.h",
      "loader/log.c",
      "loader/log.h",
      "loader/murmurhash.c",
      "loader/murmurhash.h",
      "loader/phys_dev_ext.c",
      "loader/terminator.c",
      "loader/trampoline.c",
      "loader/vk_loader_layer.h",

      # TODO(jmadill): Use assembler where available.
      "loader/unknown_ext_chain.c",
      "loader/vk_loader_platform.h",
      "loader/wsi.c",
      "loader/wsi.h",
    ]

    if (custom_vulkan_loader_library_name != "") {
      output_name = custom_vulkan_loader_library_name
    } else {
      if (is_win) {
        output_name = "vulkan-1"
      } else {
        output_name = "vulkan"

        # Create libvulkan.so.1 on Linux instead of libvulkan.so
        if (is_linux && vulkan_loader_shared) {
          output_extension = "so.1"
        }
      }
    }

    if (is_win) {
      sources += [
        "loader/dirent_on_windows.c",
        "loader/dirent_on_windows.h",
        "loader/loader.rc",
        "loader/loader_windows.c",
        "loader/loader_windows.h",
        "loader/vulkan-1.def",
      ]
      if (!is_clang) {
        cflags = [
          "/wd4054",  # Type cast from function pointer
          "/wd4055",  # Type cast from data pointer
          "/wd4100",  # Unreferenced formal parameter
          "/wd4152",  # Nonstandard extension used (pointer conversion)
          "/wd4201",  # Nonstandard extension used: nameless struct/union
          "/wd4214",  # Nonstandard extension used: bit field types other than
                      # int
          "/wd4232",  # Nonstandard extension used: address of dllimport is not
                      # static
          "/wd4305",  # Type cast truncation
          "/wd4706",  # Assignment within conditional expression
          "/wd4996",  # Unsafe stdlib function
        ]
      }
      if (is_clang) {
        cflags = [ "-Wno-incompatible-pointer-types" ]
      }
      libs = [ "Cfgmgr32.lib" ]
    }
    if (is_linux) {
      libs = [ "dl" ]
    }
    if (is_mac) {
      frameworks = [ "CoreFoundation.framework" ]
    }
    if (build_with_chromium) {
      configs -= [ "//build/config/compiler:chromium_code" ]
      configs += [ "//build/config/compiler:no_chromium_code" ]
    }
    public_deps = [ "$vulkan_headers_dir:vulkan_headers" ]
    configs += [ ":vulkan_internal_config" ]
    public_configs = [ ":vulkan_loader_config" ]
    configs -= vulkan_undefine_configs

    if (is_fuchsia) {
      category = "partner"

      symbols_api = "vulkan.ifs"

      # The Vulkan loader's interface is defined by standard Khronos vulkan headers
      # which can be obtained separately from the loader implementation itself.
      no_headers = true

      sources += [ "fuchsia/loader_extensions.cc" ]

      deps += [
        ":dlopen_fuchsia",
        "//sdk/fidl/fuchsia.io:fuchsia.io_llcpp",
        "//sdk/fidl/fuchsia.vulkan.loader:fuchsia.vulkan.loader_llcpp",
        "//sdk/lib/fdio",
      ]

      runtime_deps = [
        "//sdk/lib/fdio:fdio_sdk",
        "//zircon/system/ulib/trace-engine:trace-engine_sdk",
      ]

      libcxx_linkage = "static"
    }
  }
}

if (is_fuchsia) {
  config("fuchsia_config") {
    include_dirs = [ "fuchsia" ]

    if (is_clang || !is_win) {
      cflags = [
        "-Wno-newline-eof",
        "-Wno-strict-prototypes",
      ]
    }
  }

  source_set("dlopen_fuchsia") {
    public_configs = [ ":fuchsia_config" ]
    configs += [ ":vulkan_loader_config" ]

    sources = [
      "fuchsia/dlopen_fuchsia.cc",
      "fuchsia/dlopen_fuchsia.h",
      "fuchsia/loader_fuchsia.h",
      "fuchsia/loader_service.cc",
      "fuchsia/loader_service.h",
      "loader/log.h",
    ]

    deps = [
      "$vulkan_headers_dir:vulkan_headers",
      "//sdk/fidl/fuchsia.vulkan.loader:fuchsia.vulkan.loader_llcpp",
      "//sdk/lib/fdio",
      "//zircon/system/ulib/service:service-llcpp",
    ]
  }

  sdk_documentation("vulkan_license") {
    name = "vulkan_license"
    category = "public"

    files = [
      {
        source = "LICENSE.txt"
        dest = "LICENSE.vulkan"
      },
    ]
  }
}

group("tests") {
  # TODO(fxbug.dev/13288)
}