CMakeLists.txt

# ***** 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.
#
# The Original Code is: all of this file.
#
# Contributor(s): Jacques Beaurain.
#
# ***** END GPL LICENSE BLOCK *****

#-----------------------------------------------------------------------------
# We don't allow in-source builds. This causes no end of troubles because
# all out-of-source builds will use the CMakeCache.txt file there and even
# build the libs and objects in it.

if(${CMAKE_SOURCE_DIR} STREQUAL ${CMAKE_BINARY_DIR})
	if(NOT DEFINED WITH_IN_SOURCE_BUILD)
		message(FATAL_ERROR
			"CMake generation for blender is not allowed within the source directory!"
			"\n Remove the CMakeCache.txt file and try again from another folder, e.g.:"
			"\n "
			"\n rm CMakeCache.txt"
			"\n cd .."
			"\n mkdir cmake-make"
			"\n cd cmake-make"
			"\n cmake ../blender"
			"\n "
			"\n Alternately define WITH_IN_SOURCE_BUILD to force this option (not recommended!)"
		)
	endif()
endif()

cmake_minimum_required(VERSION 2.8)

if(NOT EXECUTABLE_OUTPUT_PATH)
	set(FIRST_RUN "TRUE")
endif()

# this starts out unset
list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/build_files/cmake/Modules")

# avoid having empty buildtype
set(CMAKE_BUILD_TYPE_INIT "Release")

# quiet output for Makefiles, 'make -s' helps too
# set_property(GLOBAL PROPERTY RULE_MESSAGES OFF)

# global compile definitions since add_definitions() adds for all.
set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS_DEBUG           DEBUG _DEBUG)
set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS_RELEASE         NDEBUG)
set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS_MINSIZEREL      NDEBUG)
set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS_RELWITHDEBINFO  NDEBUG)


#-----------------------------------------------------------------------------
# Set policy

# see "cmake --help-policy CMP0003"
# So library linking is more sane
cmake_policy(SET CMP0003 NEW)

# So BUILDINFO and BLENDERPATH strings are automatically quoted
cmake_policy(SET CMP0005 NEW)

# So syntax problems are errors
cmake_policy(SET CMP0010 NEW)

# Input directories must have CMakeLists.txt
cmake_policy(SET CMP0014 NEW)

#-----------------------------------------------------------------------------
# Load some macros.
include(build_files/cmake/macros.cmake)


#-----------------------------------------------------------------------------
# Initialize project.

blender_project_hack_pre()

project(Blender)

blender_project_hack_post()

enable_testing()

#-----------------------------------------------------------------------------
# Redirect output files

set(EXECUTABLE_OUTPUT_PATH ${CMAKE_BINARY_DIR}/bin CACHE INTERNAL "" FORCE)
set(LIBRARY_OUTPUT_PATH ${CMAKE_BINARY_DIR}/lib CACHE INTERNAL "" FORCE)

#-----------------------------------------------------------------------------
# Set default config options

get_blender_version()


# Blender internal features
option(WITH_BLENDER "Build blender (disable to build only the blender player)" ON)
mark_as_advanced(WITH_BLENDER)

option(WITH_INTERNATIONAL "Enable I18N (International fonts and text)" ON)

option(WITH_PYTHON        "Enable Embedded Python API  (only disable for development)" ON)
option(WITH_PYTHON_SECURITY "Disables execution of scripts within blend files by default" ON) 
mark_as_advanced(WITH_PYTHON)  # dont want people disabling this unless they really know what they are doing.
mark_as_advanced(WITH_PYTHON_SECURITY)  # some distributions see this as a security issue, rather than have them patch it, make a build option.
set(WITH_PYTHON_SECURITY ON CACHE BOOL "ON" FORCE) # temp force on. 

option(WITH_PYTHON_SAFETY "Enable internal API error checking to track invalid data to prevent crash on access (at the expense of some effeciency, only enable for development)." OFF)
option(WITH_PYTHON_MODULE "Enable building as a python module which runs without a user interface, like running regular blender in background mode (experimental, only enable for development)" OFF)
if(APPLE)
	option(WITH_PYTHON_FRAMEWORK "Enable building using the Python available in the framework (OSX only)" OFF)
endif()

option(WITH_BUILDINFO     "Include extra build details (only disable for development & faster builds)" ON)
option(WITH_IK_ITASC      "Enable ITASC IK solver (only disable for development & for incompatible C++ compilers)" ON)
option(WITH_IK_SOLVER     "Enable Legacy IK solver (only disable for development)" ON)
option(WITH_FFTW3         "Enable FFTW3 support (Used for smoke and audio effects)" ON)
option(WITH_BULLET        "Enable Bullet (Physics Engine)" ON)
option(WITH_SYSTEM_BULLET "Use the systems bullet library (currently unsupported due to missing features in upstream!)" )
mark_as_advanced(WITH_SYSTEM_BULLET)
option(WITH_GAMEENGINE    "Enable Game Engine" ON)
option(WITH_PLAYER        "Build Player" OFF)
option(WITH_OPENCOLORIO   "Enable OpenColorIO color management" ON)
option(WITH_COMPOSITOR    "Enable the tile based nodal compositor" ON)

# GHOST Windowing Library Options
option(WITH_GHOST_DEBUG   "Enable debugging output for the GHOST library" OFF)
mark_as_advanced(WITH_GHOST_DEBUG)

option(WITH_GHOST_SDL    "Enable building blender against SDL for windowing rather then the native APIs" OFF)
mark_as_advanced(WITH_GHOST_SDL)

# Misc...
option(WITH_HEADLESS      "Build without graphical support (renderfarm, server mode only)" OFF)
mark_as_advanced(WITH_HEADLESS)

option(WITH_AUDASPACE    "Build with blenders audio library (only disable if you know what you're doing!)" ON)
mark_as_advanced(WITH_AUDASPACE)

