# Modifications Copyright (C)2022 Advanced Micro Devices, Inc. All rights reserved. #
# Notified per clause 4(b) of the license

# ~~~
# Copyright (c) 2018 Valve Corporation
# Copyright (c) 2018 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
#
#     http://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.
# ~~~

cmake_minimum_required(VERSION 3.14)
set(CMAKE_CXX_STANDARD 17)

project(Vulkan-Tools)

add_compile_options(-Wno-unused-result)
find_package(PythonInterp 3 QUIET)

set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake")
set(SCRIPTS_DIR "${CMAKE_CURRENT_SOURCE_DIR}/scripts")

find_package(Vulkan REQUIRED)
find_package(VulkanHeaders REQUIRED)

set(CUBE_INCLUDE_DIRS ${CMAKE_CURRENT_BINARY_DIR})
# -set(CUBE_INCLUDE_DIRS ${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_CURRENT_BINARY_DIR}/.. ${VulkanHeaders_INCLUDE_DIR})
# -set(SCRIPTS_DIR "${PROJECT_SOURCE_DIR}/scripts")

if (NOT GLSLANG_INSTALL_DIR AND DEFINED ENV{GLSLANG_INSTALL_DIR})
    set(GLSLANG_INSTALL_DIR $ENV{GLSLANG_INSTALL_DIR})
endif()

if(GLSLANG_INSTALL_DIR)
    message(STATUS "Using GLSLANG_INSTALL_DIR to look for glslangValidator")
    find_program(GLSLANG_VALIDATOR names glslangValidator HINTS "${GLSLANG_INSTALL_DIR}/bin")
else()
    set(GLSLANG_VALIDATOR_NAME "glslangValidator")
    message(STATUS "Using cmake find_program to look for glslangValidator")
    if(WIN32)
        execute_process(
            COMMAND ${PYTHON_EXECUTABLE} ${SCRIPTS_DIR}/fetch_glslangvalidator.py glslang-master-windows-x64-Release.zip)
        set(GLSLANG_VALIDATOR_NAME "glslangValidator.exe")
    elseif(APPLE)
        execute_process(COMMAND ${PYTHON_EXECUTABLE} ${SCRIPTS_DIR}/fetch_glslangvalidator.py glslang-master-osx-Release.zip)
    elseif(UNIX AND NOT APPLE) # i.e. Linux
        execute_process(COMMAND ${PYTHON_EXECUTABLE} ${SCRIPTS_DIR}/fetch_glslangvalidator.py glslang-master-linux-Release.zip)
    endif()
    if (WIN32)
        set(PLATFORM_DIR "${PROJECT_SOURCE_DIR}/glslang/windows/bin")
    elseif(APPLE)
        set(PLATFORM_DIR "${PROJECT_SOURCE_DIR}/glslang/darwin/bin")
    else()
        set(PLATFORM_DIR "${PROJECT_SOURCE_DIR}/glslang/linux/bin")
    endif()
    find_program(GLSLANG_VALIDATOR NAMES ${GLSLANG_VALIDATOR_NAME} HINTS ${PLATFORM_DIR})
endif()

if(UNIX AND NOT APPLE) # i.e. Linux
    include(FindPkgConfig)
    option(BUILD_WSI_XCB_SUPPORT "Build XCB WSI support" OFF)
    option(BUILD_WSI_XLIB_SUPPORT "Build Xlib WSI support" OFF)
    option(BUILD_WSI_WAYLAND_SUPPORT "Build Wayland WSI support" OFF)
    option(BUILD_WSI_DIRECTFB_SUPPORT "Build DirectFB WSI support" OFF)
    option(BUILD_NETINT_ENCODING_SUPPORT "Build NETINT encoding support" ON)
    option(VK_RENDER_1080P "Build vkcubepp support" OFF)
    set(CUBE_WSI_SELECTION "OFFSCREEN" CACHE STRING "Select WSI target for vkcube (XCB, XLIB, WAYLAND, DIRECTFB, DISPLAY, OFFSCREEN)")

    if(BUILD_WSI_XCB_SUPPORT)
        find_package(XCB REQUIRED)
    endif()

    if(BUILD_WSI_XLIB_SUPPORT)
        find_package(X11 REQUIRED)
    endif()

    if(BUILD_WSI_WAYLAND_SUPPORT)
        find_package(Wayland REQUIRED)
        find_package(WaylandScanner REQUIRED)
        find_package(WaylandProtocols REQUIRED)
        include_directories(${WAYLAND_CLIENT_INCLUDE_DIR})
    endif()

    if(BUILD_WSI_DIRECTFB_SUPPORT)
        find_package(DirectFB REQUIRED)
        include_directories(${DIRECTFB_INCLUDE_DIR})
    endif()

    if(VK_RENDER_1080P)
	add_definitions(-DVK_RENDER_1080P)
    endif()
    
    if(BUILD_NETINT_ENCODING_SUPPORT)
        pkg_check_modules(XCODER REQUIRED xcoder)
        add_definitions(-DBUILD_NETINT_ENCODING_SUPPORT)
        include_directories(${XCODER_INCLUDE_DIRS})
        link_libraries(${XCODER_LINK_LIBRARIES})
        link_directories(${XCODER_LIBRARY_DIRS})
    endif()
