2012-05-27 13:22:43 +00:00
|
|
|
# ***** BEGIN GPL LICENSE BLOCK *****
|
|
|
|
#
|
|
|
|
# This program is free software; you can redistribute it and/or
|
|
|
|
# modify it under the terms of the GNU General Public License
|
|
|
|
# as published by the Free Software Foundation; either version 2
|
|
|
|
# of the License, or (at your option) any later version.
|
|
|
|
#
|
|
|
|
# This program is distributed in the hope that it will be useful,
|
|
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
# GNU General Public License for more details.
|
|
|
|
#
|
|
|
|
# You should have received a copy of the GNU General Public License
|
|
|
|
# along with this program; if not, write to the Free Software Foundation,
|
|
|
|
# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
|
|
#
|
|
|
|
# The Original Code is Copyright (C) 2006, Blender Foundation
|
|
|
|
# All rights reserved.
|
|
|
|
# ***** END GPL LICENSE BLOCK *****
|
2011-06-19 06:57:56 +00:00
|
|
|
|
2012-07-16 08:26:42 +00:00
|
|
|
macro(list_insert_after
|
2019-04-17 04:35:54 +00:00
|
|
|
list_id item_check item_add
|
|
|
|
)
|
|
|
|
set(_index)
|
|
|
|
list(FIND "${list_id}" "${item_check}" _index)
|
|
|
|
if("${_index}" MATCHES "-1")
|
|
|
|
message(FATAL_ERROR "'${list_id}' doesn't contain '${item_check}'")
|
|
|
|
endif()
|
|
|
|
math(EXPR _index "${_index} + 1")
|
|
|
|
list(INSERT ${list_id} "${_index}" ${item_add})
|
|
|
|
unset(_index)
|
2012-07-16 08:26:42 +00:00
|
|
|
endmacro()
|
|
|
|
|
|
|
|
macro(list_insert_before
|
2019-04-17 04:35:54 +00:00
|
|
|
list_id item_check item_add
|
|
|
|
)
|
|
|
|
set(_index)
|
|
|
|
list(FIND "${list_id}" "${item_check}" _index)
|
|
|
|
if("${_index}" MATCHES "-1")
|
|
|
|
message(FATAL_ERROR "'${list_id}' doesn't contain '${item_check}'")
|
|
|
|
endif()
|
|
|
|
list(INSERT ${list_id} "${_index}" ${item_add})
|
|
|
|
unset(_index)
|
2012-07-16 08:26:42 +00:00
|
|
|
endmacro()
|
|
|
|
|
2015-06-30 12:44:27 +00:00
|
|
|
function(list_assert_duplicates
|
2019-04-17 04:35:54 +00:00
|
|
|
list_id
|
|
|
|
)
|
|
|
|
|
|
|
|
# message(STATUS "list data: ${list_id}")
|
|
|
|
|
|
|
|
list(LENGTH list_id _len_before)
|
|
|
|
list(REMOVE_DUPLICATES list_id)
|
|
|
|
list(LENGTH list_id _len_after)
|
|
|
|
# message(STATUS "list size ${_len_before} -> ${_len_after}")
|
|
|
|
if(NOT _len_before EQUAL _len_after)
|
|
|
|
message(FATAL_ERROR "duplicate found in list which should not contain duplicates: ${list_id}")
|
|
|
|
endif()
|
|
|
|
unset(_len_before)
|
|
|
|
unset(_len_after)
|
2013-10-25 06:21:38 +00:00
|
|
|
endfunction()
|
|
|
|
|
|
|
|
|
2011-06-19 06:57:56 +00:00
|
|
|
# foo_bar.spam --> foo_barMySuffix.spam
|
|
|
|
macro(file_suffix
|
2019-04-17 04:35:54 +00:00
|
|
|
file_name_new file_name file_suffix
|
|
|
|
)
|
2011-06-19 06:57:56 +00:00
|
|
|
|
2019-04-17 04:35:54 +00:00
|
|
|
get_filename_component(_file_name_PATH ${file_name} PATH)
|
|
|
|
get_filename_component(_file_name_NAME_WE ${file_name} NAME_WE)
|
|
|
|
get_filename_component(_file_name_EXT ${file_name} EXT)
|
|
|
|
set(${file_name_new} "${_file_name_PATH}/${_file_name_NAME_WE}${file_suffix}${_file_name_EXT}")
|
2011-06-19 06:57:56 +00:00
|
|
|
|
2019-04-17 04:35:54 +00:00
|
|
|
unset(_file_name_PATH)
|
|
|
|
unset(_file_name_NAME_WE)
|
|
|
|
unset(_file_name_EXT)
|
2011-06-19 06:57:56 +00:00
|
|
|
endmacro()
|
|
|
|
|
2011-10-23 17:52:20 +00:00
|
|
|
# useful for adding debug suffix to library lists:
|
2011-06-19 06:57:56 +00:00
|
|
|
# /somepath/foo.lib --> /somepath/foo_d.lib
|
|
|
|
macro(file_list_suffix
|
2019-04-17 04:35:54 +00:00
|
|
|
fp_list_new fp_list fn_suffix
|
|
|
|
)
|
2011-06-19 06:57:56 +00:00
|
|
|
|
2019-04-17 04:35:54 +00:00
|
|
|
# incase of empty list
|
|
|
|
set(_fp)
|
|
|
|
set(_fp_suffixed)
|
2011-06-19 06:57:56 +00:00
|
|
|
|
2019-04-17 04:35:54 +00:00
|
|
|
set(fp_list_new)
|
2011-06-19 06:57:56 +00:00
|
|
|
|
2019-04-17 04:35:54 +00:00
|
|
|
foreach(_fp ${fp_list})
|
|
|
|
file_suffix(_fp_suffixed "${_fp}" "${fn_suffix}")
|
|
|
|
list(APPEND "${fp_list_new}" "${_fp_suffixed}")
|
|
|
|
endforeach()
|
2011-06-19 06:57:56 +00:00
|
|
|
|
2019-04-17 04:35:54 +00:00
|
|
|
unset(_fp)
|
|
|
|
unset(_fp_suffixed)
|
2011-06-19 06:57:56 +00:00
|
|
|
|
|
|
|
endmacro()
|
|
|
|
|
2015-12-02 13:09:06 +00:00
|
|
|
if(UNIX AND NOT APPLE)
|
2019-04-17 04:35:54 +00:00
|
|
|
macro(find_package_static)
|
|
|
|
set(_cmake_find_library_suffixes_back ${CMAKE_FIND_LIBRARY_SUFFIXES})
|
|
|
|
set(CMAKE_FIND_LIBRARY_SUFFIXES .a ${CMAKE_FIND_LIBRARY_SUFFIXES})
|
|
|
|
find_package(${ARGV})
|
|
|
|
set(CMAKE_FIND_LIBRARY_SUFFIXES ${_cmake_find_library_suffixes_back})
|
|
|
|
unset(_cmake_find_library_suffixes_back)
|
|
|
|
endmacro()
|
|
|
|
|
|
|
|
macro(find_library_static)
|
|
|
|
set(_cmake_find_library_suffixes_back ${CMAKE_FIND_LIBRARY_SUFFIXES})
|
|
|
|
set(CMAKE_FIND_LIBRARY_SUFFIXES .a ${CMAKE_FIND_LIBRARY_SUFFIXES})
|
|
|
|
find_library(${ARGV})
|
|
|
|
set(CMAKE_FIND_LIBRARY_SUFFIXES ${_cmake_find_library_suffixes_back})
|
|
|
|
unset(_cmake_find_library_suffixes_back)
|
|
|
|
endmacro()
|
2015-12-02 13:09:06 +00:00
|
|
|
endif()
|
2011-06-26 17:18:37 +00:00
|
|
|
|
2015-06-16 23:16:17 +00:00
|
|
|
function(target_link_libraries_optimized
|
2019-04-17 04:35:54 +00:00
|
|
|
TARGET
|
|
|
|
LIBS
|
|
|
|
)
|
2015-06-16 23:16:17 +00:00
|
|
|
|
2019-04-17 04:35:54 +00:00
|
|
|
foreach(_LIB ${LIBS})
|
|
|
|
target_link_libraries(${TARGET} optimized "${_LIB}")
|
|
|
|
endforeach()
|
2015-06-16 23:16:17 +00:00
|
|
|
endfunction()
|
|
|
|
|
|
|
|
function(target_link_libraries_debug
|
2019-04-17 04:35:54 +00:00
|
|
|
TARGET
|
|
|
|
LIBS
|
|
|
|
)
|
2011-06-26 17:18:37 +00:00
|
|
|
|
2019-04-17 04:35:54 +00:00
|
|
|
foreach(_LIB ${LIBS})
|
|
|
|
target_link_libraries(${TARGET} debug "${_LIB}")
|
|
|
|
endforeach()
|
2015-06-16 23:16:17 +00:00
|
|
|
endfunction()
|
|
|
|
|
2010-12-22 22:15:20 +00:00
|
|
|
# Nicer makefiles with -I/1/foo/ instead of -I/1/2/3/../../foo/
|
|
|
|
# use it instead of include_directories()
|
2015-06-16 23:16:17 +00:00
|
|
|
function(blender_include_dirs
|
2019-04-17 04:35:54 +00:00
|
|
|
includes
|
|
|
|
)
|
|
|
|
|
|
|
|
set(_ALL_INCS "")
|
|
|
|
foreach(_INC ${ARGV})
|
|
|
|
get_filename_component(_ABS_INC ${_INC} ABSOLUTE)
|
|
|
|
list(APPEND _ALL_INCS ${_ABS_INC})
|
|
|
|
# for checking for invalid includes, disable for regular use
|
2019-10-28 14:32:33 +00:00
|
|
|
# if(NOT EXISTS "${_ABS_INC}/")
|
|
|
|
# message(FATAL_ERROR "Include not found: ${_ABS_INC}/")
|
|
|
|
# endif()
|
2019-04-17 04:35:54 +00:00
|
|
|
endforeach()
|
|
|
|
include_directories(${_ALL_INCS})
|
2015-06-16 23:16:17 +00:00
|
|
|
endfunction()
|
|
|
|
|
|
|
|
function(blender_include_dirs_sys
|
2019-04-17 04:35:54 +00:00
|
|
|
includes
|
|
|
|
)
|
|
|
|
|
|
|
|
set(_ALL_INCS "")
|
|
|
|
foreach(_INC ${ARGV})
|
|
|
|
get_filename_component(_ABS_INC ${_INC} ABSOLUTE)
|
|
|
|
list(APPEND _ALL_INCS ${_ABS_INC})
|
2019-10-28 14:32:33 +00:00
|
|
|
# if(NOT EXISTS "${_ABS_INC}/")
|
|
|
|
# message(FATAL_ERROR "Include not found: ${_ABS_INC}/")
|
|
|
|
# endif()
|
2019-04-17 04:35:54 +00:00
|
|
|
endforeach()
|
|
|
|
include_directories(SYSTEM ${_ALL_INCS})
|
2015-06-16 23:16:17 +00:00
|
|
|
endfunction()
|
2010-11-05 04:18:53 +00:00
|
|
|
|
2015-06-16 23:16:17 +00:00
|
|
|
function(blender_source_group
|
2019-04-17 04:35:54 +00:00
|
|
|
sources
|
|
|
|
)
|
|
|
|
|
2019-10-28 14:32:33 +00:00
|
|
|
# if enabled, use the sources directories as filters.
|
2019-06-15 18:44:47 +00:00
|
|
|
if(WINDOWS_USE_VISUAL_STUDIO_SOURCE_FOLDERS)
|
|
|
|
foreach(_SRC ${sources})
|
|
|
|
# remove ../'s
|
|
|
|
get_filename_component(_SRC_DIR ${_SRC} REALPATH)
|
|
|
|
get_filename_component(_SRC_DIR ${_SRC_DIR} DIRECTORY)
|
2019-06-18 21:12:16 +00:00
|
|
|
string(FIND ${_SRC_DIR} "${CMAKE_CURRENT_SOURCE_DIR}/" _pos)
|
|
|
|
if(NOT _pos EQUAL -1)
|
2019-06-15 18:44:47 +00:00
|
|
|
string(REPLACE "${CMAKE_CURRENT_SOURCE_DIR}/" "" GROUP_ID ${_SRC_DIR})
|
|
|
|
string(REPLACE "/" "\\" GROUP_ID ${GROUP_ID})
|
|
|
|
source_group("${GROUP_ID}" FILES ${_SRC})
|
|
|
|
endif()
|
2019-06-18 21:12:16 +00:00
|
|
|
unset(_pos)
|
2019-06-15 18:44:47 +00:00
|
|
|
endforeach()
|
|
|
|
else()
|
|
|
|
# Group by location on disk
|
|
|
|
source_group("Source Files" FILES CMakeLists.txt)
|
|
|
|
foreach(_SRC ${sources})
|
2019-06-15 22:16:04 +00:00
|
|
|
get_filename_component(_SRC_EXT ${_SRC} EXT)
|
2019-06-15 18:44:47 +00:00
|
|
|
if((${_SRC_EXT} MATCHES ".h") OR
|
|
|
|
(${_SRC_EXT} MATCHES ".hpp") OR
|
|
|
|
(${_SRC_EXT} MATCHES ".hh"))
|
|
|
|
|
|
|
|
set(GROUP_ID "Header Files")
|
2019-06-15 22:16:04 +00:00
|
|
|
elseif(${_SRC_EXT} MATCHES ".glsl$")
|
2019-06-15 18:44:47 +00:00
|
|
|
set(GROUP_ID "Shaders")
|
|
|
|
else()
|
|
|
|
set(GROUP_ID "Source Files")
|
|
|
|
endif()
|
|
|
|
source_group("${GROUP_ID}" FILES ${_SRC})
|
|
|
|
endforeach()
|
|
|
|
endif()
|
2015-06-16 23:16:17 +00:00
|
|
|
endfunction()
|
2010-11-05 04:18:53 +00:00
|
|
|
|
2011-05-28 04:53:17 +00:00
|
|
|
|
2016-07-14 09:11:33 +00:00
|
|
|
# Support per-target CMake flags
|
|
|
|
# Read from: CMAKE_C_FLAGS_**** (made upper case) when set.
|
|
|
|
#
|
2018-09-19 15:48:11 +00:00
|
|
|
# 'name' should always match the target name,
|
2016-07-14 09:11:33 +00:00
|
|
|
# use this macro before add_library or add_executable.
|
|
|
|
#
|
|
|
|
# Optionally takes an arg passed to set(), eg PARENT_SCOPE.
|
|
|
|
macro(add_cc_flags_custom_test
|
2019-04-17 04:35:54 +00:00
|
|
|
name
|
|
|
|
)
|
|
|
|
|
|
|
|
string(TOUPPER ${name} _name_upper)
|
|
|
|
if(DEFINED CMAKE_C_FLAGS_${_name_upper})
|
|
|
|
message(STATUS "Using custom CFLAGS: CMAKE_C_FLAGS_${_name_upper} in \"${CMAKE_CURRENT_SOURCE_DIR}\"")
|
|
|
|
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${CMAKE_C_FLAGS_${_name_upper}}" ${ARGV1})
|
|
|
|
endif()
|
|
|
|
if(DEFINED CMAKE_CXX_FLAGS_${_name_upper})
|
|
|
|
message(STATUS "Using custom CXXFLAGS: CMAKE_CXX_FLAGS_${_name_upper} in \"${CMAKE_CURRENT_SOURCE_DIR}\"")
|
|
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_${_name_upper}}" ${ARGV1})
|
|
|
|
endif()
|
|
|
|
unset(_name_upper)
|
2016-07-14 09:11:33 +00:00
|
|
|
|
|
|
|
endmacro()
|
|
|
|
|
|
|
|
|
2011-05-28 04:53:17 +00:00
|
|
|
# only MSVC uses SOURCE_GROUP
|
2016-07-14 09:11:33 +00:00
|
|
|
function(blender_add_lib__impl
|
2019-04-17 04:35:54 +00:00
|
|
|
name
|
|
|
|
sources
|
|
|
|
includes
|
|
|
|
includes_sys
|
|
|
|
library_deps
|
|
|
|
)
|
|
|
|
|
|
|
|
# message(STATUS "Configuring library ${name}")
|
|
|
|
|
|
|
|
# include_directories(${includes})
|
|
|
|
# include_directories(SYSTEM ${includes_sys})
|
|
|
|
blender_include_dirs("${includes}")
|
|
|
|
blender_include_dirs_sys("${includes_sys}")
|
|
|
|
|
|
|
|
add_library(${name} ${sources})
|
|
|
|
|
2019-06-18 21:24:55 +00:00
|
|
|
if(NOT "${library_deps}" STREQUAL "")
|
2019-06-06 00:16:06 +00:00
|
|
|
target_link_libraries(${name} INTERFACE "${library_deps}")
|
2019-04-17 04:35:54 +00:00
|
|
|
endif()
|
|
|
|
|
|
|
|
# works fine without having the includes
|
|
|
|
# listed is helpful for IDE's (QtCreator/MSVC)
|
|
|
|
blender_source_group("${sources}")
|
|
|
|
|
2019-10-28 14:32:33 +00:00
|
|
|
# if enabled, set the FOLDER property for visual studio projects
|
2019-06-15 18:35:36 +00:00
|
|
|
if(WINDOWS_USE_VISUAL_STUDIO_PROJECT_FOLDERS)
|
2019-04-17 04:35:54 +00:00
|
|
|
get_filename_component(FolderDir ${CMAKE_CURRENT_SOURCE_DIR} DIRECTORY)
|
|
|
|
string(REPLACE ${CMAKE_SOURCE_DIR} "" FolderDir ${FolderDir})
|
|
|
|
set_target_properties(${name} PROPERTIES FOLDER ${FolderDir})
|
|
|
|
endif()
|
|
|
|
|
|
|
|
list_assert_duplicates("${sources}")
|
|
|
|
list_assert_duplicates("${includes}")
|
|
|
|
# Not for system includes because they can resolve to the same path
|
|
|
|
# list_assert_duplicates("${includes_sys}")
|
2013-10-25 06:21:38 +00:00
|
|
|
|
2015-06-16 23:16:17 +00:00
|
|
|
endfunction()
|
2011-05-28 04:53:17 +00:00
|
|
|
|
2010-11-05 04:18:53 +00:00
|
|
|
|
2016-07-14 09:11:33 +00:00
|
|
|
function(blender_add_lib_nolist
|
2019-04-17 04:35:54 +00:00
|
|
|
name
|
|
|
|
sources
|
|
|
|
includes
|
|
|
|
includes_sys
|
|
|
|
library_deps
|
|
|
|
)
|
2016-07-14 09:11:33 +00:00
|
|
|
|
2019-04-17 04:35:54 +00:00
|
|
|
add_cc_flags_custom_test(${name} PARENT_SCOPE)
|
2016-07-14 09:11:33 +00:00
|
|
|
|
2019-04-17 04:35:54 +00:00
|
|
|
blender_add_lib__impl(${name} "${sources}" "${includes}" "${includes_sys}" "${library_deps}")
|
2016-07-14 09:11:33 +00:00
|
|
|
endfunction()
|
|
|
|
|
2015-06-16 23:16:17 +00:00
|
|
|
function(blender_add_lib
|
2019-04-17 04:35:54 +00:00
|
|
|
name
|
|
|
|
sources
|
|
|
|
includes
|
|
|
|
includes_sys
|
|
|
|
library_deps
|
|
|
|
)
|
2006-11-17 02:27:12 +00:00
|
|
|
|
2019-04-17 04:35:54 +00:00
|
|
|
add_cc_flags_custom_test(${name} PARENT_SCOPE)
|
2016-07-14 09:11:33 +00:00
|
|
|
|
2019-04-17 04:35:54 +00:00
|
|
|
blender_add_lib__impl(${name} "${sources}" "${includes}" "${includes_sys}" "${library_deps}")
|
2006-11-17 02:27:12 +00:00
|
|
|
|
2019-04-17 04:35:54 +00:00
|
|
|
set_property(GLOBAL APPEND PROPERTY BLENDER_LINK_LIBS ${name})
|
2015-06-16 23:16:17 +00:00
|
|
|
endfunction()
|
|
|
|
|
CMake: Add support of Ninja's pools to ease building on limited amount of RAM.
Many modern computers support a lot of threads (parrallel building
jobs), but are somewhat restricted in memory, when some building jobs
can require several GB each.
Ninja builder has pools, which extend the usual `-j X` make
parallelizing option, by allowing to specify different numbers of
parallel jobs for different targets.
This commit defines three pools, one for linking, one for usual compile,
and one for compiling some 'heavy' cpp libs, when a single file can
require GB of RAM in full debug builds.
Simply enabling WITH_NINJA_POOL_JOBS will try to set default sensible
values for those three pools based on your machine specifications, you
can then tweak further the values of NINJA_MAX_NUM_PARALLEL_ settings,
if you like.
On my system (8 cores, 16GB RAM), it allows to build a full debug with
all ASAN options build with roughly 7GB of RAM used at most, pretty much
as quickly as without that option (which would require up to 11GB of
available RAM at some points).
Review task: D4780.
2019-05-07 18:32:14 +00:00
|
|
|
# Ninja only: assign 'heavy pool' to some targets that are especially RAM-consuming to build.
|
|
|
|
function(setup_heavy_lib_pool)
|
|
|
|
if(WITH_NINJA_POOL_JOBS AND NINJA_MAX_NUM_PARALLEL_COMPILE_HEAVY_JOBS)
|
|
|
|
if(WITH_CYCLES)
|
|
|
|
list(APPEND _HEAVY_LIBS "cycles_device" "cycles_kernel")
|
|
|
|
endif()
|
|
|
|
if(WITH_LIBMV)
|
|
|
|
list(APPEND _HEAVY_LIBS "bf_intern_libmv")
|
|
|
|
endif()
|
|
|
|
if(WITH_OPENVDB)
|
|
|
|
list(APPEND _HEAVY_LIBS "bf_intern_openvdb")
|
|
|
|
endif()
|
|
|
|
|
|
|
|
foreach(TARGET ${_HEAVY_LIBS})
|
|
|
|
if(TARGET ${TARGET})
|
|
|
|
set_property(TARGET ${TARGET} PROPERTY JOB_POOL_COMPILE compile_heavy_job_pool)
|
|
|
|
endif()
|
|
|
|
endforeach()
|
|
|
|
endif()
|
|
|
|
endfunction()
|
2006-11-17 02:27:12 +00:00
|
|
|
|
2015-06-16 23:16:17 +00:00
|
|
|
function(SETUP_LIBDIRS)
|
2011-05-28 04:53:17 +00:00
|
|
|
|
2019-04-17 04:35:54 +00:00
|
|
|
# NOTE: For all new libraries, use absolute library paths.
|
|
|
|
# This should eventually be phased out.
|
|
|
|
|
|
|
|
if(NOT MSVC)
|
|
|
|
link_directories(${JPEG_LIBPATH} ${PNG_LIBPATH} ${ZLIB_LIBPATH} ${FREETYPE_LIBPATH})
|
|
|
|
|
|
|
|
if(WITH_PYTHON) # AND NOT WITH_PYTHON_MODULE # WIN32 needs
|
|
|
|
link_directories(${PYTHON_LIBPATH})
|
|
|
|
endif()
|
|
|
|
if(WITH_SDL AND NOT WITH_SDL_DYNLOAD)
|
|
|
|
link_directories(${SDL_LIBPATH})
|
|
|
|
endif()
|
|
|
|
if(WITH_CODEC_FFMPEG)
|
|
|
|
link_directories(${FFMPEG_LIBPATH})
|
|
|
|
endif()
|
|
|
|
if(WITH_IMAGE_OPENEXR)
|
|
|
|
link_directories(${OPENEXR_LIBPATH})
|
|
|
|
endif()
|
|
|
|
if(WITH_IMAGE_TIFF)
|
|
|
|
link_directories(${TIFF_LIBPATH})
|
|
|
|
endif()
|
|
|
|
if(WITH_BOOST)
|
|
|
|
link_directories(${BOOST_LIBPATH})
|
|
|
|
endif()
|
|
|
|
if(WITH_OPENIMAGEIO)
|
|
|
|
link_directories(${OPENIMAGEIO_LIBPATH})
|
|
|
|
endif()
|
Compositor: Added denoising node
This node is built on Intel's OpenImageDenoise library.
Other denoisers could be integrated, for example Lukas' Cycles denoiser.
Compositor: Made OpenImageDenoise optional, added CMake and build_env files to find OIDN
Compositor: Fixed some warnings in the denoising operator
build_environment: Updated OpenImageDenoise to 0.8.1
build_environment: Updated OpenImageDenoise in `make deps` for macOS
Reviewers: sergey, jbakker, brecht
Reviewed By: brecht
Subscribers: YAFU, LazyDodo, Zen_YS, slumber, samgreen, tjvoll, yeus, ponomarovmax, getrad, coder.kalyan, vitos1k, Yegor, DeepBlender, kumaran7, Darkfie9825, aliasguru, aafra, ace_dragon, juang3d, pandrodor, cdog, lordodin, jtheninja, mavek, marcog, 5k1n2, Atair, rawalanche, 0o00o0oo, filibis, poor, lukasstockner97
Tags: #compositing
Differential Revision: https://developer.blender.org/D4304
2019-08-14 13:30:26 +00:00
|
|
|
if(WITH_OPENIMAGEDENOISE)
|
|
|
|
link_directories(${OPENIMAGEDENOISE_LIBPATH})
|
|
|
|
endif()
|
2019-04-17 04:35:54 +00:00
|
|
|
if(WITH_OPENCOLORIO)
|
|
|
|
link_directories(${OPENCOLORIO_LIBPATH})
|
|
|
|
endif()
|
|
|
|
if(WITH_OPENVDB)
|
|
|
|
link_directories(${OPENVDB_LIBPATH})
|
|
|
|
endif()
|
|
|
|
if(WITH_OPENAL)
|
|
|
|
link_directories(${OPENAL_LIBPATH})
|
|
|
|
endif()
|
|
|
|
if(WITH_JACK AND NOT WITH_JACK_DYNLOAD)
|
|
|
|
link_directories(${JACK_LIBPATH})
|
|
|
|
endif()
|
|
|
|
if(WITH_CODEC_SNDFILE)
|
|
|
|
link_directories(${LIBSNDFILE_LIBPATH})
|
|
|
|
endif()
|
|
|
|
if(WITH_FFTW3)
|
|
|
|
link_directories(${FFTW3_LIBPATH})
|
|
|
|
endif()
|
|
|
|
if(WITH_OPENCOLLADA)
|
|
|
|
link_directories(${OPENCOLLADA_LIBPATH})
|
2019-10-28 14:32:33 +00:00
|
|
|
# # Never set
|
2019-04-17 04:35:54 +00:00
|
|
|
# link_directories(${PCRE_LIBPATH})
|
|
|
|
# link_directories(${EXPAT_LIBPATH})
|
|
|
|
endif()
|
|
|
|
if(WITH_LLVM)
|
|
|
|
link_directories(${LLVM_LIBPATH})
|
|
|
|
endif()
|
|
|
|
|
|
|
|
if(WITH_ALEMBIC)
|
|
|
|
link_directories(${ALEMBIC_LIBPATH})
|
|
|
|
link_directories(${HDF5_LIBPATH})
|
|
|
|
endif()
|
|
|
|
|
|
|
|
if(WIN32 AND NOT UNIX)
|
|
|
|
link_directories(${PTHREADS_LIBPATH})
|
|
|
|
endif()
|
|
|
|
endif()
|
2015-06-16 23:16:17 +00:00
|
|
|
endfunction()
|
2010-12-08 08:43:06 +00:00
|
|
|
|
2018-05-31 17:50:30 +00:00
|
|
|
macro(setup_platform_linker_flags)
|
2019-04-17 04:35:54 +00:00
|
|
|
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${PLATFORM_LINKFLAGS}")
|
2019-11-08 16:01:00 +00:00
|
|
|
set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} ${PLATFORM_LINKFLAGS_RELEASE}")
|
2019-04-17 04:35:54 +00:00
|
|
|
set(CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG} ${PLATFORM_LINKFLAGS_DEBUG}")
|
2018-05-31 17:50:30 +00:00
|
|
|
endmacro()
|
|
|
|
|
2015-06-16 23:16:17 +00:00
|
|
|
function(setup_liblinks
|
2019-04-17 04:35:54 +00:00
|
|
|
target
|
|
|
|
)
|
|
|
|
|
|
|
|
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${PLATFORM_LINKFLAGS}" PARENT_SCOPE)
|
|
|
|
set(CMAKE_EXE_LINKER_FLAGS_DEBUG "${CMAKE_EXE_LINKER_FLAGS_DEBUG} ${PLATFORM_LINKFLAGS_DEBUG}" PARENT_SCOPE)
|
2019-11-08 16:01:00 +00:00
|
|
|
set(CMAKE_EXE_LINKER_FLAGS_RELEASE "${CMAKE_EXE_LINKER_FLAGS_RELEASE} ${PLATFORM_LINKFLAGS_RELEASE}" PARENT_SCOPE)
|
2019-04-17 04:35:54 +00:00
|
|
|
|
|
|
|
set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} ${PLATFORM_LINKFLAGS}" PARENT_SCOPE)
|
|
|
|
set(CMAKE_SHARED_LINKER_FLAGS_DEBUG "${CMAKE_SHARED_LINKER_FLAGS_DEBUG} ${PLATFORM_LINKFLAGS_DEBUG}" PARENT_SCOPE)
|
2019-11-08 16:01:00 +00:00
|
|
|
set(CMAKE_SHARED_LINKER_FLAGS_RELEASE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE} ${PLATFORM_LINKFLAGS_RELEASE}" PARENT_SCOPE)
|
2019-04-17 04:35:54 +00:00
|
|
|
|
|
|
|
set(CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS} ${PLATFORM_LINKFLAGS}" PARENT_SCOPE)
|
|
|
|
set(CMAKE_MODULE_LINKER_FLAGS_DEBUG "${CMAKE_MODULE_LINKER_FLAGS_DEBUG} ${PLATFORM_LINKFLAGS_DEBUG}" PARENT_SCOPE)
|
2019-11-08 16:01:00 +00:00
|
|
|
set(CMAKE_MODULE_LINKER_FLAGS_RELEASE "${CMAKE_MODULE_LINKER_FLAGS_RELEASE} ${PLATFORM_LINKFLAGS_RELEASE}" PARENT_SCOPE)
|
2019-04-17 04:35:54 +00:00
|
|
|
|
|
|
|
# jemalloc must be early in the list, to be before pthread (see T57998)
|
|
|
|
if(WITH_MEM_JEMALLOC)
|
|
|
|
target_link_libraries(${target} ${JEMALLOC_LIBRARIES})
|
|
|
|
endif()
|
|
|
|
|
|
|
|
target_link_libraries(
|
|
|
|
${target}
|
|
|
|
${PNG_LIBRARIES}
|
|
|
|
${FREETYPE_LIBRARY}
|
|
|
|
)
|
|
|
|
|
|
|
|
|
2019-04-17 19:26:02 +00:00
|
|
|
if(WITH_PYTHON)
|
|
|
|
target_link_libraries(${target} ${PYTHON_LINKFLAGS})
|
|
|
|
target_link_libraries(${target} ${PYTHON_LIBRARIES})
|
2019-04-17 04:35:54 +00:00
|
|
|
endif()
|
|
|
|
|
|
|
|
if(WITH_LZO AND WITH_SYSTEM_LZO)
|
|
|
|
target_link_libraries(${target} ${LZO_LIBRARIES})
|
|
|
|
endif()
|
|
|
|
if(WITH_SYSTEM_GLEW)
|
|
|
|
target_link_libraries(${target} ${BLENDER_GLEW_LIBRARIES})
|
|
|
|
endif()
|
|
|
|
if(WITH_BULLET AND WITH_SYSTEM_BULLET)
|
|
|
|
target_link_libraries(${target} ${BULLET_LIBRARIES})
|
|
|
|
endif()
|
|
|
|
if(WITH_AUDASPACE AND WITH_SYSTEM_AUDASPACE)
|
|
|
|
target_link_libraries(${target} ${AUDASPACE_C_LIBRARIES} ${AUDASPACE_PY_LIBRARIES})
|
|
|
|
endif()
|
|
|
|
if(WITH_OPENAL)
|
|
|
|
target_link_libraries(${target} ${OPENAL_LIBRARY})
|
|
|
|
endif()
|
|
|
|
if(WITH_FFTW3)
|
|
|
|
target_link_libraries(${target} ${FFTW3_LIBRARIES})
|
|
|
|
endif()
|
|
|
|
if(WITH_JACK AND NOT WITH_JACK_DYNLOAD)
|
|
|
|
target_link_libraries(${target} ${JACK_LIBRARIES})
|
|
|
|
endif()
|
|
|
|
if(WITH_CODEC_SNDFILE)
|
|
|
|
target_link_libraries(${target} ${LIBSNDFILE_LIBRARIES})
|
|
|
|
endif()
|
|
|
|
if(WITH_SDL AND NOT WITH_SDL_DYNLOAD)
|
|
|
|
target_link_libraries(${target} ${SDL_LIBRARY})
|
|
|
|
endif()
|
|
|
|
if(WITH_CYCLES_OSL)
|
|
|
|
target_link_libraries(${target} ${OSL_LIBRARIES})
|
|
|
|
endif()
|
|
|
|
if(WITH_OPENVDB)
|
2019-10-09 14:44:29 +00:00
|
|
|
target_link_libraries(${target} ${OPENVDB_LIBRARIES} ${BLOSC_LIBRARIES})
|
2019-04-17 04:35:54 +00:00
|
|
|
endif()
|
|
|
|
if(WITH_OPENIMAGEIO)
|
|
|
|
target_link_libraries(${target} ${OPENIMAGEIO_LIBRARIES})
|
|
|
|
endif()
|
Compositor: Added denoising node
This node is built on Intel's OpenImageDenoise library.
Other denoisers could be integrated, for example Lukas' Cycles denoiser.
Compositor: Made OpenImageDenoise optional, added CMake and build_env files to find OIDN
Compositor: Fixed some warnings in the denoising operator
build_environment: Updated OpenImageDenoise to 0.8.1
build_environment: Updated OpenImageDenoise in `make deps` for macOS
Reviewers: sergey, jbakker, brecht
Reviewed By: brecht
Subscribers: YAFU, LazyDodo, Zen_YS, slumber, samgreen, tjvoll, yeus, ponomarovmax, getrad, coder.kalyan, vitos1k, Yegor, DeepBlender, kumaran7, Darkfie9825, aliasguru, aafra, ace_dragon, juang3d, pandrodor, cdog, lordodin, jtheninja, mavek, marcog, 5k1n2, Atair, rawalanche, 0o00o0oo, filibis, poor, lukasstockner97
Tags: #compositing
Differential Revision: https://developer.blender.org/D4304
2019-08-14 13:30:26 +00:00
|
|
|
if(WITH_OPENIMAGEDENOISE)
|
2019-10-09 14:44:29 +00:00
|
|
|
target_link_libraries(${target} ${OPENIMAGEDENOISE_LIBRARIES})
|
|
|
|
endif()
|
|
|
|
if(WITH_TBB)
|
|
|
|
target_link_libraries(${target} ${TBB_LIBRARIES})
|
Compositor: Added denoising node
This node is built on Intel's OpenImageDenoise library.
Other denoisers could be integrated, for example Lukas' Cycles denoiser.
Compositor: Made OpenImageDenoise optional, added CMake and build_env files to find OIDN
Compositor: Fixed some warnings in the denoising operator
build_environment: Updated OpenImageDenoise to 0.8.1
build_environment: Updated OpenImageDenoise in `make deps` for macOS
Reviewers: sergey, jbakker, brecht
Reviewed By: brecht
Subscribers: YAFU, LazyDodo, Zen_YS, slumber, samgreen, tjvoll, yeus, ponomarovmax, getrad, coder.kalyan, vitos1k, Yegor, DeepBlender, kumaran7, Darkfie9825, aliasguru, aafra, ace_dragon, juang3d, pandrodor, cdog, lordodin, jtheninja, mavek, marcog, 5k1n2, Atair, rawalanche, 0o00o0oo, filibis, poor, lukasstockner97
Tags: #compositing
Differential Revision: https://developer.blender.org/D4304
2019-08-14 13:30:26 +00:00
|
|
|
endif()
|
2019-04-17 04:35:54 +00:00
|
|
|
if(WITH_OPENCOLORIO)
|
|
|
|
target_link_libraries(${target} ${OPENCOLORIO_LIBRARIES})
|
|
|
|
endif()
|
|
|
|
if(WITH_OPENSUBDIV)
|
|
|
|
target_link_libraries(${target} ${OPENSUBDIV_LIBRARIES})
|
|
|
|
endif()
|
|
|
|
if(WITH_CYCLES_EMBREE)
|
|
|
|
target_link_libraries(${target} ${EMBREE_LIBRARIES})
|
|
|
|
endif()
|
|
|
|
if(WITH_BOOST)
|
|
|
|
target_link_libraries(${target} ${BOOST_LIBRARIES})
|
|
|
|
if(Boost_USE_STATIC_LIBS AND Boost_USE_ICU)
|
|
|
|
target_link_libraries(${target} ${ICU_LIBRARIES})
|
|
|
|
endif()
|
|
|
|
endif()
|
|
|
|
target_link_libraries(${target} ${JPEG_LIBRARIES})
|
|
|
|
if(WITH_ALEMBIC)
|
|
|
|
target_link_libraries(${target} ${ALEMBIC_LIBRARIES} ${HDF5_LIBRARIES})
|
|
|
|
endif()
|
|
|
|
if(WITH_IMAGE_TIFF)
|
|
|
|
target_link_libraries(${target} ${TIFF_LIBRARY})
|
|
|
|
endif()
|
|
|
|
if(WITH_IMAGE_OPENEXR)
|
|
|
|
target_link_libraries(${target} ${OPENEXR_LIBRARIES})
|
|
|
|
endif()
|
|
|
|
if(WITH_IMAGE_OPENJPEG)
|
|
|
|
target_link_libraries(${target} ${OPENJPEG_LIBRARIES})
|
|
|
|
endif()
|
|
|
|
if(WITH_CODEC_FFMPEG)
|
|
|
|
target_link_libraries(${target} ${FFMPEG_LIBRARIES})
|
|
|
|
endif()
|
|
|
|
if(WITH_OPENCOLLADA)
|
|
|
|
if(WIN32 AND NOT UNIX)
|
|
|
|
file_list_suffix(OPENCOLLADA_LIBRARIES_DEBUG "${OPENCOLLADA_LIBRARIES}" "_d")
|
|
|
|
target_link_libraries_debug(${target} "${OPENCOLLADA_LIBRARIES_DEBUG}")
|
|
|
|
target_link_libraries_optimized(${target} "${OPENCOLLADA_LIBRARIES}")
|
|
|
|
unset(OPENCOLLADA_LIBRARIES_DEBUG)
|
|
|
|
|
|
|
|
file_list_suffix(PCRE_LIBRARIES_DEBUG "${PCRE_LIBRARIES}" "_d")
|
|
|
|
target_link_libraries_debug(${target} "${PCRE_LIBRARIES_DEBUG}")
|
|
|
|
target_link_libraries_optimized(${target} "${PCRE_LIBRARIES}")
|
|
|
|
unset(PCRE_LIBRARIES_DEBUG)
|
|
|
|
|
|
|
|
if(EXPAT_LIB)
|
|
|
|
file_list_suffix(EXPAT_LIB_DEBUG "${EXPAT_LIB}" "_d")
|
|
|
|
target_link_libraries_debug(${target} "${EXPAT_LIB_DEBUG}")
|
|
|
|
target_link_libraries_optimized(${target} "${EXPAT_LIB}")
|
|
|
|
unset(EXPAT_LIB_DEBUG)
|
|
|
|
endif()
|
|
|
|
else()
|
|
|
|
target_link_libraries(
|
|
|
|
${target}
|
|
|
|
${OPENCOLLADA_LIBRARIES}
|
|
|
|
${PCRE_LIBRARIES}
|
|
|
|
${XML2_LIBRARIES}
|
|
|
|
${EXPAT_LIB}
|
|
|
|
)
|
|
|
|
endif()
|
|
|
|
endif()
|
|
|
|
if(WITH_LLVM)
|
|
|
|
target_link_libraries(${target} ${LLVM_LIBRARY})
|
|
|
|
endif()
|
|
|
|
if(WIN32 AND NOT UNIX)
|
|
|
|
target_link_libraries(${target} ${PTHREADS_LIBRARIES})
|
|
|
|
endif()
|
|
|
|
if(UNIX AND NOT APPLE)
|
|
|
|
if(WITH_OPENMP_STATIC)
|
|
|
|
target_link_libraries(${target} ${OpenMP_LIBRARIES})
|
|
|
|
endif()
|
|
|
|
if(WITH_INPUT_NDOF)
|
|
|
|
target_link_libraries(${target} ${NDOF_LIBRARIES})
|
|
|
|
endif()
|
|
|
|
endif()
|
|
|
|
if(WITH_SYSTEM_GLOG)
|
|
|
|
target_link_libraries(${target} ${GLOG_LIBRARIES})
|
|
|
|
endif()
|
|
|
|
if(WITH_SYSTEM_GFLAGS)
|
|
|
|
target_link_libraries(${target} ${GFLAGS_LIBRARIES})
|
|
|
|
endif()
|
|
|
|
|
|
|
|
# We put CLEW and CUEW here because OPENSUBDIV_LIBRARIES depends on them..
|
|
|
|
if(WITH_CYCLES OR WITH_COMPOSITOR OR WITH_OPENSUBDIV)
|
|
|
|
target_link_libraries(${target} "extern_clew")
|
|
|
|
if(WITH_CUDA_DYNLOAD)
|
|
|
|
target_link_libraries(${target} "extern_cuew")
|
|
|
|
else()
|
|
|
|
target_link_libraries(${target} ${CUDA_CUDA_LIBRARY})
|
|
|
|
endif()
|
|
|
|
endif()
|
|
|
|
|
|
|
|
target_link_libraries(
|
|
|
|
${target}
|
|
|
|
${ZLIB_LIBRARIES}
|
|
|
|
)
|
|
|
|
|
2019-10-28 14:32:33 +00:00
|
|
|
# System libraries with no dependencies such as platform link libs or opengl should go last.
|
2019-04-17 04:35:54 +00:00
|
|
|
target_link_libraries(${target}
|
|
|
|
${BLENDER_GL_LIBRARIES})
|
|
|
|
|
2019-10-28 14:32:33 +00:00
|
|
|
# target_link_libraries(${target} ${PLATFORM_LINKLIBS} ${CMAKE_DL_LIBS})
|
2019-04-17 04:35:54 +00:00
|
|
|
target_link_libraries(${target} ${PLATFORM_LINKLIBS})
|
2015-06-16 23:16:17 +00:00
|
|
|
endfunction()
|
|
|
|
|
2011-10-01 18:29:40 +00:00
|
|
|
macro(TEST_SSE_SUPPORT
|
2019-04-17 04:35:54 +00:00
|
|
|
_sse_flags
|
|
|
|
_sse2_flags)
|
|
|
|
|
|
|
|
include(CheckCSourceRuns)
|
|
|
|
|
|
|
|
# message(STATUS "Detecting SSE support")
|
|
|
|
if(CMAKE_COMPILER_IS_GNUCC OR (CMAKE_C_COMPILER_ID MATCHES "Clang"))
|
|
|
|
set(${_sse_flags} "-msse")
|
|
|
|
set(${_sse2_flags} "-msse2")
|
|
|
|
elseif(MSVC)
|
|
|
|
# x86_64 has this auto enabled
|
|
|
|
if("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
|
|
|
|
set(${_sse_flags} "")
|
|
|
|
set(${_sse2_flags} "")
|
|
|
|
else()
|
|
|
|
set(${_sse_flags} "/arch:SSE")
|
|
|
|
set(${_sse2_flags} "/arch:SSE2")
|
|
|
|
endif()
|
|
|
|
elseif(CMAKE_C_COMPILER_ID MATCHES "Intel")
|
|
|
|
set(${_sse_flags} "") # icc defaults to -msse
|
|
|
|
set(${_sse2_flags} "") # icc defaults to -msse2
|
|
|
|
else()
|
|
|
|
message(WARNING "SSE flags for this compiler: '${CMAKE_C_COMPILER_ID}' not known")
|
|
|
|
set(${_sse_flags})
|
|
|
|
set(${_sse2_flags})
|
|
|
|
endif()
|
|
|
|
|
|
|
|
set(CMAKE_REQUIRED_FLAGS "${${_sse_flags}} ${${_sse2_flags}}")
|
|
|
|
|
|
|
|
if(NOT DEFINED SUPPORT_SSE_BUILD)
|
|
|
|
# result cached
|
|
|
|
check_c_source_runs("
|
|
|
|
#include <xmmintrin.h>
|
|
|
|
int main(void) { __m128 v = _mm_setzero_ps(); return 0; }"
|
|
|
|
SUPPORT_SSE_BUILD)
|
|
|
|
|
|
|
|
if(SUPPORT_SSE_BUILD)
|
|
|
|
message(STATUS "SSE Support: detected.")
|
|
|
|
else()
|
|
|
|
message(STATUS "SSE Support: missing.")
|
|
|
|
endif()
|
|
|
|
endif()
|
|
|
|
|
|
|
|
if(NOT DEFINED SUPPORT_SSE2_BUILD)
|
|
|
|
# result cached
|
|
|
|
check_c_source_runs("
|
|
|
|
#include <emmintrin.h>
|
|
|
|
int main(void) { __m128d v = _mm_setzero_pd(); return 0; }"
|
|
|
|
SUPPORT_SSE2_BUILD)
|
|
|
|
|
|
|
|
if(SUPPORT_SSE2_BUILD)
|
|
|
|
message(STATUS "SSE2 Support: detected.")
|
|
|
|
else()
|
|
|
|
message(STATUS "SSE2 Support: missing.")
|
|
|
|
endif()
|
|
|
|
endif()
|
|
|
|
|
|
|
|
unset(CMAKE_REQUIRED_FLAGS)
|
2010-12-08 08:43:06 +00:00
|
|
|
endmacro()
|
2010-07-04 18:40:59 +00:00
|
|
|
|
2016-01-14 07:57:58 +00:00
|
|
|
# Only print message if running CMake first time
|
|
|
|
macro(message_first_run)
|
2019-04-17 04:35:54 +00:00
|
|
|
if(FIRST_RUN)
|
|
|
|
message(${ARGV})
|
|
|
|
endif()
|
2016-01-14 07:57:58 +00:00
|
|
|
endmacro()
|
|
|
|
|
2010-10-24 03:57:07 +00:00
|
|
|
# when we have warnings as errors applied globally this
|
|
|
|
# needs to be removed for some external libs which we dont maintain.
|
|
|
|
|
|
|
|
# utility macro
|
2011-10-27 07:26:41 +00:00
|
|
|
macro(remove_cc_flag
|
2019-04-17 04:35:54 +00:00
|
|
|
_flag)
|
|
|
|
|
|
|
|
foreach(flag ${ARGV})
|
|
|
|
string(REGEX REPLACE ${flag} "" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
|
|
|
|
string(REGEX REPLACE ${flag} "" CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}")
|
|
|
|
string(REGEX REPLACE ${flag} "" CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE}")
|
|
|
|
string(REGEX REPLACE ${flag} "" CMAKE_C_FLAGS_MINSIZEREL "${CMAKE_C_FLAGS_MINSIZEREL}")
|
|
|
|
string(REGEX REPLACE ${flag} "" CMAKE_C_FLAGS_RELWITHDEBINFO "${CMAKE_C_FLAGS_RELWITHDEBINFO}")
|
|
|
|
|
|
|
|
string(REGEX REPLACE ${flag} "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
|
|
|
|
string(REGEX REPLACE ${flag} "" CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}")
|
|
|
|
string(REGEX REPLACE ${flag} "" CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}")
|
|
|
|
string(REGEX REPLACE ${flag} "" CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL}")
|
|
|
|
string(REGEX REPLACE ${flag} "" CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO}")
|
|
|
|
endforeach()
|
|
|
|
unset(flag)
|
2010-12-08 08:43:06 +00:00
|
|
|
|
|
|
|
endmacro()
|
|
|
|
|
2018-06-22 12:29:13 +00:00
|
|
|
macro(add_c_flag
|
2019-04-17 04:35:54 +00:00
|
|
|
flag)
|
2011-10-27 07:26:41 +00:00
|
|
|
|
2019-04-17 04:35:54 +00:00
|
|
|
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${flag}")
|
|
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${flag}")
|
2011-10-27 07:26:41 +00:00
|
|
|
endmacro()
|
|
|
|
|
2018-06-22 12:07:55 +00:00
|
|
|
macro(add_cxx_flag
|
2019-04-17 04:35:54 +00:00
|
|
|
flag)
|
2018-06-22 12:07:55 +00:00
|
|
|
|
2019-04-17 04:35:54 +00:00
|
|
|
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${flag}")
|
2018-06-22 12:07:55 +00:00
|
|
|
endmacro()
|
|
|
|
|
2010-12-08 08:43:06 +00:00
|
|
|
macro(remove_strict_flags)
|
|
|
|
|
2019-04-17 04:35:54 +00:00
|
|
|
if(CMAKE_COMPILER_IS_GNUCC)
|
|
|
|
remove_cc_flag(
|
|
|
|
"-Wstrict-prototypes"
|
|
|
|
"-Wmissing-prototypes"
|
|
|
|
"-Wmissing-declarations"
|
|
|
|
"-Wmissing-format-attribute"
|
|
|
|
"-Wunused-local-typedefs"
|
|
|
|
"-Wunused-macros"
|
|
|
|
"-Wunused-parameter"
|
|
|
|
"-Wwrite-strings"
|
|
|
|
"-Wredundant-decls"
|
|
|
|
"-Wundef"
|
|
|
|
"-Wshadow"
|
|
|
|
"-Wdouble-promotion"
|
|
|
|
"-Wold-style-definition"
|
|
|
|
"-Werror=[^ ]+"
|
|
|
|
"-Werror"
|
|
|
|
)
|
|
|
|
|
|
|
|
# negate flags implied by '-Wall'
|
|
|
|
add_c_flag("${C_REMOVE_STRICT_FLAGS}")
|
|
|
|
add_cxx_flag("${CXX_REMOVE_STRICT_FLAGS}")
|
|
|
|
endif()
|
|
|
|
|
|
|
|
if(CMAKE_C_COMPILER_ID MATCHES "Clang")
|
|
|
|
remove_cc_flag(
|
|
|
|
"-Wunused-parameter"
|
|
|
|
"-Wunused-variable"
|
|
|
|
"-Werror=[^ ]+"
|
|
|
|
"-Werror"
|
|
|
|
)
|
|
|
|
|
|
|
|
# negate flags implied by '-Wall'
|
|
|
|
add_c_flag("${C_REMOVE_STRICT_FLAGS}")
|
|
|
|
add_cxx_flag("${CXX_REMOVE_STRICT_FLAGS}")
|
|
|
|
endif()
|
|
|
|
|
|
|
|
if(MSVC)
|
2019-09-09 20:11:52 +00:00
|
|
|
remove_cc_flag(/w34189) # Restore warn C4189 (unused variable) back to w4
|
2019-04-17 04:35:54 +00:00
|
|
|
endif()
|
2010-10-24 03:57:07 +00:00
|
|
|
|
2010-12-08 08:43:06 +00:00
|
|
|
endmacro()
|
2010-10-24 03:57:07 +00:00
|
|
|
|
2015-03-27 10:55:58 +00:00
|
|
|
macro(remove_extra_strict_flags)
|
2019-04-17 04:35:54 +00:00
|
|
|
if(CMAKE_COMPILER_IS_GNUCC)
|
|
|
|
remove_cc_flag(
|
|
|
|
"-Wunused-parameter"
|
|
|
|
)
|
|
|
|
endif()
|
|
|
|
|
|
|
|
if(CMAKE_C_COMPILER_ID MATCHES "Clang")
|
|
|
|
remove_cc_flag(
|
|
|
|
"-Wunused-parameter"
|
|
|
|
)
|
|
|
|
endif()
|
|
|
|
|
|
|
|
if(MSVC)
|
|
|
|
# TODO
|
|
|
|
endif()
|
2015-03-27 10:55:58 +00:00
|
|
|
endmacro()
|
|
|
|
|
2011-10-23 17:52:20 +00:00
|
|
|
# note, we can only append flags on a single file so we need to negate the options.
|
|
|
|
# at the moment we cant shut up ffmpeg deprecations, so use this, but will
|
|
|
|
# probably add more removals here.
|
2018-06-22 12:40:00 +00:00
|
|
|
macro(remove_strict_c_flags_file
|
2019-04-17 04:35:54 +00:00
|
|
|
filenames)
|
|
|
|
foreach(_SOURCE ${ARGV})
|
|
|
|
if(CMAKE_COMPILER_IS_GNUCC OR
|
|
|
|
(CMAKE_C_COMPILER_ID MATCHES "Clang"))
|
|
|
|
set_source_files_properties(${_SOURCE}
|
|
|
|
PROPERTIES
|
|
|
|
COMPILE_FLAGS "${C_REMOVE_STRICT_FLAGS}"
|
|
|
|
)
|
|
|
|
endif()
|
|
|
|
if(MSVC)
|
|
|
|
# TODO
|
|
|
|
endif()
|
|
|
|
endforeach()
|
|
|
|
unset(_SOURCE)
|
2018-06-22 12:40:00 +00:00
|
|
|
endmacro()
|
2011-10-23 17:52:20 +00:00
|
|
|
|
2018-06-22 12:40:00 +00:00
|
|
|
macro(remove_strict_cxx_flags_file
|
2019-04-17 04:35:54 +00:00
|
|
|
filenames)
|
|
|
|
remove_strict_c_flags_file(${filenames} ${ARHV})
|
|
|
|
foreach(_SOURCE ${ARGV})
|
|
|
|
if(CMAKE_COMPILER_IS_GNUCC OR
|
|
|
|
(CMAKE_CXX_COMPILER_ID MATCHES "Clang"))
|
|
|
|
set_source_files_properties(${_SOURCE}
|
|
|
|
PROPERTIES
|
|
|
|
COMPILE_FLAGS "${CXX_REMOVE_STRICT_FLAGS}"
|
|
|
|
)
|
|
|
|
endif()
|
|
|
|
if(MSVC)
|
|
|
|
# TODO
|
|
|
|
endif()
|
|
|
|
endforeach()
|
|
|
|
unset(_SOURCE)
|
2011-10-23 17:52:20 +00:00
|
|
|
endmacro()
|
|
|
|
|
2016-05-18 21:36:32 +00:00
|
|
|
# External libs may need 'signed char' to be default.
|
|
|
|
macro(remove_cc_flag_unsigned_char)
|
2019-04-17 04:35:54 +00:00
|
|
|
if(CMAKE_COMPILER_IS_GNUCC OR
|
|
|
|
(CMAKE_C_COMPILER_ID MATCHES "Clang") OR
|
|
|
|
(CMAKE_C_COMPILER_ID MATCHES "Intel"))
|
|
|
|
remove_cc_flag("-funsigned-char")
|
|
|
|
elseif(MSVC)
|
|
|
|
remove_cc_flag("/J")
|
|
|
|
else()
|
|
|
|
message(WARNING
|
|
|
|
"Compiler '${CMAKE_C_COMPILER_ID}' failed to disable 'unsigned char' flag."
|
|
|
|
"Build files need updating."
|
|
|
|
)
|
|
|
|
endif()
|
2016-05-18 21:36:32 +00:00
|
|
|
endmacro()
|
2011-10-23 17:52:20 +00:00
|
|
|
|
2015-06-16 23:16:17 +00:00
|
|
|
function(ADD_CHECK_C_COMPILER_FLAG
|
2019-04-17 04:35:54 +00:00
|
|
|
_CFLAGS
|
|
|
|
_CACHE_VAR
|
|
|
|
_FLAG
|
|
|
|
)
|
|
|
|
|
|
|
|
include(CheckCCompilerFlag)
|
|
|
|
|
|
|
|
CHECK_C_COMPILER_FLAG("${_FLAG}" "${_CACHE_VAR}")
|
|
|
|
if(${_CACHE_VAR})
|
|
|
|
# message(STATUS "Using CFLAG: ${_FLAG}")
|
|
|
|
set(${_CFLAGS} "${${_CFLAGS}} ${_FLAG}" PARENT_SCOPE)
|
|
|
|
else()
|
|
|
|
message(STATUS "Unsupported CFLAG: ${_FLAG}")
|
|
|
|
endif()
|
2015-06-16 23:16:17 +00:00
|
|
|
endfunction()
|
2010-12-16 09:55:35 +00:00
|
|
|
|
2015-06-16 23:16:17 +00:00
|
|
|
function(ADD_CHECK_CXX_COMPILER_FLAG
|
2019-04-17 04:35:54 +00:00
|
|
|
_CXXFLAGS
|
|
|
|
_CACHE_VAR
|
|
|
|
_FLAG
|
|
|
|
)
|
|
|
|
|
|
|
|
include(CheckCXXCompilerFlag)
|
|
|
|
|
|
|
|
CHECK_CXX_COMPILER_FLAG("${_FLAG}" "${_CACHE_VAR}")
|
|
|
|
if(${_CACHE_VAR})
|
|
|
|
# message(STATUS "Using CXXFLAG: ${_FLAG}")
|
|
|
|
set(${_CXXFLAGS} "${${_CXXFLAGS}} ${_FLAG}" PARENT_SCOPE)
|
|
|
|
else()
|
|
|
|
message(STATUS "Unsupported CXXFLAG: ${_FLAG}")
|
|
|
|
endif()
|
2015-06-16 23:16:17 +00:00
|
|
|
endfunction()
|
2010-08-02 16:23:58 +00:00
|
|
|
|
2014-11-16 11:57:42 +00:00
|
|
|
function(get_blender_version)
|
2019-04-17 04:35:54 +00:00
|
|
|
# extracts header vars and defines them in the parent scope:
|
|
|
|
#
|
|
|
|
# - BLENDER_VERSION (major.minor)
|
|
|
|
# - BLENDER_VERSION_MAJOR
|
|
|
|
# - BLENDER_VERSION_MINOR
|
|
|
|
# - BLENDER_SUBVERSION (used for internal versioning mainly)
|
|
|
|
# - BLENDER_VERSION_CHAR (a, b, c, ...or empty string)
|
|
|
|
# - BLENDER_VERSION_CYCLE (alpha, beta, rc, release)
|
|
|
|
|
|
|
|
# So cmake depends on BKE_blender.h, beware of inf-loops!
|
|
|
|
CONFIGURE_FILE(${CMAKE_SOURCE_DIR}/source/blender/blenkernel/BKE_blender_version.h
|
|
|
|
${CMAKE_BINARY_DIR}/source/blender/blenkernel/BKE_blender_version.h.done)
|
|
|
|
|
|
|
|
file(STRINGS ${CMAKE_SOURCE_DIR}/source/blender/blenkernel/BKE_blender_version.h _contents REGEX "^#define[ \t]+BLENDER_.*$")
|
|
|
|
|
|
|
|
string(REGEX REPLACE ".*#define[ \t]+BLENDER_VERSION[ \t]+([0-9]+).*" "\\1" _out_version "${_contents}")
|
|
|
|
string(REGEX REPLACE ".*#define[ \t]+BLENDER_SUBVERSION[ \t]+([0-9]+).*" "\\1" _out_subversion "${_contents}")
|
|
|
|
string(REGEX REPLACE ".*#define[ \t]+BLENDER_VERSION_CHAR[ \t]+([a-z]+).*" "\\1" _out_version_char "${_contents}")
|
|
|
|
string(REGEX REPLACE ".*#define[ \t]+BLENDER_VERSION_CYCLE[ \t]+([a-z]+).*" "\\1" _out_version_cycle "${_contents}")
|
|
|
|
|
|
|
|
if(NOT ${_out_version} MATCHES "[0-9]+")
|
|
|
|
message(FATAL_ERROR "Version parsing failed for BLENDER_VERSION")
|
|
|
|
endif()
|
|
|
|
|
|
|
|
if(NOT ${_out_subversion} MATCHES "[0-9]+")
|
|
|
|
message(FATAL_ERROR "Version parsing failed for BLENDER_SUBVERSION")
|
|
|
|
endif()
|
|
|
|
|
|
|
|
# clumsy regex, only single char are ok but it could be unset
|
|
|
|
|
|
|
|
string(LENGTH "${_out_version_char}" _out_version_char_len)
|
|
|
|
if(NOT _out_version_char_len EQUAL 1)
|
|
|
|
set(_out_version_char "")
|
|
|
|
elseif(NOT ${_out_version_char} MATCHES "[a-z]+")
|
|
|
|
message(FATAL_ERROR "Version parsing failed for BLENDER_VERSION_CHAR")
|
|
|
|
endif()
|
|
|
|
|
|
|
|
if(NOT ${_out_version_cycle} MATCHES "[a-z]+")
|
|
|
|
message(FATAL_ERROR "Version parsing failed for BLENDER_VERSION_CYCLE")
|
|
|
|
endif()
|
|
|
|
|
|
|
|
math(EXPR _out_version_major "${_out_version} / 100")
|
|
|
|
math(EXPR _out_version_minor "${_out_version} % 100")
|
|
|
|
|
|
|
|
# for packaging, alpha to numbers
|
|
|
|
string(COMPARE EQUAL "${_out_version_char}" "" _out_version_char_empty)
|
|
|
|
if(${_out_version_char_empty})
|
|
|
|
set(_out_version_char_index "0")
|
|
|
|
else()
|
|
|
|
set(_char_ls a b c d e f g h i j k l m n o p q r s t u v w x y z)
|
|
|
|
list(FIND _char_ls ${_out_version_char} _out_version_char_index)
|
|
|
|
math(EXPR _out_version_char_index "${_out_version_char_index} + 1")
|
|
|
|
endif()
|
|
|
|
|
|
|
|
# output vars
|
|
|
|
set(BLENDER_VERSION "${_out_version_major}.${_out_version_minor}" PARENT_SCOPE)
|
|
|
|
set(BLENDER_VERSION_MAJOR "${_out_version_major}" PARENT_SCOPE)
|
|
|
|
set(BLENDER_VERSION_MINOR "${_out_version_minor}" PARENT_SCOPE)
|
|
|
|
set(BLENDER_SUBVERSION "${_out_subversion}" PARENT_SCOPE)
|
|
|
|
set(BLENDER_VERSION_CHAR "${_out_version_char}" PARENT_SCOPE)
|
|
|
|
set(BLENDER_VERSION_CHAR_INDEX "${_out_version_char_index}" PARENT_SCOPE)
|
|
|
|
set(BLENDER_VERSION_CYCLE "${_out_version_cycle}" PARENT_SCOPE)
|
2015-02-25 07:15:54 +00:00
|
|
|
|
2014-11-16 11:57:42 +00:00
|
|
|
endfunction()
|
2011-05-23 14:56:14 +00:00
|
|
|
|
|
|
|
|
|
|
|
# hacks to override initial project settings
|
2011-09-30 15:51:58 +00:00
|
|
|
# these macros must be called directly before/after project(Blender)
|
2011-05-23 14:56:14 +00:00
|
|
|
macro(blender_project_hack_pre)
|
2019-04-17 04:35:54 +00:00
|
|
|
# ------------------
|
|
|
|
# GCC -O3 HACK START
|
|
|
|
# needed because O3 can cause problems but
|
|
|
|
# allow the builder to set O3 manually after.
|
|
|
|
if(DEFINED CMAKE_C_FLAGS_RELEASE)
|
|
|
|
set(_reset_standard_cflags_rel OFF)
|
|
|
|
else()
|
|
|
|
set(_reset_standard_cflags_rel ON)
|
|
|
|
endif()
|
|
|
|
if(DEFINED CMAKE_CXX_FLAGS_RELEASE)
|
|
|
|
set(_reset_standard_cxxflags_rel OFF)
|
|
|
|
else()
|
|
|
|
set(_reset_standard_cxxflags_rel ON)
|
|
|
|
endif()
|
2011-05-23 14:56:14 +00:00
|
|
|
endmacro()
|
|
|
|
|
|
|
|
|
|
|
|
macro(blender_project_hack_post)
|
2019-04-17 04:35:54 +00:00
|
|
|
# ----------------
|
|
|
|
# GCC -O3 HACK END
|
|
|
|
if(_reset_standard_cflags_rel)
|
|
|
|
string(REGEX REPLACE "-O3" "-O2" CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE}")
|
|
|
|
set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE}" CACHE STRING "" FORCE)
|
|
|
|
mark_as_advanced(CMAKE_C_FLAGS_RELEASE)
|
|
|
|
endif()
|
|
|
|
|
|
|
|
if(_reset_standard_cxxflags_rel)
|
|
|
|
string(REGEX REPLACE "-O3" "-O2" CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}")
|
|
|
|
set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}" CACHE STRING "" FORCE)
|
|
|
|
mark_as_advanced(CMAKE_CXX_FLAGS_RELEASE)
|
|
|
|
endif()
|
|
|
|
|
|
|
|
unset(_reset_standard_cflags_rel)
|
|
|
|
unset(_reset_standard_cxxflags_rel)
|
|
|
|
|
|
|
|
# ------------------------------------------------------------------
|
|
|
|
# workaround for omission in cmake 2.8.4's GNU.cmake, fixed in 2.8.5
|
|
|
|
if(CMAKE_COMPILER_IS_GNUCC)
|
|
|
|
if(NOT DARWIN)
|
|
|
|
set(CMAKE_INCLUDE_SYSTEM_FLAG_C "-isystem ")
|
|
|
|
endif()
|
|
|
|
endif()
|
2011-06-11 06:00:28 +00:00
|
|
|
|
2011-05-23 14:56:14 +00:00
|
|
|
endmacro()
|
2011-11-07 15:53:40 +00:00
|
|
|
|
|
|
|
# pair of macros to allow libraries to be specify files to install, but to
|
|
|
|
# only install them at the end so the directories don't get cleared with
|
|
|
|
# the files in them. used by cycles to install addon.
|
2015-06-16 23:16:17 +00:00
|
|
|
function(delayed_install
|
2019-04-17 04:35:54 +00:00
|
|
|
base
|
|
|
|
files
|
|
|
|
destination)
|
|
|
|
|
|
|
|
foreach(f ${files})
|
|
|
|
if(IS_ABSOLUTE ${f})
|
|
|
|
set_property(GLOBAL APPEND PROPERTY DELAYED_INSTALL_FILES ${f})
|
|
|
|
else()
|
|
|
|
set_property(GLOBAL APPEND PROPERTY DELAYED_INSTALL_FILES ${base}/${f})
|
|
|
|
endif()
|
|
|
|
set_property(GLOBAL APPEND PROPERTY DELAYED_INSTALL_DESTINATIONS ${destination})
|
|
|
|
endforeach()
|
2019-06-18 21:12:16 +00:00
|
|
|
unset(f)
|
2015-06-16 23:16:17 +00:00
|
|
|
endfunction()
|
2011-11-07 15:53:40 +00:00
|
|
|
|
|
|
|
# note this is a function instead of a macro so that ${BUILD_TYPE} in targetdir
|
|
|
|
# does not get expanded in calling but is preserved
|
|
|
|
function(delayed_do_install
|
2019-04-17 04:35:54 +00:00
|
|
|
targetdir)
|
|
|
|
|
|
|
|
get_property(files GLOBAL PROPERTY DELAYED_INSTALL_FILES)
|
|
|
|
get_property(destinations GLOBAL PROPERTY DELAYED_INSTALL_DESTINATIONS)
|
|
|
|
|
|
|
|
if(files)
|
|
|
|
list(LENGTH files n)
|
|
|
|
math(EXPR n "${n}-1")
|
|
|
|
|
|
|
|
foreach(i RANGE ${n})
|
|
|
|
list(GET files ${i} f)
|
|
|
|
list(GET destinations ${i} d)
|
|
|
|
if(NOT IS_ABSOLUTE ${d})
|
|
|
|
install(FILES ${f} DESTINATION ${targetdir}/${d})
|
|
|
|
else()
|
|
|
|
install(FILES ${f} DESTINATION ${d})
|
|
|
|
endif()
|
|
|
|
endforeach()
|
|
|
|
endif()
|
2011-11-07 15:53:40 +00:00
|
|
|
endfunction()
|
|
|
|
|
2012-08-08 16:03:42 +00:00
|
|
|
|
2015-06-16 23:16:17 +00:00
|
|
|
function(data_to_c
|
2019-04-17 04:35:54 +00:00
|
|
|
file_from file_to
|
|
|
|
list_to_add
|
|
|
|
)
|
2012-08-08 16:03:42 +00:00
|
|
|
|
2019-04-17 04:35:54 +00:00
|
|
|
list(APPEND ${list_to_add} ${file_to})
|
|
|
|
set(${list_to_add} ${${list_to_add}} PARENT_SCOPE)
|
2012-08-08 16:03:42 +00:00
|
|
|
|
2019-04-17 04:35:54 +00:00
|
|
|
get_filename_component(_file_to_path ${file_to} PATH)
|
2012-08-11 16:25:31 +00:00
|
|
|
|
2019-04-17 04:35:54 +00:00
|
|
|
add_custom_command(
|
|
|
|
OUTPUT ${file_to}
|
|
|
|
COMMAND ${CMAKE_COMMAND} -E make_directory ${_file_to_path}
|
|
|
|
COMMAND "$<TARGET_FILE:datatoc>" ${file_from} ${file_to}
|
|
|
|
DEPENDS ${file_from} datatoc)
|
2013-09-20 06:35:28 +00:00
|
|
|
|
2019-04-17 04:35:54 +00:00
|
|
|
set_source_files_properties(${file_to} PROPERTIES GENERATED TRUE)
|
2015-06-16 23:16:17 +00:00
|
|
|
endfunction()
|
2012-08-08 16:03:42 +00:00
|
|
|
|
2012-08-11 18:47:09 +00:00
|
|
|
|
2012-08-11 13:32:19 +00:00
|
|
|
# same as above but generates the var name and output automatic.
|
2015-06-16 23:16:17 +00:00
|
|
|
function(data_to_c_simple
|
2019-04-17 04:35:54 +00:00
|
|
|
file_from
|
|
|
|
list_to_add
|
|
|
|
)
|
2012-08-11 13:32:19 +00:00
|
|
|
|
2019-04-17 04:35:54 +00:00
|
|
|
# remove ../'s
|
|
|
|
get_filename_component(_file_from ${CMAKE_CURRENT_SOURCE_DIR}/${file_from} REALPATH)
|
|
|
|
get_filename_component(_file_to ${CMAKE_CURRENT_BINARY_DIR}/${file_from}.c REALPATH)
|
2012-08-11 13:32:19 +00:00
|
|
|
|
2019-04-17 04:35:54 +00:00
|
|
|
list(APPEND ${list_to_add} ${_file_to})
|
|
|
|
source_group(Generated FILES ${_file_to})
|
|
|
|
list(APPEND ${list_to_add} ${file_from})
|
|
|
|
set(${list_to_add} ${${list_to_add}} PARENT_SCOPE)
|
2012-08-11 13:32:19 +00:00
|
|
|
|
2019-04-17 04:35:54 +00:00
|
|
|
get_filename_component(_file_to_path ${_file_to} PATH)
|
2012-08-11 16:25:31 +00:00
|
|
|
|
2019-04-17 04:35:54 +00:00
|
|
|
add_custom_command(
|
|
|
|
OUTPUT ${_file_to}
|
|
|
|
COMMAND ${CMAKE_COMMAND} -E make_directory ${_file_to_path}
|
|
|
|
COMMAND "$<TARGET_FILE:datatoc>" ${_file_from} ${_file_to}
|
|
|
|
DEPENDS ${_file_from} datatoc)
|
2012-08-11 13:32:19 +00:00
|
|
|
|
2019-04-17 04:35:54 +00:00
|
|
|
set_source_files_properties(${_file_to} PROPERTIES GENERATED TRUE)
|
2015-06-16 23:16:17 +00:00
|
|
|
endfunction()
|
2013-08-22 13:51:00 +00:00
|
|
|
|
2014-01-13 12:47:33 +00:00
|
|
|
# macro for converting pixmap directory to a png and then a c file
|
2015-06-16 23:16:17 +00:00
|
|
|
function(data_to_c_simple_icons
|
2019-04-17 04:35:54 +00:00
|
|
|
path_from icon_prefix icon_names
|
|
|
|
list_to_add
|
|
|
|
)
|
|
|
|
|
|
|
|
# Conversion steps
|
|
|
|
# path_from -> _file_from -> _file_to
|
|
|
|
# foo/*.dat -> foo.png -> foo.png.c
|
|
|
|
|
|
|
|
get_filename_component(_path_from_abs ${path_from} ABSOLUTE)
|
|
|
|
# remove ../'s
|
|
|
|
get_filename_component(_file_from ${CMAKE_CURRENT_BINARY_DIR}/${path_from}.png REALPATH)
|
|
|
|
get_filename_component(_file_to ${CMAKE_CURRENT_BINARY_DIR}/${path_from}.png.c REALPATH)
|
|
|
|
|
|
|
|
list(APPEND ${list_to_add} ${_file_to})
|
|
|
|
set(${list_to_add} ${${list_to_add}} PARENT_SCOPE)
|
|
|
|
|
|
|
|
get_filename_component(_file_to_path ${_file_to} PATH)
|
|
|
|
|
|
|
|
# Construct a list of absolute paths from input
|
|
|
|
set(_icon_files)
|
|
|
|
foreach(_var ${icon_names})
|
|
|
|
list(APPEND _icon_files "${_path_from_abs}/${icon_prefix}${_var}.dat")
|
|
|
|
endforeach()
|
|
|
|
|
|
|
|
add_custom_command(
|
|
|
|
OUTPUT ${_file_from} ${_file_to}
|
|
|
|
COMMAND ${CMAKE_COMMAND} -E make_directory ${_file_to_path}
|
2019-10-28 14:32:33 +00:00
|
|
|
# COMMAND python3 ${CMAKE_SOURCE_DIR}/source/blender/datatoc/datatoc_icon.py ${_path_from_abs} ${_file_from}
|
2019-04-17 04:35:54 +00:00
|
|
|
COMMAND "$<TARGET_FILE:datatoc_icon>" ${_path_from_abs} ${_file_from}
|
|
|
|
COMMAND "$<TARGET_FILE:datatoc>" ${_file_from} ${_file_to}
|
|
|
|
DEPENDS
|
|
|
|
${_icon_files}
|
|
|
|
datatoc_icon
|
|
|
|
datatoc
|
|
|
|
# could be an arg but for now we only create icons depending on UI_icons.h
|
|
|
|
${CMAKE_SOURCE_DIR}/source/blender/editors/include/UI_icons.h
|
|
|
|
)
|
|
|
|
|
|
|
|
set_source_files_properties(${_file_from} ${_file_to} PROPERTIES GENERATED TRUE)
|
2015-06-16 23:16:17 +00:00
|
|
|
endfunction()
|
2014-01-13 12:47:33 +00:00
|
|
|
|
2013-08-26 12:16:23 +00:00
|
|
|
# XXX Not used for now...
|
2015-06-16 23:16:17 +00:00
|
|
|
function(svg_to_png
|
2019-04-17 04:35:54 +00:00
|
|
|
file_from
|
|
|
|
file_to
|
|
|
|
dpi
|
|
|
|
list_to_add
|
|
|
|
)
|
|
|
|
|
|
|
|
# remove ../'s
|
|
|
|
get_filename_component(_file_from ${CMAKE_CURRENT_SOURCE_DIR}/${file_from} REALPATH)
|
|
|
|
get_filename_component(_file_to ${CMAKE_CURRENT_SOURCE_DIR}/${file_to} REALPATH)
|
|
|
|
|
|
|
|
list(APPEND ${list_to_add} ${_file_to})
|
|
|
|
set(${list_to_add} ${${list_to_add}} PARENT_SCOPE)
|
|
|
|
|
|
|
|
find_program(INKSCAPE_EXE inkscape)
|
|
|
|
mark_as_advanced(INKSCAPE_EXE)
|
|
|
|
|
|
|
|
if(INKSCAPE_EXE)
|
|
|
|
if(APPLE)
|
|
|
|
# in OS X app bundle, the binary is a shim that doesn't take any
|
|
|
|
# command line arguments, replace it with the actual binary
|
|
|
|
string(REPLACE "MacOS/Inkscape" "Resources/bin/inkscape" INKSCAPE_REAL_EXE ${INKSCAPE_EXE})
|
|
|
|
if(EXISTS "${INKSCAPE_REAL_EXE}")
|
|
|
|
set(INKSCAPE_EXE ${INKSCAPE_REAL_EXE})
|
|
|
|
endif()
|
|
|
|
endif()
|
|
|
|
|
|
|
|
add_custom_command(
|
|
|
|
OUTPUT ${_file_to}
|
|
|
|
COMMAND ${INKSCAPE_EXE} ${_file_from} --export-dpi=${dpi} --without-gui --export-png=${_file_to}
|
|
|
|
DEPENDS ${_file_from} ${INKSCAPE_EXE}
|
|
|
|
)
|
|
|
|
else()
|
|
|
|
message(WARNING "Inkscape not found, could not re-generate ${_file_to} from ${_file_from}!")
|
|
|
|
endif()
|
2015-06-16 23:16:17 +00:00
|
|
|
endfunction()
|
2013-08-22 13:51:00 +00:00
|
|
|
|
2015-06-16 23:16:17 +00:00
|
|
|
function(msgfmt_simple
|
2019-04-17 04:35:54 +00:00
|
|
|
file_from
|
|
|
|
list_to_add
|
|
|
|
)
|
2013-11-08 20:44:48 +00:00
|
|
|
|
2019-04-17 04:35:54 +00:00
|
|
|
# remove ../'s
|
|
|
|
get_filename_component(_file_from_we ${file_from} NAME_WE)
|
2013-11-08 20:44:48 +00:00
|
|
|
|
2019-04-17 04:35:54 +00:00
|
|
|
get_filename_component(_file_from ${file_from} REALPATH)
|
|
|
|
get_filename_component(_file_to ${CMAKE_CURRENT_BINARY_DIR}/${_file_from_we}.mo REALPATH)
|
2013-11-08 20:44:48 +00:00
|
|
|
|
2019-04-17 04:35:54 +00:00
|
|
|
list(APPEND ${list_to_add} ${_file_to})
|
|
|
|
set(${list_to_add} ${${list_to_add}} PARENT_SCOPE)
|
2013-11-08 20:44:48 +00:00
|
|
|
|
2019-04-17 04:35:54 +00:00
|
|
|
get_filename_component(_file_to_path ${_file_to} PATH)
|
2013-11-08 20:44:48 +00:00
|
|
|
|
2019-04-17 04:35:54 +00:00
|
|
|
add_custom_command(
|
|
|
|
OUTPUT ${_file_to}
|
|
|
|
COMMAND ${CMAKE_COMMAND} -E make_directory ${_file_to_path}
|
|
|
|
COMMAND "$<TARGET_FILE:msgfmt>" ${_file_from} ${_file_to}
|
|
|
|
DEPENDS msgfmt ${_file_from})
|
2013-11-08 20:44:48 +00:00
|
|
|
|
2019-04-17 04:35:54 +00:00
|
|
|
set_source_files_properties(${_file_to} PROPERTIES GENERATED TRUE)
|
2015-06-16 23:16:17 +00:00
|
|
|
endfunction()
|
2013-11-08 20:44:48 +00:00
|
|
|
|
2015-06-16 23:16:17 +00:00
|
|
|
function(find_python_package
|
2019-04-17 04:35:54 +00:00
|
|
|
package
|
|
|
|
)
|
|
|
|
|
|
|
|
string(TOUPPER ${package} _upper_package)
|
|
|
|
|
|
|
|
# set but invalid
|
|
|
|
if((NOT ${PYTHON_${_upper_package}_PATH} STREQUAL "") AND
|
|
|
|
(NOT ${PYTHON_${_upper_package}_PATH} MATCHES NOTFOUND))
|
|
|
|
# if(NOT EXISTS "${PYTHON_${_upper_package}_PATH}/${package}")
|
|
|
|
# message(WARNING "PYTHON_${_upper_package}_PATH is invalid, ${package} not found in '${PYTHON_${_upper_package}_PATH}' "
|
|
|
|
# "WITH_PYTHON_INSTALL_${_upper_package} option will be ignored when installing python")
|
|
|
|
# set(WITH_PYTHON_INSTALL${_upper_package} OFF)
|
|
|
|
# endif()
|
|
|
|
# not set, so initialize
|
|
|
|
else()
|
|
|
|
string(REPLACE "." ";" _PY_VER_SPLIT "${PYTHON_VERSION}")
|
|
|
|
list(GET _PY_VER_SPLIT 0 _PY_VER_MAJOR)
|
|
|
|
|
|
|
|
# re-cache
|
|
|
|
unset(PYTHON_${_upper_package}_PATH CACHE)
|
|
|
|
find_path(PYTHON_${_upper_package}_PATH
|
|
|
|
NAMES
|
|
|
|
${package}
|
|
|
|
HINTS
|
|
|
|
"${PYTHON_LIBPATH}/"
|
|
|
|
"${PYTHON_LIBPATH}/python${PYTHON_VERSION}/"
|
|
|
|
"${PYTHON_LIBPATH}/python${_PY_VER_MAJOR}/"
|
|
|
|
PATH_SUFFIXES
|
|
|
|
site-packages
|
|
|
|
dist-packages
|
|
|
|
vendor-packages
|
|
|
|
NO_DEFAULT_PATH
|
|
|
|
)
|
|
|
|
|
|
|
|
if(NOT EXISTS "${PYTHON_${_upper_package}_PATH}")
|
|
|
|
message(WARNING
|
|
|
|
"Python package '${package}' path could not be found in:\n"
|
|
|
|
"'${PYTHON_LIBPATH}/python${PYTHON_VERSION}/site-packages/${package}', "
|
|
|
|
"'${PYTHON_LIBPATH}/python${_PY_VER_MAJOR}/site-packages/${package}', "
|
|
|
|
"'${PYTHON_LIBPATH}/python${PYTHON_VERSION}/dist-packages/${package}', "
|
|
|
|
"'${PYTHON_LIBPATH}/python${_PY_VER_MAJOR}/dist-packages/${package}', "
|
|
|
|
"'${PYTHON_LIBPATH}/python${PYTHON_VERSION}/vendor-packages/${package}', "
|
|
|
|
"'${PYTHON_LIBPATH}/python${_PY_VER_MAJOR}/vendor-packages/${package}', "
|
|
|
|
"\n"
|
|
|
|
"The 'WITH_PYTHON_INSTALL_${_upper_package}' option will be ignored when installing Python.\n"
|
|
|
|
"The build will be usable, only add-ons that depend on this package won't be functional."
|
|
|
|
)
|
|
|
|
set(WITH_PYTHON_INSTALL_${_upper_package} OFF PARENT_SCOPE)
|
|
|
|
else()
|
|
|
|
message(STATUS "${package} found at '${PYTHON_${_upper_package}_PATH}'")
|
|
|
|
endif()
|
|
|
|
endif()
|
2015-06-16 23:16:17 +00:00
|
|
|
endfunction()
|
2014-11-16 11:57:42 +00:00
|
|
|
|
|
|
|
# like Python's 'print(dir())'
|
2015-06-16 23:16:17 +00:00
|
|
|
function(print_all_vars)
|
2019-04-17 04:35:54 +00:00
|
|
|
get_cmake_property(_vars VARIABLES)
|
|
|
|
foreach(_var ${_vars})
|
|
|
|
message("${_var}=${${_var}}")
|
|
|
|
endforeach()
|
2015-06-16 23:16:17 +00:00
|
|
|
endfunction()
|
2016-07-18 13:16:45 +00:00
|
|
|
|
|
|
|
macro(openmp_delayload
|
2019-04-17 04:35:54 +00:00
|
|
|
projectname
|
|
|
|
)
|
|
|
|
if(MSVC)
|
|
|
|
if(WITH_OPENMP)
|
2019-10-07 16:24:13 +00:00
|
|
|
if(MSVC_CLANG)
|
|
|
|
set(OPENMP_DLL_NAME "libomp")
|
|
|
|
elseif(MSVC_VERSION EQUAL 1800)
|
2019-04-17 04:35:54 +00:00
|
|
|
set(OPENMP_DLL_NAME "vcomp120")
|
|
|
|
else()
|
|
|
|
set(OPENMP_DLL_NAME "vcomp140")
|
|
|
|
endif()
|
|
|
|
SET_TARGET_PROPERTIES(${projectname} PROPERTIES LINK_FLAGS_RELEASE "/DELAYLOAD:${OPENMP_DLL_NAME}.dll delayimp.lib")
|
|
|
|
SET_TARGET_PROPERTIES(${projectname} PROPERTIES LINK_FLAGS_DEBUG "/DELAYLOAD:${OPENMP_DLL_NAME}d.dll delayimp.lib")
|
|
|
|
SET_TARGET_PROPERTIES(${projectname} PROPERTIES LINK_FLAGS_RELWITHDEBINFO "/DELAYLOAD:${OPENMP_DLL_NAME}.dll delayimp.lib")
|
|
|
|
SET_TARGET_PROPERTIES(${projectname} PROPERTIES LINK_FLAGS_MINSIZEREL "/DELAYLOAD:${OPENMP_DLL_NAME}.dll delayimp.lib")
|
|
|
|
endif()
|
|
|
|
endif()
|
2016-07-18 13:16:45 +00:00
|
|
|
endmacro()
|
2016-08-31 12:26:05 +00:00
|
|
|
|
2019-06-06 04:48:37 +00:00
|
|
|
macro(blender_precompile_headers target cpp header)
|
2019-06-18 21:24:55 +00:00
|
|
|
if(MSVC)
|
2019-06-06 14:26:15 +00:00
|
|
|
# get the name for the pch output file
|
|
|
|
get_filename_component( pchbase ${cpp} NAME_WE )
|
2019-06-25 21:27:21 +00:00
|
|
|
set( pchfinal "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_CFG_INTDIR}/${pchbase}.pch" )
|
2019-06-06 14:26:15 +00:00
|
|
|
|
|
|
|
# mark the cpp as the one outputting the pch
|
|
|
|
set_property(SOURCE ${cpp} APPEND PROPERTY OBJECT_OUTPUTS "${pchfinal}")
|
|
|
|
|
|
|
|
# get all sources for the target
|
|
|
|
get_target_property(sources ${target} SOURCES)
|
|
|
|
|
|
|
|
# make all sources depend on the pch to enforce the build order
|
|
|
|
foreach(src ${sources})
|
|
|
|
set_property(SOURCE ${src} APPEND PROPERTY OBJECT_DEPENDS "${pchfinal}")
|
|
|
|
endforeach()
|
|
|
|
|
2019-06-06 04:48:37 +00:00
|
|
|
target_sources(${target} PRIVATE ${cpp} ${header})
|
2019-06-06 14:26:15 +00:00
|
|
|
set_target_properties(${target} PROPERTIES COMPILE_FLAGS "/Yu${header} /Fp${pchfinal} /FI${header}")
|
|
|
|
set_source_files_properties(${cpp} PROPERTIES COMPILE_FLAGS "/Yc${header} /Fp${pchfinal}")
|
2019-06-06 04:48:37 +00:00
|
|
|
endif()
|
|
|
|
endmacro()
|