option(WITH_BOOL_COMPAT "Continue defining \"TRUE\" and \"FALSE\" until these can be replaced with \"true\" and \"false\" from stdbool.h" ON)
mark_as_advanced(WITH_BOOL_COMPAT)

# (unix defaults to OpenMP On)
if((UNIX AND NOT APPLE) OR (MINGW))
	set(PLATFORM_DEFAULT ON)
else()
	set(PLATFORM_DEFAULT OFF)
endif()
option(WITH_OPENMP        "Enable OpenMP (has to be supported by the compiler)" ${PLATFORM_DEFAULT})
unset(PLATFORM_DEFAULT)


if(UNIX AND NOT APPLE)
	option(WITH_X11_XINPUT "Enable X11 Xinput (tablet support and unicode input)"	ON)
	option(WITH_X11_XF86VMODE "Enable X11 video mode switching"	ON)
	option(WITH_SYSTEM_GLEW "Use GLEW OpenGL wrapper library provided by the operating system" ON)

	option(WITH_GHOST_XDND   "Enable drag'n'drop support on X11 using XDND protocol" ON)
else()
	# not an option for other OS's
	set(WITH_SYSTEM_GLEW OFF)
endif()


# (unix defaults to System OpenJPEG On)
if(UNIX AND NOT APPLE)
	set(PLATFORM_DEFAULT ON)
else()
	set(PLATFORM_DEFAULT OFF)
endif()
option(WITH_SYSTEM_OPENJPEG "Use the operating systems OpenJPEG library" ${PLATFORM_DEFAULT})
unset(PLATFORM_DEFAULT)


# Modifiers
option(WITH_MOD_FLUID           "Enable Elbeem Modifier (Fluid Simulation)" ON)
option(WITH_MOD_SMOKE           "Enable Smoke Modifier (Smoke Simulation)" ON)
option(WITH_MOD_BOOLEAN         "Enable Boolean Modifier" ON)
option(WITH_MOD_REMESH          "Enable Remesh Modifier" ON)
# option(WITH_MOD_CLOTH_ELTOPO    "Enable Experimental cloth solver" OFF)  # this is now only available in a branch
# mark_as_advanced(WITH_MOD_CLOTH_ELTOPO)
option(WITH_MOD_OCEANSIM        "Enable Ocean Modifier" OFF)

# Image format support
option(WITH_OPENIMAGEIO         "Enable OpenImageIO Support (http://www.openimageio.org)" OFF)
option(WITH_IMAGE_OPENEXR       "Enable OpenEXR Support (http://www.openexr.com)" ON)
option(WITH_IMAGE_OPENJPEG      "Enable OpenJpeg Support (http://www.openjpeg.org)" ON)
option(WITH_IMAGE_TIFF          "Enable LibTIFF Support" ON)
option(WITH_IMAGE_DDS           "Enable DDS Image Support" ON)
option(WITH_IMAGE_CINEON        "Enable CINEON and DPX Image Support" ON)
option(WITH_IMAGE_HDR           "Enable HDR Image Support" ON)
option(WITH_IMAGE_REDCODE       "Enable RedCode Image Support" OFF)
option(WITH_IMAGE_FRAMESERVER   "Enable image FrameServer Support for rendering" ON)

# Audio/Video format support
option(WITH_CODEC_AVI           "Enable Blenders own AVI file support (raw/jpeg)" ON)
option(WITH_CODEC_FFMPEG        "Enable FFMPeg Support (http://ffmpeg.org)" OFF)
option(WITH_CODEC_SNDFILE       "Enable libsndfile Support (http://www.mega-nerd.com/libsndfile)" OFF)

if(APPLE)
	option(WITH_CODEC_FFMPEG        "Enable FFMPeg Support (http://ffmpeg.org)" ON)
	option(WITH_CODEC_QUICKTIME     "Enable Quicktime Support" ON)
else()
	option(WITH_CODEC_FFMPEG        "Enable FFMPeg Support (http://ffmpeg.org)" OFF)
endif()

# 3D format support
# Disable opencollada when we don't have precompiled libs
if(APPLE OR WIN32)
	option(WITH_OPENCOLLADA		"Enable OpenCollada Support (http://www.opencollada.org)" ON)
else()
	option(WITH_OPENCOLLADA		"Enable OpenCollada Support (http://www.opencollada.org)" OFF)
endif()

# Sound output
option(WITH_SDL           "Enable SDL for sound and joystick support" ON)
option(WITH_OPENAL        "Enable OpenAL Support (http://www.openal.org)" ON)
option(WITH_JACK          "Enable Jack Support (http://www.jackaudio.org)" OFF)
if(UNIX AND NOT APPLE)
	option(WITH_JACK_DYNLOAD  "Enable runtime dynamic Jack libraries loading" OFF)
endif()

# Compression
option(WITH_LZO           "Enable fast LZO compression (used for pointcache)" ON)
option(WITH_LZMA          "Enable best LZMA compression, (used for pointcache)" ON)

# Camera/motion tracking
option(WITH_LIBMV         "Enable libmv structure from motion library" ON)

# Freestyle
option(WITH_FREESTYLE     "Enable Freestyle (advanced edges rendering)" ON)

# Misc
option(WITH_INPUT_NDOF "Enable NDOF input devices (SpaceNavigator and friends)" ON)
option(WITH_RAYOPTIMIZATION	"Enable use of SIMD (SSE) optimizations for the raytracer" ON)
option(WITH_OPENNL        "Enable use of Open Numerical Library" ON)
if(UNIX AND NOT APPLE)
	option(WITH_INSTALL_PORTABLE "Install redistributeable runtime, otherwise install into CMAKE_INSTALL_PREFIX" ON)
	option(WITH_STATIC_LIBS "Try to link with static libraries, as much as possible, to make blender more portable across distributions" OFF)
	if(WITH_STATIC_LIBS)
		option(WITH_BOOST_ICU "Boost uses ICU library (required for linking with static Boost built with libicu)." OFF)
		mark_as_advanced(WITH_BOOST_ICU)
	endif()