endif()

if(UNIX AND NOT APPLE AND NOT ANDROID) # i.e. Linux
    if(NOT CUBE_WSI_SELECTION)
        set(CUBE_WSI_SELECTION "XCB")
    endif()

    if(CUBE_WSI_SELECTION STREQUAL "XCB")
        if(NOT BUILD_WSI_XCB_SUPPORT)
            message(FATAL_ERROR "Selected XCB for vkcube build but not building Xcb support")
        endif()
        set(CUBE_INCLUDE_DIRS ${XCB_INCLUDE_DIRS} ${CUBE_INCLUDE_DIRS})
        link_libraries(${XCB_LIBRARIES})
        add_definitions(-DVK_USE_PLATFORM_XCB_KHR)
    elseif(CUBE_WSI_SELECTION STREQUAL "XLIB")
        if(NOT BUILD_WSI_XLIB_SUPPORT)
            message(FATAL_ERROR "Selected XLIB for vkcube build but not building Xlib support")
        endif()
        set(CUBE_INCLUDE_DIRS ${X11_INCLUDE_DIR} ${CUBE_INCLUDE_DIRS})
        link_libraries(${X11_LIBRARIES})
        add_definitions(-DVK_USE_PLATFORM_XLIB_KHR)
    elseif(CUBE_WSI_SELECTION STREQUAL "WAYLAND")
        if(NOT BUILD_WSI_WAYLAND_SUPPORT)
            message(FATAL_ERROR "Selected Wayland for vkcube build but not building Wayland support")
        endif()
        set(CUBE_INCLUDE_DIRS ${WAYLAND_CLIENT_INCLUDE_DIR} ${CUBE_INCLUDE_DIRS})
        link_libraries(${WAYLAND_CLIENT_LIBRARIES})
        add_definitions(-DVK_USE_PLATFORM_WAYLAND_KHR)
        set(XDG_SHELL_PROTOCOL ${WAYLAND_PROTOCOLS_PATH}/stable/xdg-shell/xdg-shell.xml)
        add_custom_command(COMMENT "Generating xdg-shell protocol dispatch data"
                           OUTPUT xdg-shell-code.c
                           COMMAND ${WAYLAND_SCANNER_EXECUTABLE}
                                   private-code
                                   ${XDG_SHELL_PROTOCOL}
                                   ${CMAKE_CURRENT_BINARY_DIR}/xdg-shell-code.c
                           MAIN_DEPENDENCY ${XDG_SHELL_PROTOCOL}
                           DEPENDS ${XDG_SHELL_PROTOCOL} ${WAYLAND_SCANNER_EXECUTABLE})
        add_custom_command(COMMENT "Generating xdg-shell protocol header"
                           OUTPUT xdg-shell-client-header.h
                           COMMAND ${WAYLAND_SCANNER_EXECUTABLE}
                                   client-header
                                   ${XDG_SHELL_PROTOCOL}
                                   ${CMAKE_CURRENT_BINARY_DIR}/xdg-shell-client-header.h
                           MAIN_DEPENDENCY ${XDG_SHELL_PROTOCOL}
                           DEPENDS ${XDG_SHELL_PROTOCOL} ${WAYLAND_SCANNER_EXECUTABLE})

        set(XDG_DECORATION_PROTOCOL ${WAYLAND_PROTOCOLS_PATH}/unstable/xdg-decoration/xdg-decoration-unstable-v1.xml)
        add_custom_command(COMMENT "Generating xdg-decoration protocol dispatch data"
                           OUTPUT xdg-decoration-code.c
                           COMMAND ${WAYLAND_SCANNER_EXECUTABLE}
                                   private-code
                                   ${XDG_DECORATION_PROTOCOL}
                                   ${CMAKE_CURRENT_BINARY_DIR}/xdg-decoration-code.c
                           MAIN_DEPENDENCY ${XDG_DECORATION_PROTOCOL}
                           DEPENDS ${XDG_DECORATION_PROTOCOL} ${WAYLAND_SCANNER_EXECUTABLE})
        add_custom_command(COMMENT "Generating xdg-decoration protocol header"
                           OUTPUT xdg-decoration-client-header.h
                           COMMAND ${WAYLAND_SCANNER_EXECUTABLE}
                                   client-header
                                   ${XDG_DECORATION_PROTOCOL}
                                   ${CMAKE_CURRENT_BINARY_DIR}/xdg-decoration-client-header.h
                           MAIN_DEPENDENCY ${XDG_DECORATION_PROTOCOL}
                           DEPENDS ${XDG_DECORATION_PROTOCOL} ${WAYLAND_SCANNER_EXECUTABLE})

        set(OPTIONAL_WAYLAND_DATA_FILES
            ${CMAKE_CURRENT_BINARY_DIR}/xdg-shell-code.c
            ${CMAKE_CURRENT_BINARY_DIR}/xdg-shell-client-header.h
            ${CMAKE_CURRENT_BINARY_DIR}/xdg-decoration-code.c
            ${CMAKE_CURRENT_BINARY_DIR}/xdg-decoration-client-header.h)
        include_directories(${CMAKE_CURRENT_BINARY_DIR})
    elseif(CUBE_WSI_SELECTION STREQUAL "DIRECTFB")
        if(NOT BUILD_WSI_DIRECTFB_SUPPORT)
            message(FATAL_ERROR "Selected DIRECTFB for vkcube build but not building DirectFB support")
        endif()
        set(CUBE_INCLUDE_DIRS ${DIRECTFB_INCLUDE_DIR} ${CUBE_INCLUDE_DIRS})
        link_libraries(${DIRECTFB_LIBRARIES})
        add_definitions(-DVK_USE_PLATFORM_DIRECTFB_EXT)
    elseif(CUBE_WSI_SELECTION STREQUAL "DISPLAY")
        add_definitions(-DVK_USE_PLATFORM_DISPLAY_KHR)
    elseif(CUBE_WSI_SELECTION STREQUAL "OFFSCREEN")
        add_definitions(-DOFFSCREEN_RENDER)
    else()
        message(FATAL_ERROR "Unrecognized value for CUBE_WSI_SELECTION: ${CUBE_WSI_SELECTION}")
    endif()

    link_libraries(${API_LOWERCASE} m)