endif()
option(WITH_PYTHON_INSTALL       "Copy system python into the blender install folder" ON)
option(WITH_PYTHON_INSTALL_NUMPY "Copy system numpy into the blender install folder"  ON)
set(PYTHON_NUMPY_PATH            "" CACHE PATH "Python to python site-packages or dist-packages containing 'numpy' module")
mark_as_advanced(PYTHON_NUMPY_PATH)

if(UNIX AND NOT APPLE)
	option(WITH_PYTHON_INSTALL_REQUESTS "Copy system requests into the blender install folder" ON)
endif()

# Cycles
option(WITH_CYCLES					"Enable cycles Render Engine" ON)
option(WITH_CYCLES_STANDALONE		"Build cycles standalone application" OFF)
option(WITH_CYCLES_STANDALONE_GUI	"Build cycles standalone with GUI" OFF)
option(WITH_CYCLES_OSL				"Build Cycles with OSL support" OFF)
option(WITH_CYCLES_CUDA_BINARIES	"Build cycles CUDA binaries" OFF)
set(CYCLES_CUDA_BINARIES_ARCH sm_20 sm_21 sm_30 sm_35 CACHE STRING "CUDA architectures to build binaries for")
mark_as_advanced(CYCLES_CUDA_BINARIES_ARCH)
unset(PLATFORM_DEFAULT)

# LLVM
option(WITH_LLVM					"Use LLVM" OFF)
option(LLVM_STATIC					"Link with LLVM static libraries" ON)
mark_as_advanced(LLVM_STATIC)

# disable for now, but plan to support on all platforms eventually
option(WITH_MEM_JEMALLOC   "Enable malloc replacement (http://www.canonware.com/jemalloc)" OFF)
mark_as_advanced(WITH_MEM_JEMALLOC)

# currently only used for BLI_mempool
option(WITH_MEM_VALGRIND "Enable extended valgrind support for better reporting" OFF)
mark_as_advanced(WITH_MEM_VALGRIND)

# Debug
option(WITH_CXX_GUARDEDALLOC "Enable GuardedAlloc for C++ memory allocation tracking (only enable for development)" OFF)
mark_as_advanced(WITH_CXX_GUARDEDALLOC)

option(WITH_ASSERT_ABORT "Call abort() when raising an assertion through BLI_assert()" OFF)
mark_as_advanced(WITH_ASSERT_ABORT)

option(WITH_BOOST					"Enable features depending on boost" ON)

if(CMAKE_COMPILER_IS_GNUCC)
	option(WITH_GCC_MUDFLAP			"Enable mudflap" OFF)
	mark_as_advanced(WITH_GCC_MUDFLAP)
endif()