else()
    message(FATAL_ERROR "Unsupported Platform!")
endif()

set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")

add_custom_command(COMMENT "Compiling cube vertex shader"
                   OUTPUT cube.vert.inc
                   COMMAND ${GLSLANG_VALIDATOR} -V -x -o ${CMAKE_CURRENT_BINARY_DIR}/cube.vert.inc
                            ${CMAKE_CURRENT_SOURCE_DIR}/shaders/cube.vert
                    MAIN_DEPENDENCY ${CMAKE_CURRENT_SOURCE_DIR}/shaders/cube.vert
                    DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/shaders/cube.vert ${GLSLANG_VALIDATOR})
add_custom_command(COMMENT "Compiling cube fragment shader"
                   OUTPUT cube.frag.inc
                   COMMAND ${GLSLANG_VALIDATOR} -V -x -o ${CMAKE_CURRENT_BINARY_DIR}/cube.frag.inc
                            ${CMAKE_CURRENT_SOURCE_DIR}/shaders/cube.frag
                    MAIN_DEPENDENCY ${CMAKE_CURRENT_SOURCE_DIR}/shaders/cube.frag
                    DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/shaders/cube.frag ${GLSLANG_VALIDATOR})

add_custom_command(COMMENT "Compiling show texture vertex shader"
                   OUTPUT show_texture.vert.inc
                   COMMAND ${GLSLANG_VALIDATOR} -V -x -o ${CMAKE_CURRENT_BINARY_DIR}/show_texture.vert.inc
                            ${CMAKE_CURRENT_SOURCE_DIR}/shaders/show_texture.vert
                    MAIN_DEPENDENCY ${CMAKE_CURRENT_SOURCE_DIR}/shaders/show_texture.vert
                    DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/shaders/show_texture.vert ${GLSLANG_VALIDATOR})
add_custom_command(COMMENT "Compiling show texture fragment shader"
                   OUTPUT show_texture.frag.inc
                   COMMAND ${GLSLANG_VALIDATOR} -V -x -o ${CMAKE_CURRENT_BINARY_DIR}/show_texture.frag.inc
                            ${CMAKE_CURRENT_SOURCE_DIR}/shaders/show_texture.frag
                    MAIN_DEPENDENCY ${CMAKE_CURRENT_SOURCE_DIR}/shaders/show_texture.frag
                    DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/shaders/show_texture.frag ${GLSLANG_VALIDATOR})

add_custom_command(COMMENT "Compiling rbg2nv12 color conversion compute shader"
                   OUTPUT rgb2nv12.comp.inc
                   COMMAND ${GLSLANG_VALIDATOR} -V -x -o ${CMAKE_CURRENT_BINARY_DIR}/rgb2nv12.comp.inc
                            ${CMAKE_CURRENT_SOURCE_DIR}/shaders/rgb2nv12.comp
                    MAIN_DEPENDENCY ${CMAKE_CURRENT_SOURCE_DIR}/shaders/rgb2nv12.comp
                    DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/shaders/rgb2nv12.comp ${GLSLANG_VALIDATOR})

add_custom_command(COMMENT "Compiling rgb2yuv420p color conversion compute shader"
                   OUTPUT rgb2yuv420p.comp.inc
                   COMMAND ${GLSLANG_VALIDATOR} -V -x -o ${CMAKE_CURRENT_BINARY_DIR}/rgb2yuv420p.comp.inc
                            ${CMAKE_CURRENT_SOURCE_DIR}/shaders/rgb2yuv420p.comp
                    MAIN_DEPENDENCY ${CMAKE_CURRENT_SOURCE_DIR}/shaders/rgb2yuv420p.comp
                    DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/shaders/rgb2yuv420p.comp ${GLSLANG_VALIDATOR})

add_custom_command(COMMENT "Compiling rgb2yuv420p color conversion compute shader"
                   OUTPUT rgb2yuv420p_netint.comp.inc
                   COMMAND ${GLSLANG_VALIDATOR} -V -x -o ${CMAKE_CURRENT_BINARY_DIR}/rgb2yuv420p_netint.comp.inc
                            ${CMAKE_CURRENT_SOURCE_DIR}/shaders/rgb2yuv420p_netint.comp
                    MAIN_DEPENDENCY ${CMAKE_CURRENT_SOURCE_DIR}/shaders/rgb2yuv420p_netint.comp
                    DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/shaders/rgb2yuv420p_netint.comp ${GLSLANG_VALIDATOR})

add_custom_command(COMMENT "Compiling rgb2yuv420p color conversion compute shader"
                   OUTPUT rgb2yuv420p_netint_1080p.comp.inc
                   COMMAND ${GLSLANG_VALIDATOR} -V -x -o ${CMAKE_CURRENT_BINARY_DIR}/rgb2yuv420p_netint_1080p.comp.inc
                            ${CMAKE_CURRENT_SOURCE_DIR}/shaders/rgb2yuv420p_netint_1080p.comp
                    MAIN_DEPENDENCY ${CMAKE_CURRENT_SOURCE_DIR}/shaders/rgb2yuv420p_netint_1080p.comp
                    DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/shaders/rgb2yuv420p_netint_1080p.comp ${GLSLANG_VALIDATOR})

include_directories(${CUBE_INCLUDE_DIRS} ${CMAKE_CURRENT_SOURCE_DIR})

# ----------------------------------------------------------------------------
# vkcubepp

set(ENCODING_COMPONENT_SOURCES
    encoder/encoding_device.h
    encoder/fake_gpu_encoding.h
    encoder/fake_gpu_encoding.cpp
)

if(BUILD_NETINT_ENCODING_SUPPORT)
    set(ENCODING_COMPONENT_SOURCES
        encoder/netint_encoding.h
        encoder/netint_encoding.cpp
        ${ENCODING_COMPONENT_SOURCES})
endif()

if(UNIX AND NOT APPLE AND NOT ANDROID)
    find_package(Threads REQUIRED)
    set(CMAKE_THREAD_PREFER_PTHREAD TRUE)
    set(THREADS_PREFER_PTHREAD_FLAG TRUE)
    if(${CMAKE_SYSTEM_PROCESSOR} STREQUAL ${CMAKE_HOST_SYSTEM_PROCESSOR})
        add_executable(vkcubepp
                       main.cpp
                       renderer/cube.cpp
                       renderer/cube.h
                       renderer/surface_render_context.h
                       vk_helper/window_surface.cpp
                       vk_helper/window_surface.h
                       options.h
                       options.cpp
                       vk_helper/vk_common.h
                       vk_helper/vk_common.cpp
                       vk_helper/vk_swapchain_rsc.h
                       vk_helper/vk_swapchain_rsc.cpp
                       util/gettime.h
                       util/timestamp_record.cpp
                       util/timestamp_record.h
                       ${ENCODING_COMPONENT_SOURCES}
                       cube.vert.inc
                       cube.frag.inc
                       show_texture.vert.inc
                       show_texture.frag.inc
                       rgb2nv12.comp.inc
                       rgb2yuv420p.comp.inc
                       rgb2yuv420p_netint.comp.inc
                       rgb2yuv420p_netint_1080p.comp.inc
		       ${OPTIONAL_WAYLAND_DATA_FILES})
        target_link_libraries(vkcubepp Vulkan::Vulkan Threads::Threads)
    endif()
else()
    message(FATAL_ERROR "Not supported platform")
endif()

install(TARGETS vkcubepp RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})

install(SCRIPT ${CMAKE_SOURCE_DIR}/scripts/run_multiple_encoding.py ${CMAKE_INSTALL_BINDIR})