if(APPLE)
	cmake_minimum_required(VERSION 2.8.8)
	cmake_policy(VERSION 2.8.8)

	if(NOT CMAKE_OSX_ARCHITECTURES)
		set(CMAKE_OSX_ARCHITECTURES x86_64 CACHE STRING
		"Choose the architecture you want to build Blender for: i386, x86_64 or ppc"
		FORCE)
	endif()
	
	execute_process(COMMAND uname -r OUTPUT_VARIABLE MAC_SYS) # check for actual system-version
	if(${MAC_SYS} MATCHES 13)
		set(OSX_SYSTEM 10.9)
	elseif(${MAC_SYS} MATCHES 12)
		set(OSX_SYSTEM 10.8)
	elseif(${MAC_SYS} MATCHES 11)
		set(OSX_SYSTEM 10.7)
	elseif(${MAC_SYS} MATCHES 10)
		set(OSX_SYSTEM 10.6)
	elseif(${MAC_SYS} MATCHES 9)
		set(OSX_SYSTEM 10.5)
	else()
		set(OSX_SYSTEM unsupported)
	endif()
	message(STATUS "Detected system-version: " ${OSX_SYSTEM})
	
	# workaround for incorrect cmake xcode lookup for developer previews - XCODE_VERSION does not take xcode-select path into accout
	# but would always look into /Applications/Xcode.app while dev versions are named Xcode<version>-DP<preview_number>
	execute_process(COMMAND xcode-select --print-path  OUTPUT_VARIABLE XCODE_CHECK OUTPUT_STRIP_TRAILING_WHITESPACE)
	string(REPLACE "/Contents/Developer" "" XCODE_BUNDLE ${XCODE_CHECK}) # truncate to bundlepath in any case
	message(STATUS "Xcode-bundle : " ${XCODE_BUNDLE})
	
	if(${CMAKE_GENERATOR} MATCHES "Xcode")
	
		if(${XCODE_VERSION} VERSION_GREATER 4.2) # earlier xcode has no bundled developer dir, no sense in getting xcode path from
			string(SUBSTRING "${XCODE_CHECK}" 14 6 DP_NAME) # reduce to XCode name without dp extension
			if(${DP_NAME} MATCHES Xcode5)
				set(XCODE_VERSION 5)
			endif()
		endif()

		##### cmake incompatibility with xcode  4.3 and higher #####
		if(${XCODE_VERSION} MATCHES '') # cmake fails due looking for xcode in the wrong path, thus will be empty var
			message(FATAL_ERROR "Xcode 4.3 and higher must be used with cmake 2.8-8 or higher")
		endif()
		### end cmake incompatibility with xcode 4.3 and higher ###
		
		if(${XCODE_VERSION} VERSION_EQUAL 4 OR ${XCODE_VERSION} VERSION_GREATER 4 AND ${XCODE_VERSION} VERSION_LESS 4.3)
			# Xcode 4 defaults to the Apple LLVM Compiler.
			# Override the default compiler selection because Blender only compiles with gcc up to xcode 4.2
			set(CMAKE_XCODE_ATTRIBUTE_GCC_VERSION "com.apple.compilers.llvmgcc42")
			message(STATUS "Setting compiler to: " ${CMAKE_XCODE_ATTRIBUTE_GCC_VERSION})
		endif()
	else() # unix makefile generator does not fill XCODE_VERSION var, so we get it with a command
		execute_process(COMMAND xcodebuild -version OUTPUT_VARIABLE XCODE_VERS_BUILD_NR)
		string(SUBSTRING "${XCODE_VERS_BUILD_NR}" 6 3 XCODE_VERSION) # truncate away build-nr
		unset(XCODE_VERS_BUILD_NR)
	endif()
	
	message(STATUS "Detected Xcode-version: " ${XCODE_VERSION})

	if(${XCODE_VERSION} VERSION_LESS 4.3)
		set(CMAKE_OSX_SYSROOT /Developer/SDKs/MacOSX${OSX_SYSTEM}.sdk CACHE PATH "" FORCE)  # use guaranteed existing sdk
	else()
		# note: xcode-select path could be ambigous, cause /Applications/Xcode.app/Contents/Developer or /Applications/Xcode.app would be allowed
		# so i use a selfcomposed bundlepath here  
		set(OSX_SYSROOT_PREFIX ${XCODE_BUNDLE}/Contents/Developer/Platforms/MacOSX.platform)
		message(STATUS "OSX_SYSROOT_PREFIX: " ${OSX_SYSROOT_PREFIX})
		set(OSX_DEVELOPER_PREFIX /Developer/SDKs/MacOSX${OSX_SYSTEM}.sdk) # use guaranteed existing sdk
		set(CMAKE_OSX_SYSROOT ${OSX_SYSROOT_PREFIX}/${OSX_DEVELOPER_PREFIX} CACHE PATH "" FORCE)
		if(${CMAKE_GENERATOR} MATCHES "Xcode")
			set(CMAKE_XCODE_ATTRIBUTE_SDKROOT macosx${OSX_SYSTEM}) # to silence sdk not found warning, just overrides CMAKE_OSX_SYSROOT
		endif()
	endif()

	if(OSX_SYSTEM MATCHES 10.9)
		set(CMAKE_FIND_ROOT_PATH ${CMAKE_OSX_SYSROOT}) # make sure syslibs and headers are looked up in sdk ( expecially for 10.9 openGL atm. )
	endif()

	if(NOT CMAKE_OSX_DEPLOYMENT_TARGET)
		set(CMAKE_OSX_DEPLOYMENT_TARGET "10.6" CACHE STRING "" FORCE) # 10.6 is our min. target, if you use higher sdk, weak linking happens
	endif()
	
	if(NOT ${CMAKE_GENERATOR} MATCHES "Xcode")
		# force CMAKE_OSX_DEPLOYMENT_TARGET for makefiles, will not work else ( cmake bug ? )
		set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mmacosx-version-min=${CMAKE_OSX_DEPLOYMENT_TARGET}")
		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mmacosx-version-min=${CMAKE_OSX_DEPLOYMENT_TARGET}")
		add_definitions("-DMACOSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET}")
	endif()

	option(WITH_LIBS10.5  "Use 10.5 libs (needed for 64bit builds)" OFF)
endif()


#-----------------------------------------------------------------------------
# Check for conflicting/unsupported configurations

if(NOT WITH_BLENDER AND NOT WITH_PLAYER AND NOT WITH_CYCLES_STANDALONE)
	message(FATAL_ERROR "At least one of WITH_BLENDER or WITH_PLAYER or WITH_CYCLES_STANDALONE must be enabled, nothing to do!")
endif()

if(NOT WITH_GAMEENGINE AND WITH_PLAYER)
	message(FATAL_ERROR "WITH_PLAYER requires WITH_GAMEENGINE")
endif()

if(NOT WITH_AUDASPACE)
	if(WITH_OPENAL)
		message(FATAL_ERROR "WITH_OPENAL requires WITH_AUDASPACE")
	endif()
	if(WITH_JACK)
		message(FATAL_ERROR "WITH_JACK requires WITH_AUDASPACE")
	endif()
	if(WITH_GAMEENGINE)
		message(FATAL_ERROR "WITH_GAMEENGINE requires WITH_AUDASPACE")
	endif()
endif()

if(NOT WITH_SDL AND WITH_GHOST_SDL)
	message(FATAL_ERROR "WITH_GHOST_SDL requires WITH_SDL")
endif()

if(WITH_IMAGE_REDCODE AND ((NOT WITH_IMAGE_OPENJPEG) OR (NOT WITH_CODEC_FFMPEG)))
	message(FATAL_ERROR "WITH_IMAGE_REDCODE requires WITH_IMAGE_OPENJPEG and WITH_CODEC_FFMPEG")
endif()

# python module, needs some different options
if(WITH_PYTHON_MODULE AND WITH_PLAYER)
	message(FATAL_ERROR "WITH_PYTHON_MODULE requires WITH_PLAYER to be OFF")
endif()

if(WITH_PYTHON_MODULE AND WITH_PYTHON_INSTALL)
	message(FATAL_ERROR "WITH_PYTHON_MODULE requires WITH_PYTHON_INSTALL to be OFF")
endif()


# may as well build python module without a UI
if(WITH_PYTHON_MODULE)
	set(WITH_HEADLESS ON)
endif()

if(NOT WITH_PYTHON)
	set(WITH_CYCLES OFF)
endif()

# enable boost for cycles, booleans, audaspace or i18n
# otherwise if the user disabled
if(NOT WITH_BOOST)
	# Explicitly disabled. so disable all deps.
	macro(set_and_warn
		_setting _val)
		if(${${_setting}})
			message(STATUS "'WITH_BOOST' is disabled: forceing 'set(${_setting} ${_val})'")
		endif()
		set(${_setting} ${_val})
	endmacro()

	set_and_warn(WITH_CYCLES         OFF)
	set_and_warn(WITH_MOD_BOOLEAN    OFF)
	set_and_warn(WITH_AUDASPACE      OFF)
	set_and_warn(WITH_INTERNATIONAL  OFF)

	set_and_warn(WITH_OPENAL         OFF)  # depends on AUDASPACE
	set_and_warn(WITH_GAMEENGINE     OFF)  # depends on AUDASPACE
elseif(WITH_CYCLES OR WITH_OPENIMAGEIO OR WITH_MOD_BOOLEAN OR WITH_AUDASPACE OR WITH_INTERNATIONAL)
	# Keep enabled
else()
	# Enabled but we don't need it
	set(WITH_BOOST OFF)
endif()

# auto enable openimageio for cycles
if(WITH_CYCLES)
	set(WITH_OPENIMAGEIO ON)
endif()

# auto enable openimageio linking dependencies
if(WITH_OPENIMAGEIO)
	set(WITH_IMAGE_OPENEXR ON)
	set(WITH_IMAGE_TIFF ON)
endif()

# auto enable llvm for cycles_osl
if(WITH_CYCLES_OSL)
	set(WITH_LLVM ON CACHE BOOL "ON" FORCE)
endif()

# don't store paths to libs for portable distribution
if(WITH_INSTALL_PORTABLE)
	set(CMAKE_SKIP_BUILD_RPATH TRUE)
endif()

if(WITH_GHOST_SDL OR WITH_HEADLESS)
	set(WITH_GHOST_XDND OFF)
	set(WITH_X11_XF86VMODE OFF)
	set(WITH_X11_XINPUT OFF)
endif()

TEST_SSE_SUPPORT(COMPILER_SSE_FLAG COMPILER_SSE2_FLAG)

TEST_STDBOOL_SUPPORT()
if(HAVE_STDBOOL_H)
	add_definitions(-DHAVE_STDBOOL_H)
endif()
if(WITH_BOOL_COMPAT)
	add_definitions(-DWITH_BOOL_COMPAT)
endif()

#-----------------------------------------------------------------------------
# Check for valid directories
# ... a partial checkout may cause this.
#
# note: we need to check for a known subdir in both cases.
#       since uninitialized git submodules will give blank dirs

if(WITH_INTERNATIONAL)
	if(NOT EXISTS "${CMAKE_SOURCE_DIR}/release/datafiles/locale/languages")
		message(WARNING "Translation path '${CMAKE_SOURCE_DIR}/release/datafiles/locale' is missing, "
						"This is a 'git submodule', which are known not to work with bridges to other version "
						"control systems, disabling 'WITH_INTERNATIONAL'.")
		set(WITH_INTERNATIONAL OFF)
	endif()
endif()

if(WITH_PYTHON)
	if(NOT EXISTS "${CMAKE_SOURCE_DIR}/release/scripts/addons/modules")
		message(WARNING "Addons path '${CMAKE_SOURCE_DIR}/release/scripts/addons' is missing, "
						"This is a 'git submodule', which are known not to work with bridges to other version "
						"control systems: * CONTINUING WITHOUT ADDONS *")
	endif()
endif()

#-----------------------------------------------------------------------------
# Initialize un-cached vars, avoid unused warning

# linux only, not cached
set(WITH_BINRELOC OFF)

# MAXOSX only, set to avoid uninitialized
set(EXETYPE "")

# C/C++ flags
set(PLATFORM_CFLAGS)

# these are added to later on.
set(C_WARNINGS)
set(CXX_WARNINGS)

# for gcc -Wno-blah-blah
set(CC_REMOVE_STRICT_FLAGS)

# libraries to link the binary with passed to target_link_libraries()
# known as LLIBS to scons
set(PLATFORM_LINKLIBS "")

# Added to linker flags in setup_liblinks
# - CMAKE_EXE_LINKER_FLAGS
# - CMAKE_EXE_LINKER_FLAGS_DEBUG
set(PLATFORM_LINKFLAGS "")
set(PLATFORM_LINKFLAGS_DEBUG "")


# For alternate Python locations the commandline can be used to override detected/default cache settings, e.g:
# On Unix:
#   cmake ../blender \
#         -D PYTHON_VERSION=3.3 \
#         -D PYTHON_INCLUDE_DIR=/opt/py33/include/python3.3d \
#         -D PYTHON_LIBRARY=/opt/py33/lib/libpython3.3d.so
#
# On Macs:
#   cmake ../blender \
#         -D PYTHON_INCLUDE_DIR=/System/Library/Frameworks/Python.framework/Versions/3.3/include/python3.3 \
#         -D PYTHON_LIBPATH=/System/Library/Frameworks/Python.framework/Versions/3.3/lib/python3.3/config \
#         -G Xcode
#
# When changing any of this remember to update the notes in doc/build_systems/cmake.txt

#-----------------------------------------------------------------------------
#Platform specifics

if(UNIX AND NOT APPLE)
	macro(find_package_wrapper)
		string(TOUPPER ${ARGV0} _NAME_UPPER)
		if(WITH_STATIC_LIBS)
			set(_cmake_find_library_suffixes_back ${CMAKE_FIND_LIBRARY_SUFFIXES})
			set(CMAKE_FIND_LIBRARY_SUFFIXES .a ${CMAKE_FIND_LIBRARY_SUFFIXES})
		endif()
		find_package(${ARGV})
		if(WITH_STATIC_LIBS)
			set(CMAKE_FIND_LIBRARY_SUFFIXES ${_cmake_find_library_suffixes_back})
			unset(_cmake_find_library_suffixes_back)
		endif()
	endmacro()

	find_package_wrapper(JPEG REQUIRED)
	find_package_wrapper(PNG REQUIRED)
	find_package_wrapper(ZLIB REQUIRED)
	find_package_wrapper(Freetype REQUIRED)

	if(WITH_PYTHON)
		# No way to set py33. remove for now.
		# find_package(PythonLibs)

		# Use our own instead, since wothout py is such a rare case,
		# require this package
		# XXX Linking errors with debian static python :/
#		find_package_wrapper(PythonLibsUnix REQUIRED)
		find_package(PythonLibsUnix REQUIRED)
	endif()

	if(WITH_IMAGE_OPENEXR)
		find_package_wrapper(OpenEXR)  # our own module
		if(NOT OPENEXR_FOUND)
			set(WITH_IMAGE_OPENEXR OFF)
		endif()
	endif()

	if(WITH_IMAGE_OPENJPEG)
		find_package_wrapper(OpenJPEG)
		if(NOT OPENJPEG_FOUND)
			set(WITH_IMAGE_OPENJPEG OFF)
		endif()
	endif()

	if(WITH_IMAGE_TIFF)
		# XXX Linking errors with debian static tiff :/
#		find_package_wrapper(TIFF)
		find_package(TIFF)
		if(NOT TIFF_FOUND)
			set(WITH_IMAGE_TIFF OFF)
		endif()
	endif()

	# Audio IO
	if(WITH_OPENAL)
		find_package_wrapper(OpenAL)
		if(NOT OPENAL_FOUND)
			set(WITH_OPENAL OFF)
		endif()
	endif()

	if(WITH_SDL)
		find_package_wrapper(SDL)
		mark_as_advanced(
			SDLMAIN_LIBRARY
			SDL_INCLUDE_DIR
			SDL_LIBRARY
			SDL_LIBRARY_TEMP
		)
		# unset(SDLMAIN_LIBRARY CACHE)
		if(NOT SDL_FOUND)
			set(WITH_SDL OFF)
		endif()
	endif()

	if(WITH_JACK)
		find_package_wrapper(Jack)
		if(NOT JACK_FOUND)
			set(WITH_JACK OFF)
		endif()
	endif()

	# Codecs
	if(WITH_CODEC_SNDFILE)
		find_package_wrapper(SndFile)
		if(NOT SNDFILE_FOUND)
			set(WITH_CODEC_SNDFILE OFF)
		endif()
	endif()

	if(WITH_CODEC_FFMPEG)
		set(FFMPEG /usr CACHE PATH "FFMPEG Directory")
		set(FFMPEG_LIBRARIES avformat avcodec avutil avdevice swscale CACHE STRING "FFMPEG Libraries")

		mark_as_advanced(FFMPEG)

		# lame, but until we have proper find module for ffmpeg
		set(FFMPEG_INCLUDE_DIRS ${FFMPEG}/include)
		if(EXISTS "${FFMPEG}/include/ffmpeg/")
			list(APPEND FFMPEG_INCLUDE_DIRS "${FFMPEG}/include/ffmpeg")
		endif()
		# end lameness

		mark_as_advanced(FFMPEG_LIBRARIES)
		set(FFMPEG_LIBPATH ${FFMPEG}/lib)
		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -D__STDC_CONSTANT_MACROS")
	endif()

	if(WITH_FFTW3)
		find_package_wrapper(Fftw3)
		if(NOT FFTW3_FOUND)
			set(WITH_FFTW3 OFF)
		endif()
	endif()

	if(WITH_OPENCOLLADA)
		find_package_wrapper(OpenCOLLADA)
		if(OPENCOLLADA_FOUND)
			find_package_wrapper(XML2)
			find_package_wrapper(PCRE)
		else()
			set(WITH_OPENCOLLADA OFF)
		endif()
	endif()

	if(WITH_MEM_JEMALLOC)
		find_package_wrapper(JeMalloc)
		if(NOT JEMALLOC_FOUND)
			set(WITH_MEM_JEMALLOC OFF)
		endif()
	endif()

	if(WITH_INPUT_NDOF)
		find_package_wrapper(Spacenav)
		if(NOT SPACENAV_FOUND)
			set(WITH_INPUT_NDOF OFF)
		endif()

		# use generic names within blenders buildsystem.
		if(SPACENAV_FOUND)
			set(NDOF_INCLUDE_DIRS ${SPACENAV_INCLUDE_DIRS})
			set(NDOF_LIBRARIES ${SPACENAV_LIBRARIES})
		endif()
	endif()

	if(WITH_BOOST)
		# uses in build instructions to override include and library variables
		if(NOT BOOST_CUSTOM)
			if(WITH_STATIC_LIBS)
				set(Boost_USE_STATIC_LIBS ON)
			endif()
			set(Boost_USE_MULTITHREADED ON)
			set(__boost_packages filesystem regex system thread date_time)
			if(WITH_INTERNATIONAL)
				list(APPEND __boost_packages locale)
			endif()
			if(WITH_CYCLES_NETWORK)
				list(APPEND __boost_packages serialization)
			endif()
			find_package(Boost 1.48 COMPONENTS ${__boost_packages})
			if(NOT Boost_FOUND)
				# try to find non-multithreaded if -mt not found, this flag
				# doesn't matter for us, it has nothing to do with thread
				# safety, but keep it to not disturb build setups
				set(Boost_USE_MULTITHREADED OFF)
				find_package(Boost 1.48 COMPONENTS ${__boost_packages})
			endif()
			unset(__boost_packages)
			if(Boost_USE_STATIC_LIBS AND WITH_BOOST_ICU)
				find_package(IcuLinux)
			endif()
			mark_as_advanced(Boost_DIR)  # why doesnt boost do this?
		endif()

		set(BOOST_INCLUDE_DIR ${Boost_INCLUDE_DIRS})
		set(BOOST_LIBRARIES ${Boost_LIBRARIES})
		set(BOOST_LIBPATH ${Boost_LIBRARY_DIRS})
		set(BOOST_DEFINITIONS "-DBOOST_ALL_NO_LIB")
	endif()

	if(WITH_OPENIMAGEIO)
		find_package_wrapper(OpenImageIO)

		set(OPENIMAGEIO_LIBRARIES ${OPENIMAGEIO_LIBRARIES} ${PNG_LIBRARIES} ${JPEG_LIBRARIES} ${ZLIB_LIBRARIES} ${BOOST_LIBRARIES})
		set(OPENIMAGEIO_LIBPATH)  # TODO, remove and reference the absolute path everywhere
		set(OPENIMAGEIO_DEFINITIONS "")

		if(WITH_IMAGE_TIFF)
			list(APPEND OPENIMAGEIO_LIBRARIES "${TIFF_LIBRARY}")
		endif()
		if(WITH_IMAGE_OPENEXR)
			list(APPEND OPENIMAGEIO_LIBRARIES "${OPENEXR_LIBRARIES}")
		endif()

		if(NOT OPENIMAGEIO_FOUND)
			set(WITH_OPENIMAGEIO OFF)
			message(STATUS "OpenImageIO not found, disabling WITH_CYCLES")
		endif()
	endif()

	if(WITH_OPENCOLORIO)
		find_package_wrapper(OpenColorIO)

		set(OPENCOLORIO_LIBRARIES ${OPENCOLORIO_LIBRARIES})
		set(OPENCOLORIO_LIBPATH)  # TODO, remove and reference the absolute path everywhere
		set(OPENCOLORIO_DEFINITIONS)

		if(NOT OPENCOLORIO_FOUND)
			set(WITH_OPENCOLORIO OFF)
			message(STATUS "OpenColorIO not found")
		endif()
	endif()

	# XXX Maybe most of this section should go into an llvm module?
	if(WITH_LLVM)
		# Set llvm version if not specified
		if(NOT LLVM_VERSION)
			set(LLVM_VERSION "3.0")
		endif()

		if(LLVM_DIRECTORY)
			find_program(LLVM_CONFIG llvm-config-${LLVM_VERSION} HINTS ${LLVM_DIRECTORY}/bin NO_CMAKE_PATH)
			if(NOT LLVM_CONFIG)
				find_program(LLVM_CONFIG llvm-config HINTS ${LLVM_DIRECTORY}/bin NO_CMAKE_PATH)
			endif()
		else()
			find_program(LLVM_CONFIG llvm-config-${LLVM_VERSION})
			if(NOT LLVM_CONFIG)
				find_program(LLVM_CONFIG llvm-config)
			endif()
		endif()

		if(NOT DEFINED LLVM_VERSION)
			execute_process(COMMAND ${LLVM_CONFIG} --version
							OUTPUT_VARIABLE LLVM_VERSION
							OUTPUT_STRIP_TRAILING_WHITESPACE)
			set(LLVM_VERSION ${LLVM_VERSION} CACHE STRING "Version of LLVM to use")
		endif()
		if(NOT DEFINED LLVM_DIRECTORY)
			execute_process(COMMAND ${LLVM_CONFIG} --prefix
							OUTPUT_VARIABLE LLVM_DIRECTORY
							OUTPUT_STRIP_TRAILING_WHITESPACE)
			set(LLVM_DIRECTORY ${LLVM_DIRECTORY} CACHE PATH "Path to the LLVM installation")
		endif()
		if(NOT DEFINED LLVM_LIBPATH)
			execute_process(COMMAND ${LLVM_CONFIG} --libdir
							OUTPUT_VARIABLE LLVM_LIBPATH
							OUTPUT_STRIP_TRAILING_WHITESPACE)
			set(LLVM_LIBPATH ${LLVM_LIBPATH} CACHE PATH "Path to the LLVM library path")
		endif()

		if(LLVM_STATIC)
			find_library(LLVM_LIBRARY
			             NAMES LLVMAnalysis # first of a whole bunch of libs to get
			             PATHS ${LLVM_LIBPATH})
		else()
			find_library(LLVM_LIBRARY
			             NAMES LLVM-${LLVM_VERSION}
			             PATHS ${LLVM_LIBPATH})
		endif()


		if(LLVM_LIBRARY AND LLVM_DIRECTORY AND LLVM_LIBPATH)
			if(LLVM_STATIC)
				# if static LLVM libraries were requested, use llvm-config to generate
				# the list of what libraries we need, and substitute that in the right
				# way for LLVM_LIBRARY.
				execute_process(COMMAND ${LLVM_CONFIG} --libfiles
				                OUTPUT_VARIABLE LLVM_LIBRARY
				                OUTPUT_STRIP_TRAILING_WHITESPACE)
				string(REPLACE " " ";" LLVM_LIBRARY "${LLVM_LIBRARY}")
			endif()
		else()
			message(FATAL_ERROR "LLVM not found.")
		endif()

		# Fix for conflict with Mesa llvmpipe
		set(PLATFORM_LINKFLAGS "${PLATFORM_LINKFLAGS} -Wl,--version-script=${CMAKE_SOURCE_DIR}/source/creator/blender.map")
	endif()

	if(WITH_CYCLES_OSL)
		set(CYCLES_OSL ${LIBDIR}/osl CACHE PATH "Path to OpenShadingLanguage installation")
	
		message(STATUS "CYCLES_OSL = ${CYCLES_OSL}")
	
		find_library(OSL_LIB_EXEC NAMES oslexec PATHS ${CYCLES_OSL}/lib)
		find_library(OSL_LIB_COMP NAMES oslcomp PATHS ${CYCLES_OSL}/lib)
		find_library(OSL_LIB_QUERY NAMES oslquery PATHS ${CYCLES_OSL}/lib)
		# Note: --whole-archive is needed to force loading of all symbols in liboslexec,
		# otherwise LLVM is missing the osl_allocate_closure_component function
		list(APPEND OSL_LIBRARIES ${OSL_LIB_COMP} -Wl,--whole-archive ${OSL_LIB_EXEC} -Wl,--no-whole-archive ${OSL_LIB_QUERY})
		find_path(OSL_INCLUDES OSL/oslclosure.h PATHS ${CYCLES_OSL}/include)
		find_program(OSL_COMPILER NAMES oslc PATHS ${CYCLES_OSL}/bin)
	
		if(OSL_INCLUDES AND OSL_LIBRARIES AND OSL_COMPILER)
			set(OSL_FOUND TRUE)
			message(STATUS "OSL includes = ${OSL_INCLUDES}")
			message(STATUS "OSL library = ${OSL_LIBRARIES}")
			message(STATUS "OSL compiler = ${OSL_COMPILER}")
		else()
			message(STATUS "OSL not found")
		endif()
	endif()

	# OpenSuse needs lutil, ArchLinux not, for now keep, can avoid by using --as-needed
	set(PLATFORM_LINKLIBS "-lutil -lc -lm -lpthread")

	if((NOT WITH_HEADLESS) AND (NOT WITH_GHOST_SDL))
		find_package(X11 REQUIRED)
		find_path(X11_XF86keysym_INCLUDE_PATH X11/XF86keysym.h ${X11_INC_SEARCH_PATH})
		mark_as_advanced(X11_XF86keysym_INCLUDE_PATH)

		set(PLATFORM_LINKLIBS "${PLATFORM_LINKLIBS} ${X11_X11_LIB}")

		if(WITH_X11_XINPUT)
			if(X11_Xinput_LIB)
				set(PLATFORM_LINKLIBS "${PLATFORM_LINKLIBS} ${X11_Xinput_LIB}")
			else()
				set(WITH_X11_XINPUT OFF)
			endif()
		endif()

		if(WITH_X11_XF86VMODE)
			# XXX, why dont cmake make this available?
			FIND_LIBRARY(X11_Xxf86vmode_LIB Xxf86vm   ${X11_LIB_SEARCH_PATH})
			mark_as_advanced(X11_Xxf86vmode_LIB)
			if(X11_Xxf86vmode_LIB)
				set(PLATFORM_LINKLIBS "${PLATFORM_LINKLIBS} ${X11_Xxf86vmode_LIB}")
			else()
				set(WITH_X11_XF86VMODE OFF)
			endif()
		endif()
	endif()

	if(CMAKE_SYSTEM_NAME MATCHES "Linux")
		if(NOT WITH_PYTHON_MODULE)
			# binreloc is linux only
			set(BINRELOC_INCLUDE_DIRS ${CMAKE_SOURCE_DIR}/extern/binreloc/include)
			set(WITH_BINRELOC ON)
		endif()
	endif()

	set(PLATFORM_LINKFLAGS "${PLATFORM_LINKFLAGS} -pthread")

	# lfs on glibc, all compilers should use
	add_definitions(-D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 -D_LARGEFILE64_SOURCE)

	# GNU Compiler
	if(CMAKE_COMPILER_IS_GNUCC)
		set(PLATFORM_CFLAGS "-pipe -fPIC -funsigned-char -fno-strict-aliasing")
	# CLang is the same as GCC for now.
	elseif(CMAKE_C_COMPILER_ID MATCHES "Clang")
		set(PLATFORM_CFLAGS "-pipe -fPIC -funsigned-char -fno-strict-aliasing")
	# Solaris CC
	elseif(CMAKE_C_COMPILER_ID MATCHES "SunPro")
		set(PLATFORM_CFLAGS "-pipe -features=extensions -fPIC -D__FUNCTION__=__func__")
		
	# Intel C++ Compiler
	elseif(CMAKE_C_COMPILER_ID MATCHES "Intel")
		# think these next two are broken
		find_program(XIAR xiar)
		if(XIAR)
			set(CMAKE_AR "${XIAR}")
		endif()
		mark_as_advanced(XIAR)

		find_program(XILD xild)
		if(XILD)
			set(CMAKE_LINKER "${XILD}")
		endif()
		mark_as_advanced(XILD)

		set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fp-model precise -prec_div -parallel")
		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fp-model precise -prec_div -parallel")

		# set(PLATFORM_CFLAGS "${PLATFORM_CFLAGS} -diag-enable sc3")
		set(PLATFORM_CFLAGS "-pipe -fPIC -funsigned-char -fno-strict-aliasing")
		set(PLATFORM_LINKFLAGS "${PLATFORM_LINKFLAGS} -static-intel")
	endif()

elseif(WIN32)

	add_definitions(-DWIN32)

	if(MSVC)
		set(PLATFORM_LINKLIBS ws2_32 vfw32 winmm kernel32 user32 gdi32 comdlg32 advapi32 shfolder shell32 ole32 oleaut32 uuid psapi)

		# MSVC11 SDL is not hard linked to dxguid.lib
		if(MSVC11 AND WITH_SDL)
			set(PLATFORM_LINKLIBS ${PLATFORM_LINKLIBS} dxguid)
		endif()

		add_definitions(
			-D_CRT_NONSTDC_NO_DEPRECATE
			-D_CRT_SECURE_NO_DEPRECATE
			-D_SCL_SECURE_NO_DEPRECATE
			-D_CONSOLE
			-D_LIB
		)

		# MSVC11 needs _ALLOW_KEYWORD_MACROS to build
		if(NOT MSVC_VERSION VERSION_LESS 1700)
			add_definitions(-D_ALLOW_KEYWORD_MACROS)
		endif()

		if(CMAKE_CL_64)
			# We want to support Vista level ABI for x64
			if(NOT MSVC_VERSION VERSION_LESS 1700)
				add_definitions(-D_WIN32_WINNT=0x600)
			endif()
		endif()

		set(CMAKE_CXX_FLAGS "/nologo /J /Gd /EHsc /MP" CACHE STRING "MSVC MT C++ flags " FORCE)